text:
using AWS
using AWS.AWSServices: route53_recovery_readiness
using AWS.Compat
using AWS.UUIDs

"""
    create_cell(cell_name)
    create_cell(cell_name, params::Dict{String,<:Any})

Creates a new Cell.

# Arguments
- `cell_name`: The name of the Cell to create

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cells"`: A list of Cell arns contained within this Cell (for use in nested Cells, e.g.
  regions within which AZs)
- `"tags"`:
"""
function create_cell(cellName; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "POST",
        "/cells",
        Dict{String,Any}("cellName" => cellName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_cell(
    cellName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/cells",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("cellName" => cellName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_cross_account_authorization(cross_account_authorization)
    create_cross_account_authorization(cross_account_authorization, params::Dict{String,<:Any})

Create a new cross account readiness authorization.

# Arguments
- `cross_account_authorization`: The cross account authorization

"""
function create_cross_account_authorization(
    crossAccountAuthorization; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "POST",
        "/crossaccountauthorizations",
        Dict{String,Any}("crossAccountAuthorization" => crossAccountAuthorization);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_cross_account_authorization(
    crossAccountAuthorization,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/crossaccountauthorizations",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}("crossAccountAuthorization" => crossAccountAuthorization),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_readiness_check(readiness_check_name, resource_set_name)
    create_readiness_check(readiness_check_name, resource_set_name, params::Dict{String,<:Any})

Creates a new Readiness Check.

# Arguments
- `readiness_check_name`: The name of the ReadinessCheck to create
- `resource_set_name`: The name of the ResourceSet to check

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`:
"""
function create_readiness_check(
    readinessCheckName, resourceSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "POST",
        "/readinesschecks",
        Dict{String,Any}(
            "readinessCheckName" => readinessCheckName, "resourceSetName" => resourceSetName
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_readiness_check(
    readinessCheckName,
    resourceSetName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/readinesschecks",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "readinessCheckName" => readinessCheckName,
                    "resourceSetName" => resourceSetName,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_recovery_group(recovery_group_name)
    create_recovery_group(recovery_group_name, params::Dict{String,<:Any})

Creates a new Recovery Group.

# Arguments
- `recovery_group_name`: The name of the RecoveryGroup to create

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"cells"`: A list of Cell arns
- `"tags"`:
"""
function create_recovery_group(
    recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "POST",
        "/recoverygroups",
        Dict{String,Any}("recoveryGroupName" => recoveryGroupName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_recovery_group(
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/recoverygroups",
        Dict{String,Any}(
            mergewith(
                _merge, Dict{String,Any}("recoveryGroupName" => recoveryGroupName), params
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_resource_set(resource_set_name, resource_set_type, resources)
    create_resource_set(resource_set_name, resource_set_type, resources, params::Dict{String,<:Any})

Creates a new Resource Set.

# Arguments
- `resource_set_name`: The name of the ResourceSet to create
- `resource_set_type`: AWS Resource type of the resources in the ResourceSet
- `resources`: A list of Resource objects

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"tags"`:
"""
function create_resource_set(
    resourceSetName,
    resourceSetType,
    resources;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/resourcesets",
        Dict{String,Any}(
            "resourceSetName" => resourceSetName,
            "resourceSetType" => resourceSetType,
            "resources" => resources,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_resource_set(
    resourceSetName,
    resourceSetType,
    resources,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/resourcesets",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "resourceSetName" => resourceSetName,
                    "resourceSetType" => resourceSetType,
                    "resources" => resources,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_cell(cell_name)
    delete_cell(cell_name, params::Dict{String,<:Any})

Deletes an existing Cell.

# Arguments
- `cell_name`: The Cell to delete

"""
function delete_cell(cellName; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "DELETE",
        "/cells/$(cellName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_cell(
    cellName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/cells/$(cellName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_cross_account_authorization(cross_account_authorization)
    delete_cross_account_authorization(cross_account_authorization, params::Dict{String,<:Any})

Delete cross account readiness authorization

# Arguments
- `cross_account_authorization`: The cross account authorization

"""
function delete_cross_account_authorization(
    crossAccountAuthorization; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "DELETE",
        "/crossaccountauthorizations/$(crossAccountAuthorization)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_cross_account_authorization(
    crossAccountAuthorization,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/crossaccountauthorizations/$(crossAccountAuthorization)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_readiness_check(readiness_check_name)
    delete_readiness_check(readiness_check_name, params::Dict{String,<:Any})

Deletes an existing Readiness Check.

# Arguments
- `readiness_check_name`: The ReadinessCheck to delete

"""
function delete_readiness_check(
    readinessCheckName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "DELETE",
        "/readinesschecks/$(readinessCheckName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_readiness_check(
    readinessCheckName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/readinesschecks/$(readinessCheckName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_recovery_group(recovery_group_name)
    delete_recovery_group(recovery_group_name, params::Dict{String,<:Any})

Deletes an existing Recovery Group.

# Arguments
- `recovery_group_name`: The RecoveryGroup to delete

"""
function delete_recovery_group(
    recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "DELETE",
        "/recoverygroups/$(recoveryGroupName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_recovery_group(
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/recoverygroups/$(recoveryGroupName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_resource_set(resource_set_name)
    delete_resource_set(resource_set_name, params::Dict{String,<:Any})

Deletes an existing Resource Set.

# Arguments
- `resource_set_name`: The ResourceSet to delete

"""
function delete_resource_set(
    resourceSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "DELETE",
        "/resourcesets/$(resourceSetName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_resource_set(
    resourceSetName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/resourcesets/$(resourceSetName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_architecture_recommendations(recovery_group_name)
    get_architecture_recommendations(recovery_group_name, params::Dict{String,<:Any})

Returns a collection of recommendations to improve resilliance and readiness check quality
for a Recovery Group.

# Arguments
- `recovery_group_name`: Name of RecoveryGroup (top level resource) to be analyzed.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token that can be used to resume pagination from the end of the
  collection.
"""
function get_architecture_recommendations(
    recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroups/$(recoveryGroupName)/architectureRecommendations";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_architecture_recommendations(
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroups/$(recoveryGroupName)/architectureRecommendations",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_cell(cell_name)
    get_cell(cell_name, params::Dict{String,<:Any})

Returns information about a Cell.

# Arguments
- `cell_name`: The Cell to get

"""
function get_cell(cellName; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/cells/$(cellName)"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function get_cell(
    cellName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/cells/$(cellName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_cell_readiness_summary(cell_name)
    get_cell_readiness_summary(cell_name, params::Dict{String,<:Any})

Returns information about readiness of a Cell.

# Arguments
- `cell_name`: The name of the Cell

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function get_cell_readiness_summary(
    cellName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/cellreadiness/$(cellName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_cell_readiness_summary(
    cellName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/cellreadiness/$(cellName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_readiness_check(readiness_check_name)
    get_readiness_check(readiness_check_name, params::Dict{String,<:Any})

Returns information about a ReadinessCheck.

# Arguments
- `readiness_check_name`: The ReadinessCheck to get

"""
function get_readiness_check(
    readinessCheckName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_readiness_check(
    readinessCheckName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_readiness_check_resource_status(readiness_check_name, resource_identifier)
    get_readiness_check_resource_status(readiness_check_name, resource_identifier, params::Dict{String,<:Any})

Returns detailed information about the status of an individual resource within a Readiness
Check's Resource Set.

# Arguments
- `readiness_check_name`: The ReadinessCheck to get
- `resource_identifier`: The resource ARN or component Id to get

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function get_readiness_check_resource_status(
    readinessCheckName,
    resourceIdentifier;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)/resource/$(resourceIdentifier)/status";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_readiness_check_resource_status(
    readinessCheckName,
    resourceIdentifier,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)/resource/$(resourceIdentifier)/status",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_readiness_check_status(readiness_check_name)
    get_readiness_check_status(readiness_check_name, params::Dict{String,<:Any})

Returns information about the status of a Readiness Check.

# Arguments
- `readiness_check_name`: The ReadinessCheck to get

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function get_readiness_check_status(
    readinessCheckName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)/status";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_readiness_check_status(
    readinessCheckName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks/$(readinessCheckName)/status",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_recovery_group(recovery_group_name)
    get_recovery_group(recovery_group_name, params::Dict{String,<:Any})

Returns information about a Recovery Group.

# Arguments
- `recovery_group_name`: The RecoveryGroup to get

"""
function get_recovery_group(
    recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroups/$(recoveryGroupName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_recovery_group(
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroups/$(recoveryGroupName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_recovery_group_readiness_summary(recovery_group_name)
    get_recovery_group_readiness_summary(recovery_group_name, params::Dict{String,<:Any})

Returns information about a Recovery Group.

# Arguments
- `recovery_group_name`: The name of the RecoveryGroup

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function get_recovery_group_readiness_summary(
    recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroupreadiness/$(recoveryGroupName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_recovery_group_readiness_summary(
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroupreadiness/$(recoveryGroupName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_resource_set(resource_set_name)
    get_resource_set(resource_set_name, params::Dict{String,<:Any})

Returns information about a Resource Set.

# Arguments
- `resource_set_name`: The ResourceSet to get

"""
function get_resource_set(
    resourceSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/resourcesets/$(resourceSetName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_resource_set(
    resourceSetName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/resourcesets/$(resourceSetName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_cells()
    list_cells(params::Dict{String,<:Any})

Returns a collection of Cells.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function list_cells(; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/cells"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_cells(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET", "/cells", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end

"""
    list_cross_account_authorizations()
    list_cross_account_authorizations(params::Dict{String,<:Any})

Returns a collection of cross account readiness authorizations.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function list_cross_account_authorizations(;
    aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/crossaccountauthorizations";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_cross_account_authorizations(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/crossaccountauthorizations",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_readiness_checks()
    list_readiness_checks(params::Dict{String,<:Any})

Returns a collection of Readiness Checks.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function list_readiness_checks(; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/readinesschecks"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_readiness_checks(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/readinesschecks",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_recovery_groups()
    list_recovery_groups(params::Dict{String,<:Any})

Returns a collection of Recovery Groups.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function list_recovery_groups(; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/recoverygroups"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_recovery_groups(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/recoverygroups",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_resource_sets()
    list_resource_sets(params::Dict{String,<:Any})

Returns a collection of Resource Sets.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
"""
function list_resource_sets(; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/resourcesets"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_resource_sets(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/resourcesets",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_rules()
    list_rules(params::Dict{String,<:Any})

Returns a collection of rules that are applied as part of Readiness Checks.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Upper bound on number of records to return.
- `"nextToken"`: A token used to resume pagination from the end of a previous request.
- `"resourceType"`: Filter parameter which specifies the rules to return given a resource
  type.
"""
function list_rules(; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "GET", "/rules"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_rules(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET", "/rules", params; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end

"""
    list_tags_for_resources(resource-arn)
    list_tags_for_resources(resource-arn, params::Dict{String,<:Any})

Returns a list of the tags assigned to the specified resource.

# Arguments
- `resource-arn`: The Amazon Resource Name (ARN) for the resource. You can get this from
  the response to any request to the resource.

"""
function list_tags_for_resources(
    resource_arn; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "GET",
        "/tags/$(resource-arn)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_tags_for_resources(
    resource_arn,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "GET",
        "/tags/$(resource-arn)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    tag_resource(resource-arn, tags)
    tag_resource(resource-arn, tags, params::Dict{String,<:Any})

Adds tags to the specified resource. You can specify one or more tags to add.

# Arguments
- `resource-arn`: The Amazon Resource Name (ARN) for the resource. You can get this from
  the response to any request to the resource.
- `tags`:

"""
function tag_resource(resource_arn, tags; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "POST",
        "/tags/$(resource-arn)",
        Dict{String,Any}("tags" => tags);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function tag_resource(
    resource_arn,
    tags,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "POST",
        "/tags/$(resource-arn)",
        Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tags" => tags), params));
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    untag_resource(resource-arn, tag_keys)
    untag_resource(resource-arn, tag_keys, params::Dict{String,<:Any})

Removes tags from the specified resource. You can specify one or more tags to remove.

# Arguments
- `resource-arn`: The Amazon Resource Name (ARN) for the resource. You can get this from
  the response to any request to the resource.
- `tag_keys`: A comma-separated list of the tag keys to remove from the resource.

"""
function untag_resource(
    resource_arn, tagKeys; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "DELETE",
        "/tags/$(resource-arn)",
        Dict{String,Any}("tagKeys" => tagKeys);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function untag_resource(
    resource_arn,
    tagKeys,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "DELETE",
        "/tags/$(resource-arn)",
        Dict{String,Any}(mergewith(_merge, Dict{String,Any}("tagKeys" => tagKeys), params));
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_cell(cell_name, cells)
    update_cell(cell_name, cells, params::Dict{String,<:Any})

Updates an existing Cell.

# Arguments
- `cell_name`: The Cell to update
- `cells`: A list of Cell arns, completely replaces previous list

"""
function update_cell(cellName, cells; aws_config::AbstractAWSConfig=global_aws_config())
    return route53_recovery_readiness(
        "PUT",
        "/cells/$(cellName)",
        Dict{String,Any}("cells" => cells);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_cell(
    cellName,
    cells,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "PUT",
        "/cells/$(cellName)",
        Dict{String,Any}(mergewith(_merge, Dict{String,Any}("cells" => cells), params));
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_readiness_check(readiness_check_name, resource_set_name)
    update_readiness_check(readiness_check_name, resource_set_name, params::Dict{String,<:Any})

Updates an exisiting Readiness Check.

# Arguments
- `readiness_check_name`: The ReadinessCheck to update
- `resource_set_name`: The name of the ResourceSet to check

"""
function update_readiness_check(
    readinessCheckName, resourceSetName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "PUT",
        "/readinesschecks/$(readinessCheckName)",
        Dict{String,Any}("resourceSetName" => resourceSetName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_readiness_check(
    readinessCheckName,
    resourceSetName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "PUT",
        "/readinesschecks/$(readinessCheckName)",
        Dict{String,Any}(
            mergewith(
                _merge, Dict{String,Any}("resourceSetName" => resourceSetName), params
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_recovery_group(cells, recovery_group_name)
    update_recovery_group(cells, recovery_group_name, params::Dict{String,<:Any})

Updates an existing Recovery Group.

# Arguments
- `cells`: A list of Cell arns, completely replaces previous list
- `recovery_group_name`: The RecoveryGroup to update

"""
function update_recovery_group(
    cells, recoveryGroupName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_readiness(
        "PUT",
        "/recoverygroups/$(recoveryGroupName)",
        Dict{String,Any}("cells" => cells);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_recovery_group(
    cells,
    recoveryGroupName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "PUT",
        "/recoverygroups/$(recoveryGroupName)",
        Dict{String,Any}(mergewith(_merge, Dict{String,Any}("cells" => cells), params));
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_resource_set(resource_set_name, resource_set_type, resources)
    update_resource_set(resource_set_name, resource_set_type, resources, params::Dict{String,<:Any})

Updates an existing Resource Set.

# Arguments
- `resource_set_name`: The ResourceSet to update
- `resource_set_type`: AWS Resource Type of the resources in the ResourceSet
- `resources`: A list of Resource objects

"""
function update_resource_set(
    resourceSetName,
    resourceSetType,
    resources;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "PUT",
        "/resourcesets/$(resourceSetName)",
        Dict{String,Any}("resourceSetType" => resourceSetType, "resources" => resources);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_resource_set(
    resourceSetName,
    resourceSetType,
    resources,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_readiness(
        "PUT",
        "/resourcesets/$(resourceSetName)",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "resourceSetType" => resourceSetType, "resources" => resources
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end


text:
  <title>The source code</title>
    <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />

/**
 * @class Ext.dd.PanelProxy
 * A custom drag proxy implementation specific to {@link Ext.Panel}s. This class is primarily used internally
 * for the Panel's drag drop implementation, and should never need to be created directly.
 * @constructor
 * @param panel The {@link Ext.Panel} to proxy for
 * @param config Configuration options
 */
Ext.dd.PanelProxy = function(panel, config){
    this.panel = panel;
    this.id = this.panel.id +'-ddproxy';
    Ext.apply(this, config);
};

Ext.dd.PanelProxy.prototype = {

/**
     * @cfg {Boolean} insertProxy True to insert a placeholder proxy element while dragging the panel,
     * false to drag with no proxy (defaults to true).
     */
    insertProxy : true,

    // private overrides
    setStatus : Ext.emptyFn,
    reset : Ext.emptyFn,
    update : Ext.emptyFn,
    stop : Ext.emptyFn,
    sync: Ext.emptyFn,

/**
     * Gets the proxy's element
     * @return {Element} The proxy's element
     */
    getEl : function(){
        return this.ghost;
    },

/**
     * Gets the proxy's ghost element
     * @return {Element} The proxy's ghost element
     */
    getGhost : function(){
        return this.ghost;
    },

/**
     * Gets the proxy's element
     * @return {Element} The proxy's element
     */
    getProxy : function(){
        return this.proxy;
    },

/**
     * Hides the proxy
     */
    hide : function(){
        if(this.ghost){
            if(this.proxy){
                this.proxy.remove();
                delete this.proxy;
            }
            this.panel.el.dom.style.display = '';
            this.ghost.remove();
            delete this.ghost;
        }
    },

/**
     * Shows the proxy
     */
    show : function(){
        if(!this.ghost){
            this.ghost = this.panel.createGhost(undefined, undefined, Ext.getBody());
            this.ghost.setXY(this.panel.el.getXY())
            if(this.insertProxy){
                this.proxy = this.panel.el.insertSibling({cls:'x-panel-dd-spacer'});
                this.proxy.setSize(this.panel.getSize());
            }
            this.panel.el.dom.style.display = 'none';
        }
    },

    // private
    repair : function(xy, callback, scope){
        this.hide();
        if(typeof callback == "function"){
            callback.call(scope || this);
        }
    },

/**
     * Moves the proxy to a different position in the DOM.  This is typically called while dragging the Panel
     * to keep the proxy sync'd to the Panel's location.
     * @param {HTMLElement} parentNode The proxy's parent DOM node
     * @param {HTMLElement} before (optional) The sibling node before which the proxy should be inserted (defaults
     * to the parent's last child if not specified)
     */
    moveProxy : function(parentNode, before){
        if(this.proxy){
            parentNode.insertBefore(this.proxy.dom, before);
        }
    }
};

// private - DD implementation for Panels
Ext.Panel.DD = function(panel, cfg){
    this.panel = panel;
    this.dragData = {panel: panel};
    this.proxy = new Ext.dd.PanelProxy(panel, cfg);
    Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg);
    var h = panel.header;
    if(h){
        this.setHandleElId(h.id);
    }
    (h ? h : this.panel.body).setStyle('cursor', 'move');
    this.scroll = false;
};

Ext.extend(Ext.Panel.DD, Ext.dd.DragSource, {
    showFrame: Ext.emptyFn,
    startDrag: Ext.emptyFn,
    b4StartDrag: function(x, y) {
        this.proxy.show();
    },
    b4MouseDown: function(e) {
        var x = e.getPageX();
        var y = e.getPageY();
        this.autoOffset(x, y);
    },
    onInitDrag : function(x, y){
        this.onStartDrag(x, y);
        return true;
    },
    createFrame : Ext.emptyFn,
    getDragEl : function(e){
        return this.proxy.ghost.dom;
    },
    endDrag : function(e){
        this.proxy.hide();
        this.panel.saveState();
    },

    autoOffset : function(x, y) {
        x -= this.startPageX;
        y -= this.startPageY;
        this.setDelta(x, y);
    }
});

redpajama_set_name: RedPajamaGithub


text:
/
    YSON_API bool isCompatible(DetailedValueType compatType,
                               DetailedValueType type);

    namespace Details
    {
        template <typename T>
        struct DetailedValueTraits
        {
            constexpr static DetailedValueType valueType()
            {
                return DetailedValueType::UNKNOWN;
            }
        };

        #define YSON_DETAIL_DETAILEDVALUETRAITS(type, detValueType) \
            template <> \
            struct DetailedValueTraits<type> \
            { \
                constexpr static DetailedValueType valueType() \
                {return detValueType;} \
            }

        YSON_DETAIL_DETAILEDVALUETRAITS(char, DetailedValueType::CHAR);
        YSON_DETAIL_DETAILEDVALUETRAITS(int8_t, DetailedValueType::SINT_8);
        YSON_DETAIL_DETAILEDVALUETRAITS(uint8_t, DetailedValueType::UINT_8);
        YSON_DETAIL_DETAILEDVALUETRAITS(int16_t, DetailedValueType::SINT_16);
        YSON_DETAIL_DETAILEDVALUETRAITS(uint16_t, DetailedValueType::UINT_16);
        YSON_DETAIL_DETAILEDVALUETRAITS(int32_t, DetailedValueType::SINT_32);
        YSON_DETAIL_DETAILEDVALUETRAITS(uint32_t, DetailedValueType::UINT_32);
        YSON_DETAIL_DETAILEDVALUETRAITS(int64_t, DetailedValueType::SINT_64);
        YSON_DETAIL_DETAILEDVALUETRAITS(uint64_t, DetailedValueType::UINT_64);
        YSON_DETAIL_DETAILEDVALUETRAITS(float, DetailedValueType::FLOAT_32);
        YSON_DETAIL_DETAILEDVALUETRAITS(double, DetailedValueType::FLOAT_64);
        YSON_DETAIL_DETAILEDVALUETRAITS(std::string, DetailedValueType::STRING);
    }

    /** @brief Returns true if a value of type T can hold a value of type
      *     @a valueType.
      */
    template <typename T>
    bool isCompatible(DetailedValueType valueType)
    {
        auto type = Details::DetailedValueTraits<T>::valueType();
        return isCompatible(type, valueType);
    }
}


text:
/// <reference path="jquery-2.1.1.js" />
/// <reference path="require.js" />
/// <reference path="bower_components/sammy/lib/sammy.js" />
/// <reference path="mustache.js-master/mustache.js" />
/// <reference path="bower_components/sammy/lib/plugins/sammy.mustache.js" />
(function () {
    requirejs.config({
        paths: {
            jquery: 'jquery-2.1.1',
            sammy: 'bower_components/sammy/lib/sammy',
            mustache: 'mustache.js-master/mustache',
            m:'bower_components/sammy/lib/plugins/sammy.mustache',
        }
    });

    require(['jquery', 'sammy', 'mustache', 'm'], function ($, S, M) {
        var app = S('.chat-posts', function () {
            // include a plugin
            this.use('Mustache');
            var that = this;
            // define a 'route'
            this.get('#/', function () {
                var that = this;
                console.log(that);
                $.getJSON('http://crowd-chat.herokuapp.com/posts', function (data) {
                    var template = $('#m').html();
                    for (var i = 0; i < data.length; i++) {
                        var rendered = that.mustache(template, data[i]);
                        $('#container .chat-posts').append(rendered);
                    }
                });
            });

            $('#container .post').on('click', function () {
                $.post('http://crowd-chat.herokuapp.com/posts', {
                    user: $('#container .name').val(),
                    text: $('#container .input').val().trim()
                });
                $('#container .input').val('');

                that.refresh();
            });

        });

        // start the application
        app.run('#/');
    });
})();


text:
<?php namespace Anomaly\FilesModule\File;

use Anomaly\FilesModule\File\Contract\FileInterface;
use Symfony\Component\HttpFoundation\Response;

/**
 * Class FileReader
 *
 * @link          http://pyrocms.com/
 * @author        PyroCMS, Inc. <support@pyrocms.com>
 * @author        Ryan Thompson <ryan@pyrocms.com>
 */
class FileReader extends FileResponse
{

    /**
     * Return the response headers.
     *
     * @param  FileInterface $file
     * @return Response
     */
    public function read(FileInterface $file)
    {
        $response = $this->make($file);

        return $response;
    }

    /**
     * Make the response.
     *
     * @param  FileInterface $file
     * @return Response
     */
    public function make(FileInterface $file)
    {
        $response = parent::make($file);

        $response->headers->set('Content-Disposition', 'inline');

        return $response->setContent($this->manager->read($file->location()));
    }
}


text:
/* *
 *
 *  (c) 2010-2019 Torstein Honsi
 *
 *  License: www.highcharts.com/license
 *
 *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
 *
 * */
'use strict';
import H from '../parts/Globals.js';
/**
 * @typedef {"arc"|"circle"|"solid"} Highcharts.PaneBackgroundShapeValue
 */
import '../mixins/centered-series.js';
import U from '../parts/Utilities.js';
var extend = U.extend, splat = U.splat;
var CenteredSeriesMixin = H.CenteredSeriesMixin, merge = H.merge;
/* eslint-disable valid-jsdoc */
/**
 * The Pane object allows options that are common to a set of X and Y axes.
 *
 * In the future, this can be extended to basic Highcharts and Highstock.
 *
 * @private
 * @class
 * @name Highcharts.Pane
 * @param {Highcharts.PaneOptions} options
 * @param {Highcharts.Chart} chart
 */
function Pane(options, chart) {
    this.init(options, chart);
}
// Extend the Pane prototype
extend(Pane.prototype, {
    coll: 'pane',
    /**
     * Initialize the Pane object
     *
     * @private
     * @function Highcharts.Pane#init
     *
     * @param {Highcharts.PaneOptions} options
     *
     * @param {Highcharts.Chart} chart
     */
    init: function (options, chart) {
        this.chart = chart;
        this.background = [];
        chart.pane.push(this);
        this.setOptions(options);
    },
    /**
     * @private
     * @function Highcharts.Pane#setOptions
     *
     * @param {Highcharts.PaneOptions} options
     */
    setOptions: function (options) {
        // Set options. Angular charts have a default background (#3318)
        this.options = options = merge(this.defaultOptions, this.chart.angular ? { background: {} } : undefined, options);
    },
    /**
     * Render the pane with its backgrounds.
     *
     * @private
     * @function Highcharts.Pane#render
     */
    render: function () {
        var options = this.options, backgroundOption = this.options.background, renderer = this.chart.renderer, len, i;
        if (!this.group) {
            this.group = renderer.g('pane-group')
                .attr({ zIndex: options.zIndex || 0 })
                .add();
        }
        this.updateCenter();
        // Render the backgrounds
        if (backgroundOption) {
            backgroundOption = splat(backgroundOption);
            len = Math.max(backgroundOption.length, this.background.length || 0);
            for (i = 0; i < len; i++) {
                // #6641 - if axis exists, chart is circular and apply
                // background
                if (backgroundOption[i] && this.axis) {
                    this.renderBackground(merge(this.defaultBackgroundOptions, backgroundOption[i]), i);
                }
                else if (this.background[i]) {
                    this.background[i] = this.background[i].destroy();
                    this.background.splice(i, 1);
                }
            }
        }
    },
    /**
     * Render an individual pane background.
     *
     * @private
     * @function Highcharts.Pane#renderBackground
     *
     * @param {Highcharts.PaneBackgroundOptions} backgroundOptions
     *        Background options
     *
     * @param {number} i
     *        The index of the background in this.backgrounds
     */
    renderBackground: function (backgroundOptions, i) {
        var method = 'animate', attribs = {
            'class': 'highcharts-pane ' + (backgroundOptions.className || '')
        };
        if (!this.chart.styledMode) {
            extend(attribs, {
                'fill': backgroundOptions.backgroundColor,
                'stroke': backgroundOptions.borderColor,
                'stroke-width': backgroundOptions.borderWidth
            });
        }
        if (!this.background[i]) {
            this.background[i] = this.chart.renderer
                .path()
                .add(this.group);
            method = 'attr';
        }
        this.background[i][method]({
            'd': this.axis.getPlotBandPath(backgroundOptions.from, backgroundOptions.to, backgroundOptions)
        }).attr(attribs);
    },
    /**
     * The pane serves as a container for axes and backgrounds for circular
     * gauges and polar charts.
     *
     * @since        2.3.0
     * @product      highcharts
     * @requires     highcharts-more
     * @optionparent pane
     */
    defaultOptions: {
        /**
         * The end angle of the polar X axis or gauge value axis, given in
         * degrees where 0 is north. Defaults to [startAngle](#pane.startAngle)
         * + 360.
         *
         * @sample {highcharts} highcharts/demo/gauge-vu-meter/
         *         VU-meter with custom start and end angle
         *
         * @type      {number}
         * @since     2.3.0
         * @product   highcharts
         * @apioption pane.endAngle
         */
        /**
         * The center of a polar chart or angular gauge, given as an array
         * of [x, y] positions. Positions can be given as integers that
         * transform to pixels, or as percentages of the plot area size.
         *
         * @sample {highcharts} highcharts/demo/gauge-vu-meter/
         *         Two gauges with different center
         *
         * @type    {Array<string|number>}
         * @default ["50%", "50%"]
         * @since   2.3.0
         * @product highcharts
         */
        center: ['50%', '50%'],
        /**
         * The size of the pane, either as a number defining pixels, or a
         * percentage defining a percentage of the plot are.
         *
         * @sample {highcharts} highcharts/demo/gauge-vu-meter/
         *         Smaller size
         *
         * @type    {number|string}
         * @product highcharts
         */
        size: '85%',
        /**
         * The start angle of the polar X axis or gauge axis, given in degrees
         * where 0 is north. Defaults to 0.
         *
         * @sample {highcharts} highcharts/demo/gauge-vu-meter/
         *         VU-meter with custom start and end angle
         *
         * @since   2.3.0
         * @product highcharts
         */
        startAngle: 0
    },
    /**
     * An array of background items for the pane.
     *
     * @sample {highcharts} highcharts/demo/gauge-speedometer/
     *         Speedometer gauge with multiple backgrounds
     *
     * @type         {Array<*>}
     * @optionparent pane.background
     */
    defaultBackgroundOptions: {
        /**
         * The class name for this background.
         *
         * @sample {highcharts} highcharts/css/pane/
         *         Panes styled by CSS
         * @sample {highstock} highcharts/css/pane/
         *         Panes styled by CSS
         * @sample {highmaps} highcharts/css/pane/
         *         Panes styled by CSS
         *
         * @type      {string}
         * @default   highcharts-pane
         * @since     5.0.0
         * @apioption pane.background.className
         */
        /**
         * The shape of the pane background. When `solid`, the background
         * is circular. When `arc`, the background extends only from the min
         * to the max of the value axis.
         *
         * @type    {Highcharts.PaneBackgroundShapeValue}
         * @since   2.3.0
         * @product highcharts
         */
        shape: 'circle',
        /**
         * The pixel border width of the pane background.
         *
         * @since 2.3.0
         * @product highcharts
         */
        borderWidth: 1,
        /**
         * The pane background border color.
         *
         * @type    {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
         * @since   2.3.0
         * @product highcharts
         */
        borderColor: '#cccccc',
        /**
         * The background color or gradient for the pane.
         *
         * @type    {Highcharts.GradientColorObject}
         * @default { linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 }, stops: [[0, #ffffff], [1, #e6e6e6]] }
         * @since   2.3.0
         * @product highcharts
         */
        backgroundColor: {
            /** @ignore-option */
            linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
            /** @ignore-option */
            stops: [
                [0, '#ffffff'],
                [1, '#e6e6e6']
            ]
        },
        /** @ignore-option */
        from: -Number.MAX_VALUE,
        /**
         * The inner radius of the pane background. Can be either numeric
         * (pixels) or a percentage string.
         *
         * @type    {number|string}
         * @since   2.3.0
         * @product highcharts
         */
        innerRadius: 0,
        /** @ignore-option */
        to: Number.MAX_VALUE,
        /**
         * The outer radius of the circular pane background. Can be either
         * numeric (pixels) or a percentage string.
         *
         * @type     {number|string}
         * @since    2.3.0
         * @product  highcharts
         */
        outerRadius: '105%'
    },
    /**
     * Gets the center for the pane and its axis.
     *
     * @private
     * @function Highcharts.Pane#updateCenter
     * @param {Highcharts.RadialAxis} [axis]
     * @return {void}
     */
    updateCenter: function (axis) {
        this.center = (axis ||
            this.axis ||
            {}).center = CenteredSeriesMixin.getCenter.call(this);
    },
    /**
     * Destroy the pane item
     *
     * @ignore
     * @private
     * @function Highcharts.Pane#destroy
     * /
    destroy: function () {
        H.erase(this.chart.pane, this);
        this.background.forEach(function (background) {
            background.destroy();
        });
        this.background.length = 0;
        this.group = this.group.destroy();
    },
    */
    /**
     * Update the pane item with new options
     *
     * @private
     * @function Highcharts.Pane#update
     * @param {Highcharts.PaneOptions} options
     *        New pane options
     * @param {boolean} [redraw]
     * @return {void}
     */
    update: function (options, redraw) {
        merge(true, this.options, options);
        merge(true, this.chart.options.pane, options); // #9917
        this.setOptions(this.options);
        this.render();
        this.chart.axes.forEach(function (axis) {
            if (axis.pane === this) {
                axis.pane = null;
                axis.update({}, redraw);
            }
        }, this);
    }
});
H.Pane = Pane;


text:
import React, { Component } from "react"
import PropTypes from "prop-types"
import { connect } from "react-redux"
import { List, ListItem } from "material-ui/List"
import { Card, CardHeader, CardText } from "material-ui/Card"
import FontIcon from "material-ui/FontIcon"
import { CONSUL_FETCH_REGIONS, CONSUL_SET_REGION } from "../sagas/event"

class SelectConsulRegion extends Component {
  constructor(props) {
    super(props)
    this._onClick = this.handleChangeRegion.bind(this)
  }

  componentDidMount() {
    this.props.dispatch({ type: CONSUL_FETCH_REGIONS })
  }

  handleChangeRegion(region) {
    this.props.dispatch({
      type: CONSUL_SET_REGION,
      payload: region
    })
  }

  render() {
    return (
      <Card>
        <CardHeader title="Please select a consul datacenter" />
        <CardText>
          <List>
            {Object.keys(this.props.consulRegions).map(region => {
              const regionName = this.props.consulRegions[region]
              return (
                <ListItem
                  leftIcon={<FontIcon className="material-icons">public</FontIcon>}
                  primaryText={regionName}
                  onClick={() => this._onClick(regionName)}
                />
              )
            })}
          </List>
        </CardText>
      </Card>
    )
  }
}

function mapStateToProps({ consulRegions }) {
  return { consulRegions }
}

SelectConsulRegion.defaultProps = {
  consulRegions: []
}

SelectConsulRegion.propTypes = {
  consulRegions: PropTypes.array.isRequired,
  dispatch: PropTypes.func.isRequired
}

export default connect(mapStateToProps)(SelectConsulRegion)


text:
package net.codetojoy.service;

import java.util.*;
import java.io.File;

import net.codetojoy.cache.*;
import net.codetojoy.pojo.*;

public class ItemDAO implements ClearCachePredicate {
    private ItemCache itemCache = new SimpleItemCache(this);

    @Override
    public boolean doClearCache() {
        boolean result = new File("/Users/measter/tmp/clear.cache.txt").exists();
        return result;
    }

    @Override
    public int getPredicateCheckFrequency() {
        return 0;
    }

    protected String mockFetch(int id) {
        String result = new Date().toString();

        try {
            System.out.println("fetching item id: " + id);
            Thread.sleep(2*1000);
        } catch(Exception ex) {
        }

        return result;
    }

    public Item getItem(int id) {
        Item item = itemCache.getItem(id);

        if (item == null) {
           String payload = mockFetch(id);
           item = new Item(id, payload);
           itemCache.putItem(id, item);
        }

        return item;
    }

    public List<Item> getItems() {
        List<Item> result = new ArrayList<>();

        for (Integer id : itemCache.getIds()) {
            Item item = itemCache.getItem(id);
            result.add(item);
        }

        return result;
    }

    public void clear() {
        itemCache.clear();
    }
}


text:
using UnityEngine;
using Leap.Unity.Interaction;
#if UNITY_EDITOR
using UnityEditor;
#endif

namespace Leap.Unity.Interaction {

  /**
  * The InteractiveBrushBone class is a physics element of an InteractiveBrushHand object.
  * It contains Unity physics components that are controlled by the Interaction Engine.
  * @since 4.1.3
  */
  public class InteractionBrushBone : MonoBehaviour {

    // Used by InteractionBrushHand:
    /** The active InteractionManager. */
    public InteractionManager manager;
    /** This InteractiveBrushBone's RigidBody. */
    public Rigidbody capsuleBody;
    /** This InteractiveBrushBone's Collider. */
    public CapsuleCollider capsuleCollider;
    /** This InteractiveBrushBone's target position. */
    public Vector3 lastTarget;

    // Once the brush becomes dislocated, it then remains dislocated until it
    // stops triggering and then the _dislocatedCounter expires.
    private const int DISLOCATED_BRUSH_COOLDOWN = 3;
    private int _dislocatedCounter = DISLOCATED_BRUSH_COOLDOWN;

    /** Changes the collider to react to collisions as a trigger. */
    public void startTriggering() {
      capsuleCollider.isTrigger = true;
      _dislocatedCounter = 0;
    }

    /** Determines whether the brush bone should react to collisions as a trigger. */
    public bool updateTriggering() {
      if (_dislocatedCounter < DISLOCATED_BRUSH_COOLDOWN) {
        if (++_dislocatedCounter == DISLOCATED_BRUSH_COOLDOWN) {
          capsuleCollider.isTrigger = false;
          return false;
        }
        return true;
      }
      return false;
    }

    private void tryNotify(Collider other) {
      IInteractionBehaviour ib = other.GetComponentInParent<IInteractionBehaviour>();
      if (ib) {
        manager.EnsureActive(ib);
        _dislocatedCounter = 0;
        ib.NotifyBrushDislocated();
      }
    }

    protected void OnTriggerEnter(Collider other) {
      tryNotify(other);
    }

    protected void OnTriggerStay(Collider other) {
      tryNotify(other);
    }

#if UNITY_EDITOR
    private string ThisLabel() {
      return gameObject.name + " <layer " + LayerMask.LayerToName(gameObject.layer) + ">";
    }

    private string ThatLabel(Collision collision) {
      GameObject otherObj = collision.collider.gameObject;
      return otherObj.name + " <layer " + LayerMask.LayerToName(otherObj.layer) + ">";
    }

    private void OnCollisionEnter(Collision collision) {
      GameObject otherObj = collision.collider.gameObject;
      if (otherObj.GetComponentInParent<InteractionBehaviourBase>() == null) {
        Debug.LogError("For interaction to work properly please prevent collision between an InteractionBrushHand and non-interaction objects. " + ThisLabel() + ", " + ThatLabel(collision));
      }
    }
#endif // UNITY_EDITOR
  }
}


text:
function ll = mogLogLikelihood(model)

% MOGLOGLIKELIHOOD Mixture of Gaussian's log likelihood.
% FORMAT
% DESC computes the variational lower bound on the log likelihood
% of a mixtures of probabilistic PCA model, it wraps the mogLowerBound command.
% ARG model : the model for which log likelihood is to be computed.
% RETURN lll : the lower bound on the log likelihood computed for the model.
%
% SEEALSO : mogCreate, mogLowerBound
%
% COPYRIGHT : Neil D. Lawrence, 2006, 2008
% MLTOOLS

model = mogEstep(model);
ll = mogLowerBound(model);


text:
			<button type="button" class="close" aria-label="Close" data-ng-click="app.errorShow = false">×</button>
			{{ app.errorMessage }}

You have {{user.unicorns}} Unicorns.

				<button type="submit" class="btn btn-success btn-lg" data-ng-click="buyRevive()">Revive for {{fee}} Unicorns</button>

It's a new day, try not to die so quickly next time.


text:
require 'spec_helper'
require 'rollbar/middleware/sinatra'
require 'sinatra/base'
require 'rack/test'

class SinatraDummy < Sinatra::Base
  class DummyError < StandardError; end

  use Rollbar::Middleware::Sinatra

  get '/foo' do
    raise DummyError.new
  end

  get '/bar' do
    'this will not crash'
  end

  post '/crash_post' do
    raise DummyError.new
  end
end

describe Rollbar::Middleware::Sinatra, :reconfigure_notifier => true do
  include Rack::Test::Methods

  def app
    SinatraDummy
  end

  let(:logger_mock) { double('logger').as_null_object }

  before do
    Rollbar.reconfigure do |config|
      config.logger = logger_mock
      config.framework = 'Sinatra'
    end
  end

  let(:uncaught_level) do
    Rollbar.configuration.uncaught_exception_level
  end

  let(:expected_report_args) do
    [uncaught_level, exception]
  end

  describe '#call' do
    context 'for a crashing endpoint' do
      # this is the default for test mode in Sinatra
      context 'with raise_errors? == true' do
        let(:exception) { kind_of(SinatraDummy::DummyError) }

        before do
          allow(app.settings).to receive(:raise_errors?).and_return(true)
        end

        it 'reports the error to Rollbar API and raises error' do
          expect(Rollbar).to receive(:log).with(*expected_report_args)

          expect do
            get '/foo'
          end.to raise_error(SinatraDummy::DummyError)
        end
      end

      context 'with raise_errors? == false' do
        let(:exception) { kind_of(SinatraDummy::DummyError) }

        before do
          allow(app.settings).to receive(:raise_errors?).and_return(false)
        end

        it 'reports the error to Rollbar, but nothing is raised' do
          expect(Rollbar).to receive(:log).with(*expected_report_args)
          get '/foo'
        end
      end
    end

    context 'for a NOT crashing endpoint' do
      it 'doesnt report any error to Rollbar API' do
        expect(Rollbar).not_to receive(:log)
        get '/bar'
      end
    end

    context 'if the middleware itself fails' do
      let(:exception) { Exception.new }

      before do
        allow_any_instance_of(described_class).to receive(:framework_error).and_raise(exception)
        allow(app.settings).to receive(:raise_errors?).and_return(false)
      end

      it 'reports the report error' do
        expect(Rollbar).to receive(:log).with(*expected_report_args)

        expect do
          get '/foo'
        end.to raise_error(exception)
      end
    end

    context 'with GET parameters' do
      let(:exception) { kind_of(SinatraDummy::DummyError) }
      let(:params) do
        {
          'key' => 'value'
        }
      end

      it 'appear in the sent payload' do
        expect do
          get '/foo', params
        end.to raise_error(exception)

        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
      end
    end

    context 'with POST parameters' do
      let(:exception) { kind_of(SinatraDummy::DummyError) }
      let(:params) do
        {
          'key' => 'value'
        }
      end

      it 'appear in the sent payload' do
        expect do
          post '/crash_post', params
        end.to raise_error(exception)

        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
      end
    end

    context 'with JSON POST parameters' do
      let(:exception) { kind_of(SinatraDummy::DummyError) }
      let(:params) do
        {
          'key' => 'value'
        }
      end

      it 'appear in the sent payload' do
        expect do
          post '/crash_post', params.to_json, { 'CONTENT_TYPE' => 'application/json' }
        end.to raise_error(exception)

        expect(Rollbar.last_report[:request][:params]).to be_eql(params)
      end
    end

    it 'resets the notifier in every request' do
      get '/bar'
      id1 = Rollbar.notifier.object_id

      get '/bar'
      id2 = Rollbar.notifier.object_id

      expect(id1).not_to be_eql(id2)
    end
  end
end


text:
#ifndef FILTER
#define FILTER

#include <string>
#include "Logger.h"
using namespace std;
string print(int priority, string tag, string message, bool log, string, string stackmsg, int p);
void SetPriority(int priority);

#endif


text:
#include <thrift/lib/cpp/EventHandlerBase.h>

#include <gtest/gtest.h>

using namespace std;
using namespace folly;
using namespace apache::thrift;

class lulz : public exception {
 public:
  explicit lulz(string message) noexcept : message_(move(message)) {}
  const char* what() const noexcept override { return message_.c_str(); }
 private:
  string message_;
};

namespace {

class EventHandler : public TProcessorEventHandler {
 public:
  string ex_type;
  string ex_what;
  void userException(void*,
                     const char*,
                     const std::string& ex_type,
                     const std::string& ex_what) override {
    this->ex_type = ex_type;
    this->ex_what = ex_what;
  }
};

template <class E> exception_ptr to_eptr(const E& e) {
  try { throw e; }
  catch (E&) { return current_exception(); }
}

class TProcessorEventHandlerTest : public testing::Test {};

}

TEST_F(TProcessorEventHandlerTest, with_full_wrapped_eptr) {
  auto e = lulz("hello");
  auto wrap = exception_wrapper(to_eptr(e), e);
  EXPECT_EQ("lulz", wrap.class_name().toStdString());
  EXPECT_EQ("lulz: hello", wrap.what().toStdString());

  EventHandler eh;
  eh.userExceptionWrapped(nullptr, nullptr, false, wrap);
  EXPECT_EQ("lulz", eh.ex_type);
  EXPECT_EQ("hello", eh.ex_what);
}

TEST_F(TProcessorEventHandlerTest, with_half_wrapped_eptr) {
  auto e = lulz("hello");
  auto wrap = exception_wrapper(to_eptr(e));
  EXPECT_EQ("", wrap.class_name().toStdString());
  EXPECT_EQ("", wrap.what().toStdString());

  EventHandler eh;
  eh.userExceptionWrapped(nullptr, nullptr, false, wrap);
  EXPECT_EQ("lulz", eh.ex_type);
  EXPECT_EQ("hello", eh.ex_what);
}

TEST_F(TProcessorEventHandlerTest, with_wrap_surprise) {
  auto e = lulz("hello");
  auto wrap = exception_wrapper(e);
  EXPECT_EQ("lulz", wrap.class_name().toStdString());
  EXPECT_EQ("lulz: hello", wrap.what().toStdString());

  EventHandler eh;
  eh.userExceptionWrapped(nullptr, nullptr, false, wrap);
  EXPECT_EQ("lulz", eh.ex_type);
  EXPECT_EQ("lulz: hello", eh.ex_what);
}

TEST_F(TProcessorEventHandlerTest, with_wrap_declared) {
  auto e = lulz("hello");
  auto wrap = exception_wrapper(e);
  EXPECT_EQ("lulz", wrap.class_name().toStdString());
  EXPECT_EQ("lulz: hello", wrap.what().toStdString());

  EventHandler eh;
  eh.userExceptionWrapped(nullptr, nullptr, true, wrap);
  EXPECT_EQ("lulz", eh.ex_type);
  EXPECT_EQ("hello", eh.ex_what);
}


text:
title: "Equus"
playwright: Peter Shaffer
period: Spring
season: In House
season_sort: 250
date_start: 2014-04-02
date_end: 2014-04-05
venue: New Theatre

cast:
  - role: Alan Strang
    name: Ajay Stevenson
  - role: Martin Dysart
    name: Ben Williamson
  - role: Dora Strang
    name: Amelia Gann
  - role: Frank Strang
    name: Ben Hollands
  - role: Hesther Soloman
    name: Grace Roberts
  - role: Jill Mason
    name: Daniella Blackford
  - role: Harry Dalton
    name: Omid Faramarzi
  - role: Nurse
    name: Ruth Wogan
  - role: Horseman / Nugget
    name: Matt Hodges
  - role: Ensemble
    name: Charlotte Prosser
  - role: Ensemble
    name: Nick Cain
  - role: Ensemble
    name: Hollie Blaber
  - role: Ensemble
    name: Kitty Martens
  - role: Ensemble
    name: Oliver Smith

crew:
  - role: Director
    name: Ricki Crook
  - role: Producer
    name: Charlotte Prosser
  - role: Set Designer
    name: Aubrey Turner
  - role: Set Designer
    name: Chelsea Jayne Wright
  - role: Set Designer
    name: Tom Selves
  - role: Set Designer
    name: Joseph Heil
  - role: Technical Director
    name: Will Pimblett
  - role: Lighting Designer
    name: Tessa Denney
  - role: Technical Operator
    name: Nathan Penney
  - role: Technical Operator
    name: Tom Gloess
  - role: Technical Operator
    name: Hannah Doyle
  - role: Technical Operator
    name: Joseph Heil
  - role: Stage Manager
    name: Ollie Shortt
  - role: Mask Designer
    name: Hugh Purves
  - role: Costumes & Make-up
    name: Maddie Hardy

assets:
  - type: poster
    image: hn8BzqV

prod_shots: sQvgwk

links:
  - type: Review
    href: https://impactnottingham.com/2014/04/equus-nottingham-new-theatre/
    snapshot: 5v4kd
    publisher: Impact Nottingham
    author: Scarlett White
    title: "Equus @ Nottingham New Theatre"
    date: 2014-04-03
    rating: 4.5/5
    quote: "However those who enjoy the controversial, the engaging, and the psychologically fascinating should certainly buy a ticket for this excellent performance and prepare to be wowed, though you should be warned – you may never look at a horse the same way again."
---

Equus took critics and public alike by storm and has gone on to become a modern classic, Peter Shaffer depicts the story of a deranged youth who blinds six horses with a spike. Through a psychiatrist's analysis of the events, Shaffer creates a chilling portrait of how materialism and convenience have killed our capacity for worship and passion and, consequently, our capacity for pain. Rarely has a playwright created an atmosphere and situation that so harshly pinpoints the spiritual and mental decay of modern man. With passionate monologue combined with a thrilling exploration of physicality, Equus is a play not to be missed.


text:
suite('DisplayProcess', function() {
	var sut;
	var runQ;
	var fakePacketFilter;
	var fakeClientGui;
	var displayRouter;
	var packetWorkerIdentifier;

	setup(function(){
		wdi.Debug.debug = false; //disable debugging, it slows tests
	});

	suite('#process()', function() {
		setup(function() {
			runQ = new wdi.RunQueue();

			fakePacketFilter = {
				notifyEnd: function() {

				},

				filter: function(o, fn, scope) {
					fn.call(scope, o);
				}
			};

			fakeClientGui =  {};

			displayRouter = new wdi.DisplayRouter();

			packetWorkerIdentifier = {
				getImageProperties: function() {
					return false;
				}
			};

			displayRouter.packetProcess = function(spiceMessage) {}; //replace packetProcess, because of partial mocking
			sut = new wdi.DisplayProcess({
				runQ: runQ,
				packetFilter: fakePacketFilter,
				clientGui: fakeClientGui,
				displayRouter: displayRouter,
				packetWorkerIdentifier: packetWorkerIdentifier
			});

			wdi.ExecutionControl.sync = true;
		});

		test('displayProcess process should call packetFilfer process', sinon.test(function() {
			var fakeProxy = {
				end:function() {

				}
			};
			runQ.add = function(fnStart, scope, fnEnd) {
				fnStart.call(scope, fakeProxy);
			}
			this.mock(fakePacketFilter)
				.expects('filter')
				.once();
			sut._process(false);
		}));

		test('displayProcess process should call packetFilfer notifyEnd', sinon.test(function() {
			runQ.add = function(fn, scope, endFn) {
				fn.call(scope,{end:function(){}});
				endFn.call(scope);
			};

			this.mock(fakePacketFilter)
				.expects('notifyEnd')
				.once();
			sut._process(false);
		}));

		test('displayProcess process should call runq add', sinon.test(function() {
			this.mock(runQ)
				.expects('add')
				.once();
			sut._process(false);
		}));

		test('displayProcess process should call runq process', sinon.test(function() {
			this.mock(runQ)
				.expects('process')
				.once();
			sut._process(false);
		}));

		test('displayProcess process should call runq process', sinon.test(function() {
			this.mock(runQ)
				.expects('process')
				.once();
			sut._process(false);
		}));
	});
});


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LightNode.Server
{
    internal static class Utils
    {
        public static bool IsNullable(this Type type)
        {
            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
        }
    }
}


text:
layout: post
title: Build Systems - Tony Kelman
comments: true
category: posts
tags: meeting make reproducibility
---

## Attending

- lots!

## Tony Kelman

Tony is a lecturer in Mechanical Engineering, and a core contributor to the Julia language. He likes building things, including scientific software.

## Build systems

Yay open source! So there's some cool library you want to use, and its author was kind enough to share the source code with the world. But maybe that's all that they provided? Or you want to change something, fix a bug, add a feature, etc. For libraries written in compiled languages like C, C++, Fortran, etc, compilation and dependencies can be hard. There are a variety of build systems commonly used by open-source projects to assist in building libraries and managing dependencies across various platforms. I'll talk about the [GNU autotools][autotools] (and Make), [CMake][cmake], and briefly mention [gyp][gyp]. I'll work through an example using a small but nontrivial C library.

Code examples can be found [here][code].

[code]: https://github.com/thehackerwithin/berkeley/tree/master/build_systems "Code Examples"
[autotools]: https://en.wikipedia.org/wiki/GNU_Build_System "Autotools"
[cmake]: https://cmake.org/ "CMake"
[gyp]: https://gyp.gsrc.io/ "gyp"


text:
<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Authentication Language Lines
    |--------------------------------------------------------------------------
    |
    | The following language lines are used during authentication for various
    | messages that we need to display to the user. You are free to modify
    | these language lines according to your application's requirements.
    |
    */

    'failed' => 'These credentials do not match our records.',
    'general_error' => 'You do not have access to do that.',
    'password_used' => 'You can not set a password that you have previously used.',
    'socialite' => [
        'unacceptable' => ':provider is not an acceptable login type.',
    ],
    'throttle' => 'Too many login attempts. Please try again in :seconds seconds.',
    'unknown' => 'An unknown error occurred',
];


text:
Share Link
==========

Share links fast 'n' easy with this handy Google Chrome extension.


text:
package com.fuelcoin.examples;

import java.io.File;
import java.math.BigInteger;
import java.net.InetAddress;

import com.fuelcoinj.core.Address;
import com.fuelcoinj.core.Base58;
import com.fuelcoinj.core.BlockChain;
import com.fuelcoinj.core.DumpedPrivateKey;
import com.fuelcoinj.core.ECKey;
import com.fuelcoinj.core.NetworkParameters;
import com.fuelcoinj.core.PeerAddress;
import com.fuelcoinj.core.PeerGroup;
import com.fuelcoinj.core.Wallet;
import com.fuelcoinj.params.MainNetParams;
import com.fuelcoinj.store.MemoryBlockStore;
import com.fuelcoinj.store.ValidHashStore;

/**
 * This example shows how to solve the challenge Hal posted here:

 *
 * http://www.peercoin.org/smf/index.php?topic=3638
 * .0

 *
 * in which a private key with some coins associated with it is published. The goal is to import the private key,
 * claim the coins and then send them to a different address.
 */
//WARNING THIS HAS NOT BEEN SETUP OR TESTED WITH FUELCOIN
public class PrivateKeys {
    public static void main(String[] args) throws Exception {
        // TODO: Assumes main network not testnet. Make it selectable.
        NetworkParameters params = MainNetParams.get();
        try {
            // Decode the private key from Satoshis Base58 variant. If 51 characters long then it's from Peercoins
            // dumpprivkey command and includes a version byte and checksum, or if 52 characters long then it has
            // compressed pub key. Otherwise assume it's a raw key.
            ECKey key;
            if (args[0].length() == 51 || args[0].length() == 52) {
                DumpedPrivateKey dumpedPrivateKey = new DumpedPrivateKey(params, args[0]);
                key = dumpedPrivateKey.getKey();
            } else {
                BigInteger privKey = Base58.decodeToBigInteger(args[0]);
                key = ECKey.fromPrivate(privKey);
            }
            System.out.println("Address from private key is: " + key.toAddress(params).toString());
            // And the address ...
            Address destination = new Address(params, args[1]);

            // Import the private key to a fresh wallet.
            Wallet wallet = new Wallet(params);
            wallet.importKey(key);

            // Find the transactions that involve those coins.
            final MemoryBlockStore blockStore = new MemoryBlockStore(params);
            BlockChain chain = new BlockChain(params, wallet, blockStore, new ValidHashStore(new File("hashstore")));

            final PeerGroup peerGroup = new PeerGroup(params, chain);
            peerGroup.addAddress(new PeerAddress(InetAddress.getLocalHost()));
            peerGroup.startAsync();
            peerGroup.downloadBlockChain();
            peerGroup.stopAsync();

            // And take them!
            System.out.println("Claiming " + wallet.getBalance().toFriendlyString());
            wallet.sendCoins(peerGroup, destination, wallet.getBalance());
            // Wait a few seconds to let the packets flush out to the network (ugly).
            Thread.sleep(5000);
            System.exit(0);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("First arg should be private key in Base58 format. Second argument should be address " +
                    "to send to.");
            return;
        }
    }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

        <title>CruiseControl.NET : Synergy Project</title>
	    <link rel="stylesheet" href="styles/site.css" type="text/css" />
        <META http-equiv="Content-Type" content="text/html; charset=UTF-8">

                            CruiseControl.NET : Synergy Project

					    This page last changed on Dec 15, 2009 by csut017.

Synergy Project

A CM Synergy project (which is similar to a "view" in other SCM packages).

Version

Available from version 1.0

Examples

<project>
  <release>Product/1.0</release>
  <projectSpecification>Product-1</projectSpecification>
  <taskFolder>1234</taskFolder>
  <baseline>false</baseline>
  <purpose>Integration Testing</purpose>
  <template>true</template>
</project>

Configuration Elements

 Element
 Description
 Type
 Required
 Default
 Version

 baseline
 If true, creates a new baseline for the project configuration after a successful integration.
Realistically, a successful continuous integration does not justify creation of a baseline.  Baselines should be used to create a snapshot of a configuration, so that anyone can  usually based on a project mileston
 Boolean
 No
 0
 1.0

 projectSpecification
 The configured Synergy project specification for all source control operations.
 String
 Yes
 n/a
 1.0

 purpose
 Synergy purpose specification for the project and any created baselines.
 String
 No
 Integration Testing
 1.0

 reconcile
 If enabled, updates the work area from the database, discarding all uncontrolled files in the work area and changes to static objects.
Useful if your build process adds or modifies files in the source tree.
 String array
 No
 false
 1.0

 release
 The configured Synergy release value for the given project.
The component + version specification.
 String
 Yes
 n/a
 1.0

 taskFolder
 The folder specification for the shared folder which will be used to "manually" add successfully integrated tasks added to.
This should be a shared folder added to the reconfigure template/properties for all developer's projects (i.e., projects for purpose "Insulated Development" or "Colloborative Development").  The easiset way to do this is by creating a "folder template", which is then added to the "Default Release" reconfigure templates "Default Release:Insulated Development" or "Default Release:Colloborative Development". Adding integrated tasks to a shared task folder is an alternative to creating a new baseline for every successful integration build.  Most source control providers implemented by CruiseControl.NET use labels for grouping change sets.  However, Synergy is an activity based SCM tool that groups changes by ...
 Int32
 No
 0
 1.0

 template
 If true, resets the reconfigure properties for this project and all subprojects to use the reconfigure template.
Do not set to true if you have manually set the template to reconfigure with specific settings (e.g., reconfigure by object status, with a manually added set of tasks, etc).
 Boolean
 No
 false
 1.0

<colgroup><col width='24'><col></colgroup>
	Automatically Generated

Documentation generated on Tuesday, 15 Dec 2009 at 8:12:07 PM

			    Document generated by Confluence on Jan 30, 2010 19:06


text:
<?php _e('Simple Tags: Options', 'simpletags'); ?>

		<?php
		// Get array options/description
		$option_data = (array) include( STAGS_DIR . '/inc/helper.options.admin.php' );
		foreach ( $option_data as $key => $val ) {
			$style = '';

			// Deactive tabs if feature not actived
			if ( isset($options['active_related_posts']) && (int) $options['active_related_posts'] == 0 && $key == 'relatedposts' ) {
				$style = 'style="display:none;"';
			}

			// Deactive tabs if feature not actived
			if ( isset($options['auto_link_tags']) && (int) $options['auto_link_tags'] == 0 && $key == 'auto-links' ) {
				$style = 'style="display:none;"';
			}

			echo ''.self::getNiceTitleOptions($key).'';
		}
		?>

		<form action="https://www.paypal.com/cgi-bin/webscr" method="post">
			<input type="hidden" name="cmd" value="_s-xclick" />
			<input type="hidden" name="hosted_button_id" value="L9QU9QT9R5FQS" />
			<input type="image" src="https://www.paypal.com/en_US/i/btn/btn_donateCC_LG_global.gif" style="border:0;" name="submit" alt="PayPal - The safer, easier way to pay online." />
		</form>

<?php _e('Visit the plugin\'s homepage for further details. If you find a bug, or have a fantastic idea for this plugin, ask me !', 'simpletags'); ?>

	<form action="<?php echo self::$admin_url; ?>" method="post">
		<?php echo self::print_options( $option_data ); ?>

			<?php wp_nonce_field( 'updateresetoptions-simpletags' ); ?>
			<input class="button-primary" type="submit" name="updateoptions" value="<?php _e('Update options »', 'simpletags'); ?>" />
			<input class="button" type="submit" name="reset_options" onclick="return confirm('<?php _e('Do you really want to restore the default options?', 'simpletags'); ?>');" value="<?php _e('Reset Options', 'simpletags'); ?>" />

	</form>

	<?php self::printAdminFooter(); ?>


text:
package gr.gttm;

import gr.gttm.tools.PhoenixConnectionProvider;
import gr.gttm.tools.PhoenixMapper;

import java.util.Map;
import java.util.Random;

import org.apache.storm.jdbc.bolt.JdbcInsertBolt;
import org.apache.storm.jdbc.common.ConnectionProvider;
import org.apache.storm.jdbc.mapper.JdbcMapper;

import backtype.storm.Config;
import backtype.storm.StormSubmitter;
import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;
import backtype.storm.utils.Utils;

public class PhoenixTopology {

	public static class RandomRowSpout extends BaseRichSpout {
		SpoutOutputCollector _collector;
		Random _rand;

		@Override
		public void open(Map conf, TopologyContext context,
				SpoutOutputCollector collector) {
			_collector = collector;
			_rand = new Random();
		}

		@Override
		public void nextTuple() {
			Utils.sleep(100);
			String randIp = _rand.nextInt(256) + "." + _rand.nextInt(256) + "."
					+ _rand.nextInt(256) + "." + _rand.nextInt(256);
			String[] dnsPool = new String[] { "cnn.com", "google.com",
					"twitter.com", "ntua.gr", "facebook.com" };
			String randDns = dnsPool[_rand.nextInt(dnsPool.length)];
			int randLatency = _rand.nextInt(1000);
			_collector.emit(new Values(randIp, randDns, randLatency));
		}

		@Override
		public void ack(Object id) {
		}

		@Override
		public void fail(Object id) {
		}

		@Override
		public void declareOutputFields(OutputFieldsDeclarer declarer) {
			declarer.declare(new Fields("ip", "dns", "latency"));
		}

	}

	public static void main(String[] args) throws Exception {
		//CREATE TABLE "phoenixtest" ("ip" VARCHAR PRIMARY KEY, "cf1"."dns" VARCHAR, "cf2"."latency" INTEGER);
		ConnectionProvider connectionProvider = new PhoenixConnectionProvider();
		JdbcMapper simpleJdbcMapper = new PhoenixMapper();
		JdbcInsertBolt phoenixBolt = new JdbcInsertBolt(
				connectionProvider, simpleJdbcMapper)
				.withInsertQuery("UPSERT INTO \"phoenixtest\" VALUES (?,?,?)")
				.withQueryTimeoutSecs(30);

		TopologyBuilder builder = new TopologyBuilder();

		builder.setSpout("row", new RandomRowSpout(), 1);
		builder.setBolt("output", phoenixBolt, 1).shuffleGrouping("row");

		Config conf = new Config();
		conf.setDebug(true);
		conf.setNumWorkers(4);

		StormSubmitter.submitTopology("PhoenixTopology", conf,
				builder.createTopology());
	}
}


text:
#ifdef USE_TI_UIIPHONEROWANIMATIONSTYLE

#import "TiUIiPhoneRowAnimationStyleProxy.h"
#import "TiBase.h"

@implementation TiUIiPhoneRowAnimationStyleProxy

-(NSString*)apiName
{
    return @"Ti.UI.iPhone.RowAnimationStyle";
}

MAKE_SYSTEM_PROP(NONE,UITableViewRowAnimationNone);
MAKE_SYSTEM_PROP(LEFT,UITableViewRowAnimationLeft);
MAKE_SYSTEM_PROP(RIGHT,UITableViewRowAnimationRight);
MAKE_SYSTEM_PROP(TOP,UITableViewRowAnimationTop);
MAKE_SYSTEM_PROP(BOTTOM,UITableViewRowAnimationBottom);
MAKE_SYSTEM_PROP(FADE,UITableViewRowAnimationFade);

// used before 0.9 in KS
MAKE_SYSTEM_PROP(UP,UITableViewRowAnimationTop);
MAKE_SYSTEM_PROP(DOWN,UITableViewRowAnimationBottom);

@end

#endif


text:
package org.hibernate.metamodel.binding;

/**
 * @author Steve Ebersole
 * @author Gail Badner
 */
public class CompositeCollectionElement extends AbstractCollectionElement {
	public CompositeCollectionElement(AbstractPluralAttributeBinding binding) {
		super( binding );
	}

	@Override
	public CollectionElementNature getCollectionElementNature() {
		return CollectionElementNature.COMPOSITE;
	}
}


text:
package me.welcomer.framework.pico.service

import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import scala.util.Try

import me.welcomer.framework.pico.repository.PicoPdsRepositoryComponent
import me.welcomer.framework.utils.DBUtils
import play.api.libs.json.JsObject
import play.api.libs.json.JsValue
import play.api.libs.json.Json
import play.api.libs.json.Reads
import play.api.libs.json.Writes

/**
 * PicoPds Service Component
 *
 * Provides a PDS service scoped to the provided picoUUID.
 *
 * You must implement the following when using:
 * {{{
 * protected def _picoPdsService(picoUUID: String): PicoPdsService
 * }}}
 */
trait PicoPdsServiceComponent { self: PicoPdsRepositoryComponent =>
  protected def _picoPdsService(picoUUID: String): PicoPdsService

  /**
   * PicoPds Service
   *
   * You must implement the following when using:
   * {{{
   * implicit val picoUUID: String
   * }}}
   */
  trait PicoPdsService {
    /**
     * The picoUUID used for scoping the PDS service.
     */
    implicit val picoUUID: String

    // TODO: Convert all BSONDocument returns to JsObject
    // TODO: Replace Option with Try? (so we can pass exceptions back if needed)

    /**
     * Store a single item in the specified (or default) namespace.
     *
     * @param key The key of the item to retrieve
     * @param The item to be stored
     * @param namespace An optional namespace to locate the key in
     * @param selector An optional selection query
     * @return The results of the store
     */
    def storeItem[T](key: String, item: T, namespace: Option[String] = None)(implicit ec: ExecutionContext, writeT: Writes[T]): Future[JsObject]

    // TODO: Remove this for the generic method when we switch BSON to JSON
    def storeItemWithJsValue(
      key: String,
      item: JsValue,
      namespace: Option[String] = None,
      selector: Option[JsObject] = None)(implicit ec: ExecutionContext): Future[JsObject]

    // TODO: Remove this for the generic method when we switch BSON to JSON
    // TODO: Maybe rename this to merge? Or maybe just make storeItem smarter (with a shouldMerge type flag)
    def storeAllItemsWithJsObject(items: JsObject, namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject]

    /**
     * Push an item into array in the specified (or default) namespace.
     *
     * @param arrayKey The key of the array to modify
     * @param item The item to push into the array
     * @param namespace An optional namespace to locate the key in
     * @param selector An optional selection query
     * @param unique Should the item be unique in the array? (won't be added if already exists)
     * @return The results of the store
     */
    def pushArrayItem(
      arrayKey: String,
      item: JsValue,
      namespace: Option[String] = None,
      selector: Option[JsObject] = None,
      unique: Boolean = false)(implicit ec: ExecutionContext): Future[JsObject]

    /**
     * Push items into array in the specified (or default) namespace.
     *
     * @param arrayKey The key of the array to modify
     * @param items The items to push into the array
     * @param namespace An optional namespace to locate the key in
     * @param selector An optional selection query
     * @param unique Should the items be unique in the array? (won't be added if already exists)
     * @return The results of the store
     */
    def pushArrayItems(
      arrayKey: String,
      items: Seq[JsValue],
      namespace: Option[String] = None,
      selector: Option[JsObject] = None,
      unique: Boolean = false)(implicit ec: ExecutionContext): Future[JsObject]

    /**
     * Retrieve the query/projection in the specified (or default) namespace.
     *
     * @param query The selection query
     * @param projection The fields to select
     * @param namespace An optional namespace to locate the key in
     */
    def retrieve(
      query: JsObject,
      projection: JsObject,
      namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]]

    /**
     * Retrieve a single item in the specified (or default) namespace from the PDS as type T.
     *
     * @param key The key of the item to retrieve
     * @param namespace An optional namespace to locate the key in
     * @return The retrieved item as type Option[T] or None
     */
    def retrieveItem[T](key: String, namespace: Option[String] = None)(implicit ec: ExecutionContext, readsT: Reads[T]): Future[Option[T]]

    /**
     * Retrieve all items in the specified (or default) namespace from the PDS.
     *
     *  @param namespace An optional namespace to locate the key in
     *  @param filter A list containing the keys to be included
     *  @return The retrieved items or None
     */
    def retrieveAllItems(namespace: Option[String] = None, filter: Option[List[String]] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]]

    //    /**
    //     * Retrieve all items in the specified (or default) namespace from the PDS as type T.
    //     *
    //     *  @param namespace An optional namespace to locate the key in
    //     *  @param filter A JsObject containing the keys to be included
    //     *  @return The retrieved items or None
    //     */
    //    def retrieveAllItems[T](namespace: Option[String] = None, filter: Option[List[String]] = None)(implicit ec: ExecutionContext, readsT: Reads[T]): Future[Option[T]]

    /**
     * Retrieve all namespaces and their items from the PDS.
     *
     * @param filter A list containing the keys to be included
     *
     * @return The retrieved items or None
     */
    def retrieveAllNamespaces(filter: Option[List[String]] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]]

    /**
     * Remove a single item in the specified (or default) namespace from the PDS.
     *
     * @param key The key of the item to remove
     * @param namespace An optional namespace to locate the key in
     * @return The results of the removal
     */
    def removeItem(key: String, namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject]

    /**
     * Remove all items in the specified (or default) namespace from the PDS.
     *
     *  @param namespace An optional namespace to locate the key in
     *  @return The results of the removal
     */
    def removeAllItems(namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject]

    /**
     * Remove all namespaces and their items from the PDS.
     *
     * @return The results of the removal
     */
    def removeAllNamespaces(implicit ec: ExecutionContext): Future[JsObject]
  }
}

/**
 * Implementation of [[me.welcomer.framework.pico.service.PicoPdsServiceComponent]]
 */
trait PicoPdsServiceComponentImpl extends PicoPdsServiceComponent { self: PicoPdsRepositoryComponent =>
  override protected def _picoPdsService(picoUUID: String): PicoPdsService = new PicoPdsServiceImpl()(picoUUID)

  /**
   * Implementation of [[me.welcomer.framework.pico.service.PicoPdsServiceComponent#PicoPdsService]]
   */
  private[this] class PicoPdsServiceImpl(implicit val picoUUID: String) extends PicoPdsService with DBUtils {
    import reactivemongo.bson.DefaultBSONHandlers._

    override def storeItem[T](key: String, item: T, namespace: Option[String] = None)(implicit ec: ExecutionContext, writeT: Writes[T]): Future[JsObject] = {
      _picoPdsRepository.setScopedKey(namespace, Some(key), item)
    }

    // TODO: Remove this for the generic method when we switch BSON to JSON
    override def storeItemWithJsValue(
      key: String,
      item: JsValue,
      namespace: Option[String] = None,
      selector: Option[JsObject] = None)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.setScopedKey(namespace, Some(key), item, selector = selector)
    }

    // TODO: Remove this for the generic method when we switch BSON to JSON
    override def storeAllItemsWithJsObject(items: JsObject, namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.mergeScoped(
        namespace,
        None,
        items)
    }

    override def pushArrayItem(
      arrayKey: String,
      item: JsValue,
      namespace: Option[String] = None,
      selector: Option[JsObject] = None,
      unique: Boolean = false)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.pushScopedArrayItem(arrayKey, item, namespace, selector, unique)
    }

    override def pushArrayItems(
      arrayKey: String,
      items: Seq[JsValue],
      namespace: Option[String] = None,
      selector: Option[JsObject] = None,
      unique: Boolean = false)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.pushScopedArrayItems(arrayKey, items, namespace, selector, unique)
    }

    override def retrieve(
      query: JsObject,
      projection: JsObject,
      namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]] = {
      _picoPdsRepository.findScoped(query, projection, namespace)
    }

    override def retrieveItem[T](key: String, namespace: Option[String] = None)(implicit ec: ExecutionContext,
                                                                                readsT: Reads[T]): Future[Option[T]] = {
      // TODO: Push this functionality down into the repos level?
      _picoPdsRepository.findScopedDocument(namespace) map {
        case Some(result) => (result \ key).asOpt[T]
        case None         => None
      }
    }

    override def retrieveAllItems(namespace: Option[String] = None, filter: Option[List[String]] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]] = {
      _picoPdsRepository.findScopedDocument(namespace, filter)
    }

    //    override def retrieveAllItems[T](namespace: Option[String] = None, filter: Option[List[String]] = None)(implicit ec: ExecutionContext, readsT: Reads[T]): Future[Option[T]] = {
    //      _picoPdsRepository.findScopedDocument(namespace, filter) map {
    //        case Some(result) => result.asOpt[T]
    //        case None => None
    //      }
    //    }

    override def retrieveAllNamespaces(filter: Option[List[String]] = None)(implicit ec: ExecutionContext): Future[Option[JsObject]] = {
      _picoPdsRepository.findScopedDocument(None, filter, ignoreNamespace = true)
    }

    override def removeItem(key: String, namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.unsetScopedKey(namespace, Some(key))
    }

    override def removeAllItems(namespace: Option[String] = None)(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.unsetScopedKey(namespace)
    }

    override def removeAllNamespaces(implicit ec: ExecutionContext): Future[JsObject] = {
      _picoPdsRepository.setScopedKey(None, None, Json.obj(), true)
    }

  }
}