text:
package com.amazonaws.services.devicefarm;

import javax.annotation.Generated;

import com.amazonaws.services.devicefarm.model.*;

/**
 * Abstract implementation of {@code AWSDeviceFarmAsync}. Convenient method forms pass through to the corresponding
 * overload that takes a request object and an {@code AsyncHandler}, which throws an
 * {@code UnsupportedOperationException}.
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AbstractAWSDeviceFarmAsync extends AbstractAWSDeviceFarm implements AWSDeviceFarmAsync {

    protected AbstractAWSDeviceFarmAsync() {
    }

    @Override
    public java.util.concurrent.Future<CreateDevicePoolResult> createDevicePoolAsync(CreateDevicePoolRequest request) {

        return createDevicePoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateDevicePoolResult> createDevicePoolAsync(CreateDevicePoolRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateDevicePoolRequest, CreateDevicePoolResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateInstanceProfileResult> createInstanceProfileAsync(CreateInstanceProfileRequest request) {

        return createInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateInstanceProfileResult> createInstanceProfileAsync(CreateInstanceProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateInstanceProfileRequest, CreateInstanceProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateNetworkProfileResult> createNetworkProfileAsync(CreateNetworkProfileRequest request) {

        return createNetworkProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateNetworkProfileResult> createNetworkProfileAsync(CreateNetworkProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateNetworkProfileRequest, CreateNetworkProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateProjectResult> createProjectAsync(CreateProjectRequest request) {

        return createProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateProjectResult> createProjectAsync(CreateProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateProjectRequest, CreateProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateRemoteAccessSessionResult> createRemoteAccessSessionAsync(CreateRemoteAccessSessionRequest request) {

        return createRemoteAccessSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateRemoteAccessSessionResult> createRemoteAccessSessionAsync(CreateRemoteAccessSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateRemoteAccessSessionRequest, CreateRemoteAccessSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateTestGridProjectResult> createTestGridProjectAsync(CreateTestGridProjectRequest request) {

        return createTestGridProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateTestGridProjectResult> createTestGridProjectAsync(CreateTestGridProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateTestGridProjectRequest, CreateTestGridProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateTestGridUrlResult> createTestGridUrlAsync(CreateTestGridUrlRequest request) {

        return createTestGridUrlAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateTestGridUrlResult> createTestGridUrlAsync(CreateTestGridUrlRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateTestGridUrlRequest, CreateTestGridUrlResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateUploadResult> createUploadAsync(CreateUploadRequest request) {

        return createUploadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateUploadResult> createUploadAsync(CreateUploadRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateUploadRequest, CreateUploadResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<CreateVPCEConfigurationResult> createVPCEConfigurationAsync(CreateVPCEConfigurationRequest request) {

        return createVPCEConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<CreateVPCEConfigurationResult> createVPCEConfigurationAsync(CreateVPCEConfigurationRequest request,
            com.amazonaws.handlers.AsyncHandler<CreateVPCEConfigurationRequest, CreateVPCEConfigurationResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteDevicePoolResult> deleteDevicePoolAsync(DeleteDevicePoolRequest request) {

        return deleteDevicePoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteDevicePoolResult> deleteDevicePoolAsync(DeleteDevicePoolRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteDevicePoolRequest, DeleteDevicePoolResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteInstanceProfileResult> deleteInstanceProfileAsync(DeleteInstanceProfileRequest request) {

        return deleteInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteInstanceProfileResult> deleteInstanceProfileAsync(DeleteInstanceProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteInstanceProfileRequest, DeleteInstanceProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteNetworkProfileResult> deleteNetworkProfileAsync(DeleteNetworkProfileRequest request) {

        return deleteNetworkProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteNetworkProfileResult> deleteNetworkProfileAsync(DeleteNetworkProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteNetworkProfileRequest, DeleteNetworkProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteProjectResult> deleteProjectAsync(DeleteProjectRequest request) {

        return deleteProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteProjectResult> deleteProjectAsync(DeleteProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteProjectRequest, DeleteProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteRemoteAccessSessionResult> deleteRemoteAccessSessionAsync(DeleteRemoteAccessSessionRequest request) {

        return deleteRemoteAccessSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteRemoteAccessSessionResult> deleteRemoteAccessSessionAsync(DeleteRemoteAccessSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteRemoteAccessSessionRequest, DeleteRemoteAccessSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteRunResult> deleteRunAsync(DeleteRunRequest request) {

        return deleteRunAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteRunResult> deleteRunAsync(DeleteRunRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteRunRequest, DeleteRunResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteTestGridProjectResult> deleteTestGridProjectAsync(DeleteTestGridProjectRequest request) {

        return deleteTestGridProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteTestGridProjectResult> deleteTestGridProjectAsync(DeleteTestGridProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteTestGridProjectRequest, DeleteTestGridProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteUploadResult> deleteUploadAsync(DeleteUploadRequest request) {

        return deleteUploadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteUploadResult> deleteUploadAsync(DeleteUploadRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteUploadRequest, DeleteUploadResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<DeleteVPCEConfigurationResult> deleteVPCEConfigurationAsync(DeleteVPCEConfigurationRequest request) {

        return deleteVPCEConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<DeleteVPCEConfigurationResult> deleteVPCEConfigurationAsync(DeleteVPCEConfigurationRequest request,
            com.amazonaws.handlers.AsyncHandler<DeleteVPCEConfigurationRequest, DeleteVPCEConfigurationResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetAccountSettingsResult> getAccountSettingsAsync(GetAccountSettingsRequest request) {

        return getAccountSettingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetAccountSettingsResult> getAccountSettingsAsync(GetAccountSettingsRequest request,
            com.amazonaws.handlers.AsyncHandler<GetAccountSettingsRequest, GetAccountSettingsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetDeviceResult> getDeviceAsync(GetDeviceRequest request) {

        return getDeviceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetDeviceResult> getDeviceAsync(GetDeviceRequest request,
            com.amazonaws.handlers.AsyncHandler<GetDeviceRequest, GetDeviceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetDeviceInstanceResult> getDeviceInstanceAsync(GetDeviceInstanceRequest request) {

        return getDeviceInstanceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetDeviceInstanceResult> getDeviceInstanceAsync(GetDeviceInstanceRequest request,
            com.amazonaws.handlers.AsyncHandler<GetDeviceInstanceRequest, GetDeviceInstanceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetDevicePoolResult> getDevicePoolAsync(GetDevicePoolRequest request) {

        return getDevicePoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetDevicePoolResult> getDevicePoolAsync(GetDevicePoolRequest request,
            com.amazonaws.handlers.AsyncHandler<GetDevicePoolRequest, GetDevicePoolResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetDevicePoolCompatibilityResult> getDevicePoolCompatibilityAsync(GetDevicePoolCompatibilityRequest request) {

        return getDevicePoolCompatibilityAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetDevicePoolCompatibilityResult> getDevicePoolCompatibilityAsync(GetDevicePoolCompatibilityRequest request,
            com.amazonaws.handlers.AsyncHandler<GetDevicePoolCompatibilityRequest, GetDevicePoolCompatibilityResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetInstanceProfileResult> getInstanceProfileAsync(GetInstanceProfileRequest request) {

        return getInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetInstanceProfileResult> getInstanceProfileAsync(GetInstanceProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<GetInstanceProfileRequest, GetInstanceProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetJobResult> getJobAsync(GetJobRequest request) {

        return getJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetJobResult> getJobAsync(GetJobRequest request,
            com.amazonaws.handlers.AsyncHandler<GetJobRequest, GetJobResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetNetworkProfileResult> getNetworkProfileAsync(GetNetworkProfileRequest request) {

        return getNetworkProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetNetworkProfileResult> getNetworkProfileAsync(GetNetworkProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<GetNetworkProfileRequest, GetNetworkProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetOfferingStatusResult> getOfferingStatusAsync(GetOfferingStatusRequest request) {

        return getOfferingStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetOfferingStatusResult> getOfferingStatusAsync(GetOfferingStatusRequest request,
            com.amazonaws.handlers.AsyncHandler<GetOfferingStatusRequest, GetOfferingStatusResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetProjectResult> getProjectAsync(GetProjectRequest request) {

        return getProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetProjectResult> getProjectAsync(GetProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<GetProjectRequest, GetProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetRemoteAccessSessionResult> getRemoteAccessSessionAsync(GetRemoteAccessSessionRequest request) {

        return getRemoteAccessSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetRemoteAccessSessionResult> getRemoteAccessSessionAsync(GetRemoteAccessSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<GetRemoteAccessSessionRequest, GetRemoteAccessSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetRunResult> getRunAsync(GetRunRequest request) {

        return getRunAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetRunResult> getRunAsync(GetRunRequest request,
            com.amazonaws.handlers.AsyncHandler<GetRunRequest, GetRunResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetSuiteResult> getSuiteAsync(GetSuiteRequest request) {

        return getSuiteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetSuiteResult> getSuiteAsync(GetSuiteRequest request,
            com.amazonaws.handlers.AsyncHandler<GetSuiteRequest, GetSuiteResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetTestResult> getTestAsync(GetTestRequest request) {

        return getTestAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetTestResult> getTestAsync(GetTestRequest request,
            com.amazonaws.handlers.AsyncHandler<GetTestRequest, GetTestResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetTestGridProjectResult> getTestGridProjectAsync(GetTestGridProjectRequest request) {

        return getTestGridProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetTestGridProjectResult> getTestGridProjectAsync(GetTestGridProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<GetTestGridProjectRequest, GetTestGridProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetTestGridSessionResult> getTestGridSessionAsync(GetTestGridSessionRequest request) {

        return getTestGridSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetTestGridSessionResult> getTestGridSessionAsync(GetTestGridSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<GetTestGridSessionRequest, GetTestGridSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetUploadResult> getUploadAsync(GetUploadRequest request) {

        return getUploadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetUploadResult> getUploadAsync(GetUploadRequest request,
            com.amazonaws.handlers.AsyncHandler<GetUploadRequest, GetUploadResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<GetVPCEConfigurationResult> getVPCEConfigurationAsync(GetVPCEConfigurationRequest request) {

        return getVPCEConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<GetVPCEConfigurationResult> getVPCEConfigurationAsync(GetVPCEConfigurationRequest request,
            com.amazonaws.handlers.AsyncHandler<GetVPCEConfigurationRequest, GetVPCEConfigurationResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<InstallToRemoteAccessSessionResult> installToRemoteAccessSessionAsync(InstallToRemoteAccessSessionRequest request) {

        return installToRemoteAccessSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<InstallToRemoteAccessSessionResult> installToRemoteAccessSessionAsync(InstallToRemoteAccessSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<InstallToRemoteAccessSessionRequest, InstallToRemoteAccessSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListArtifactsResult> listArtifactsAsync(ListArtifactsRequest request) {

        return listArtifactsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListArtifactsResult> listArtifactsAsync(ListArtifactsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListArtifactsRequest, ListArtifactsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListDeviceInstancesResult> listDeviceInstancesAsync(ListDeviceInstancesRequest request) {

        return listDeviceInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListDeviceInstancesResult> listDeviceInstancesAsync(ListDeviceInstancesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListDeviceInstancesRequest, ListDeviceInstancesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListDevicePoolsResult> listDevicePoolsAsync(ListDevicePoolsRequest request) {

        return listDevicePoolsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListDevicePoolsResult> listDevicePoolsAsync(ListDevicePoolsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListDevicePoolsRequest, ListDevicePoolsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListDevicesResult> listDevicesAsync(ListDevicesRequest request) {

        return listDevicesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListDevicesResult> listDevicesAsync(ListDevicesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListDevicesRequest, ListDevicesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListInstanceProfilesResult> listInstanceProfilesAsync(ListInstanceProfilesRequest request) {

        return listInstanceProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListInstanceProfilesResult> listInstanceProfilesAsync(ListInstanceProfilesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListInstanceProfilesRequest, ListInstanceProfilesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListJobsResult> listJobsAsync(ListJobsRequest request) {

        return listJobsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListJobsResult> listJobsAsync(ListJobsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListJobsRequest, ListJobsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListNetworkProfilesResult> listNetworkProfilesAsync(ListNetworkProfilesRequest request) {

        return listNetworkProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListNetworkProfilesResult> listNetworkProfilesAsync(ListNetworkProfilesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListNetworkProfilesRequest, ListNetworkProfilesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListOfferingPromotionsResult> listOfferingPromotionsAsync(ListOfferingPromotionsRequest request) {

        return listOfferingPromotionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListOfferingPromotionsResult> listOfferingPromotionsAsync(ListOfferingPromotionsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListOfferingPromotionsRequest, ListOfferingPromotionsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListOfferingTransactionsResult> listOfferingTransactionsAsync(ListOfferingTransactionsRequest request) {

        return listOfferingTransactionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListOfferingTransactionsResult> listOfferingTransactionsAsync(ListOfferingTransactionsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListOfferingTransactionsRequest, ListOfferingTransactionsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListOfferingsResult> listOfferingsAsync(ListOfferingsRequest request) {

        return listOfferingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListOfferingsResult> listOfferingsAsync(ListOfferingsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListOfferingsRequest, ListOfferingsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListProjectsResult> listProjectsAsync(ListProjectsRequest request) {

        return listProjectsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListProjectsResult> listProjectsAsync(ListProjectsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListProjectsRequest, ListProjectsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListRemoteAccessSessionsResult> listRemoteAccessSessionsAsync(ListRemoteAccessSessionsRequest request) {

        return listRemoteAccessSessionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListRemoteAccessSessionsResult> listRemoteAccessSessionsAsync(ListRemoteAccessSessionsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListRemoteAccessSessionsRequest, ListRemoteAccessSessionsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListRunsResult> listRunsAsync(ListRunsRequest request) {

        return listRunsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListRunsResult> listRunsAsync(ListRunsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListRunsRequest, ListRunsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListSamplesResult> listSamplesAsync(ListSamplesRequest request) {

        return listSamplesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListSamplesResult> listSamplesAsync(ListSamplesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListSamplesRequest, ListSamplesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListSuitesResult> listSuitesAsync(ListSuitesRequest request) {

        return listSuitesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListSuitesResult> listSuitesAsync(ListSuitesRequest request,
            com.amazonaws.handlers.AsyncHandler<ListSuitesRequest, ListSuitesResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTagsForResourceResult> listTagsForResourceAsync(ListTagsForResourceRequest request) {

        return listTagsForResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTagsForResourceResult> listTagsForResourceAsync(ListTagsForResourceRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTagsForResourceRequest, ListTagsForResourceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTestGridProjectsResult> listTestGridProjectsAsync(ListTestGridProjectsRequest request) {

        return listTestGridProjectsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTestGridProjectsResult> listTestGridProjectsAsync(ListTestGridProjectsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTestGridProjectsRequest, ListTestGridProjectsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionActionsResult> listTestGridSessionActionsAsync(ListTestGridSessionActionsRequest request) {

        return listTestGridSessionActionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionActionsResult> listTestGridSessionActionsAsync(ListTestGridSessionActionsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTestGridSessionActionsRequest, ListTestGridSessionActionsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionArtifactsResult> listTestGridSessionArtifactsAsync(ListTestGridSessionArtifactsRequest request) {

        return listTestGridSessionArtifactsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionArtifactsResult> listTestGridSessionArtifactsAsync(ListTestGridSessionArtifactsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTestGridSessionArtifactsRequest, ListTestGridSessionArtifactsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionsResult> listTestGridSessionsAsync(ListTestGridSessionsRequest request) {

        return listTestGridSessionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTestGridSessionsResult> listTestGridSessionsAsync(ListTestGridSessionsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTestGridSessionsRequest, ListTestGridSessionsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListTestsResult> listTestsAsync(ListTestsRequest request) {

        return listTestsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListTestsResult> listTestsAsync(ListTestsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListTestsRequest, ListTestsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListUniqueProblemsResult> listUniqueProblemsAsync(ListUniqueProblemsRequest request) {

        return listUniqueProblemsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListUniqueProblemsResult> listUniqueProblemsAsync(ListUniqueProblemsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListUniqueProblemsRequest, ListUniqueProblemsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListUploadsResult> listUploadsAsync(ListUploadsRequest request) {

        return listUploadsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListUploadsResult> listUploadsAsync(ListUploadsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListUploadsRequest, ListUploadsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ListVPCEConfigurationsResult> listVPCEConfigurationsAsync(ListVPCEConfigurationsRequest request) {

        return listVPCEConfigurationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ListVPCEConfigurationsResult> listVPCEConfigurationsAsync(ListVPCEConfigurationsRequest request,
            com.amazonaws.handlers.AsyncHandler<ListVPCEConfigurationsRequest, ListVPCEConfigurationsResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<PurchaseOfferingResult> purchaseOfferingAsync(PurchaseOfferingRequest request) {

        return purchaseOfferingAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<PurchaseOfferingResult> purchaseOfferingAsync(PurchaseOfferingRequest request,
            com.amazonaws.handlers.AsyncHandler<PurchaseOfferingRequest, PurchaseOfferingResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<RenewOfferingResult> renewOfferingAsync(RenewOfferingRequest request) {

        return renewOfferingAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<RenewOfferingResult> renewOfferingAsync(RenewOfferingRequest request,
            com.amazonaws.handlers.AsyncHandler<RenewOfferingRequest, RenewOfferingResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<ScheduleRunResult> scheduleRunAsync(ScheduleRunRequest request) {

        return scheduleRunAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<ScheduleRunResult> scheduleRunAsync(ScheduleRunRequest request,
            com.amazonaws.handlers.AsyncHandler<ScheduleRunRequest, ScheduleRunResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<StopJobResult> stopJobAsync(StopJobRequest request) {

        return stopJobAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<StopJobResult> stopJobAsync(StopJobRequest request,
            com.amazonaws.handlers.AsyncHandler<StopJobRequest, StopJobResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<StopRemoteAccessSessionResult> stopRemoteAccessSessionAsync(StopRemoteAccessSessionRequest request) {

        return stopRemoteAccessSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<StopRemoteAccessSessionResult> stopRemoteAccessSessionAsync(StopRemoteAccessSessionRequest request,
            com.amazonaws.handlers.AsyncHandler<StopRemoteAccessSessionRequest, StopRemoteAccessSessionResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<StopRunResult> stopRunAsync(StopRunRequest request) {

        return stopRunAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<StopRunResult> stopRunAsync(StopRunRequest request,
            com.amazonaws.handlers.AsyncHandler<StopRunRequest, StopRunResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<TagResourceResult> tagResourceAsync(TagResourceRequest request) {

        return tagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<TagResourceResult> tagResourceAsync(TagResourceRequest request,
            com.amazonaws.handlers.AsyncHandler<TagResourceRequest, TagResourceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UntagResourceResult> untagResourceAsync(UntagResourceRequest request) {

        return untagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UntagResourceResult> untagResourceAsync(UntagResourceRequest request,
            com.amazonaws.handlers.AsyncHandler<UntagResourceRequest, UntagResourceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateDeviceInstanceResult> updateDeviceInstanceAsync(UpdateDeviceInstanceRequest request) {

        return updateDeviceInstanceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateDeviceInstanceResult> updateDeviceInstanceAsync(UpdateDeviceInstanceRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateDeviceInstanceRequest, UpdateDeviceInstanceResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateDevicePoolResult> updateDevicePoolAsync(UpdateDevicePoolRequest request) {

        return updateDevicePoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateDevicePoolResult> updateDevicePoolAsync(UpdateDevicePoolRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateDevicePoolRequest, UpdateDevicePoolResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateInstanceProfileResult> updateInstanceProfileAsync(UpdateInstanceProfileRequest request) {

        return updateInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateInstanceProfileResult> updateInstanceProfileAsync(UpdateInstanceProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateInstanceProfileRequest, UpdateInstanceProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateNetworkProfileResult> updateNetworkProfileAsync(UpdateNetworkProfileRequest request) {

        return updateNetworkProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateNetworkProfileResult> updateNetworkProfileAsync(UpdateNetworkProfileRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateNetworkProfileRequest, UpdateNetworkProfileResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateProjectResult> updateProjectAsync(UpdateProjectRequest request) {

        return updateProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateProjectResult> updateProjectAsync(UpdateProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateProjectRequest, UpdateProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateTestGridProjectResult> updateTestGridProjectAsync(UpdateTestGridProjectRequest request) {

        return updateTestGridProjectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateTestGridProjectResult> updateTestGridProjectAsync(UpdateTestGridProjectRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateTestGridProjectRequest, UpdateTestGridProjectResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateUploadResult> updateUploadAsync(UpdateUploadRequest request) {

        return updateUploadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateUploadResult> updateUploadAsync(UpdateUploadRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateUploadRequest, UpdateUploadResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

    @Override
    public java.util.concurrent.Future<UpdateVPCEConfigurationResult> updateVPCEConfigurationAsync(UpdateVPCEConfigurationRequest request) {

        return updateVPCEConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<UpdateVPCEConfigurationResult> updateVPCEConfigurationAsync(UpdateVPCEConfigurationRequest request,
            com.amazonaws.handlers.AsyncHandler<UpdateVPCEConfigurationRequest, UpdateVPCEConfigurationResult> asyncHandler) {

        throw new java.lang.UnsupportedOperationException();
    }

}


text:
package org.apache.guacamole.auth.jdbc.connectiongroup;

import com.google.inject.Inject;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import org.apache.guacamole.GuacamoleException;
import org.apache.guacamole.auth.jdbc.base.RestrictedObject;
import org.apache.guacamole.net.auth.ConnectionGroup;
import org.apache.guacamole.net.auth.Directory;
import org.mybatis.guice.transactional.Transactional;

/**
 * Implementation of the ConnectionGroup Directory which is driven by an
 * underlying, arbitrary database.
 *
 * @author James Muehlner
 * @author Michael Jumper
 */
public class ConnectionGroupDirectory extends RestrictedObject
    implements Directory<ConnectionGroup> {

    /**
     * Service for managing connection group objects.
     */
    @Inject
    private ConnectionGroupService connectionGroupService;

    @Override
    public ConnectionGroup get(String identifier) throws GuacamoleException {
        return connectionGroupService.retrieveObject(getCurrentUser(), identifier);
    }

    @Override
    @Transactional
    public Collection<ConnectionGroup> getAll(Collection<String> identifiers) throws GuacamoleException {
        Collection<ModeledConnectionGroup> objects = connectionGroupService.retrieveObjects(getCurrentUser(), identifiers);
        return Collections.<ConnectionGroup>unmodifiableCollection(objects);
    }

    @Override
    @Transactional
    public Set<String> getIdentifiers() throws GuacamoleException {
        return connectionGroupService.getIdentifiers(getCurrentUser());
    }

    @Override
    @Transactional
    public void add(ConnectionGroup object) throws GuacamoleException {
        connectionGroupService.createObject(getCurrentUser(), object);
    }

    @Override
    @Transactional
    public void update(ConnectionGroup object) throws GuacamoleException {
        ModeledConnectionGroup connectionGroup = (ModeledConnectionGroup) object;
        connectionGroupService.updateObject(getCurrentUser(), connectionGroup);
    }

    @Override
    @Transactional
    public void remove(String identifier) throws GuacamoleException {
        connectionGroupService.deleteObject(getCurrentUser(), identifier);
    }

}

redpajama_set_name: RedPajamaGithub


text:
var assert = require('assert'),
    vows = require('vows');

var MailChimpAPI = require('mailchimp').MailChimpAPI;

vows.describe('MailChimpAPI').addBatch({

	'Instantiating the MailChimp API wrapper': {

		'without any arguments': {
			topic: function () { return new MailChimpAPI() },
			'throws an error': function (topic) {
				assert.throws(topic, Error);
				assert.strictEqual(topic.message, 'You have to provide an API key for this to work.');
			}
		},

		'with an API key': {
			topic: function () { return new MailChimpAPI('apiKey-dc') },
			'successfully creates an instance': function (topic) {
				assert.isObject(topic);
				assert.strictEqual(topic.version, '1.3');
			}
		},

		'without API key but with parameters': {
			topic: function () { return new MailChimpAPI({ version: '1.3' }) },
			'throws an error': function (topic) {
				assert.throws(topic, Error);
			}
		},

		'with an API key and parameters': {
			topic: function () { return new MailChimpAPI('apiKey-dc', { version: '1.3' }) },
			'successfully creates an instance': function (topic) {
				assert.isObject(topic);
				assert.strictEqual(topic.version, '1.3');
			}
		},

		'with an API key and an unsupported version': {
			topic: function () { return new MailChimpAPI('apiKey-dc', { version: '0.1' }) },
			'throws an error': function (topic) {
				assert.throws(topic, Error);
				assert.strictEqual(topic.message, 'Version 0.1 of the MailChimp API is currently not supported.');
			}
		}

	}

}).export(module);


text:
class CommentsController < ApplicationController
  protect_from_forgery

  def determine_type(params)
    types = %w(problem_id solution_id improvement_id)
    types.each_with_index do |type, index|
      return type if params.include?(type)
    end
  end

  def determine_id(params, parsed_type)
    return params[parsed_type]
  end

  def ready_comment_params(params)
    parsed_type = determine_type(params)
    parsed_id = determine_id(params, parsed_type)
    parsed_type.slice!("_id")
    return [parsed_type.classify.constantize.find(parsed_id), parsed_type, parsed_id]
  end

  def create
    comment_params = ready_comment_params(params)
    @comment = Comment.new(description: params[:comment_description], commentable_type: comment_params[1],
      commentable_id: comment_params[2], user: current_user, username: current_user.email)

    if @comment.save
      render json: { description: @comment.description,
                    commentable_type: @comment.commentable_type,
                    commentable_id: @comment.commentable_id,
                    username: @comment.user.email,
                    saved: true
                  }
    else
      # flash.now[:notice] = "Comment can't be blank"
      render json: { description: @comment.description,
                    commentable_type: @comment.commentable_type,
                    commentable_id: @comment.commentable_id,
                    username: @comment.user.email,
                    saved: false
                  }
    end
  end

  def problem_comments
    problem_number = params[:problem_id]
    @comments = Comment.where(commentable_type: "problem", commentable_id: problem_number)
    p @comments
    render json: { problems: @comments}
  end

  def solution_comments
    solution_number = params[:solution_id]
    @comments = Comment.where(commentable_type: "solution", commentable_id: solution_number)
    p @comments
    render json: { solutions: @comments}
  end

  def improvement_comments
    improvement_number = params[:improvement_id]
    @comments = Comment.where(commentable_type: "improvement", commentable_id: improvement_number)
    render json: { improvements: @comments}
  end

end


text:
var DESCRIPTORS = require('../internals/descriptors');
var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
var anObject = require('../internals/an-object');
var toPrimitive = require('../internals/to-primitive');

var nativeDefineProperty = Object.defineProperty;

// `Object.defineProperty` method
// https://tc39.github.io/ecma262/#sec-object.defineproperty
exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return nativeDefineProperty(O, P, Attributes);
  } catch (error) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};


text:
using namespace clang;

namespace {

// Check to ensure that implicit default argument expressions are visited.
class IntegerLiteralVisitor
    : public ExpectedLocationVisitor<IntegerLiteralVisitor> {
public:
  bool VisitIntegerLiteral(const IntegerLiteral *IL) {
    Match("literal", IL->getLocation());
    return true;
  }
};

TEST(RecursiveASTVisitor, DefaultArgumentsAreVisited) {
  IntegerLiteralVisitor Visitor;
  Visitor.ExpectMatch("literal", 1, 15, 2);
  EXPECT_TRUE(Visitor.runOver("int f(int i = 1);\n"
                              "static int k = f();\n"));
}

} // end anonymous namespace


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

namespace Xunit.Sdk
{
	/// <summary>
	/// Aggregates exceptions. Intended to run one or more code blocks, and collect the
	/// exceptions thrown by those code blocks.
	/// </summary>
	public class ExceptionAggregator
	{
		private readonly List<Exception> exceptions;

		/// <summary>
		/// Initializes a new instance of the <see cref="ExceptionAggregator"/> class.
		/// </summary>
		public ExceptionAggregator()
		{
			exceptions = new List<Exception>();
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="ExceptionAggregator"/> class that
		/// contains the exception list of its parent.
		/// </summary>
		/// <param name="parent">The parent aggregator to copy exceptions from.</param>
		public ExceptionAggregator(ExceptionAggregator parent)
		{
			exceptions = new List<Exception>(parent.exceptions);
		}

		/// <summary>
		/// Returns <c>true</c> if the aggregator has at least one exception inside it.
		/// </summary>
		public bool HasExceptions { get { return exceptions.Count > 0; } }

		/// <summary>
		/// Adds an exception to the aggregator.
		/// </summary>
		/// <param name="ex">The exception to be added.</param>
		public void Add(Exception ex)
		{
			exceptions.Add(ex);
		}

		/// <summary>
		/// Adds exceptions from another aggregator into this aggregator.
		/// </summary>
		/// <param name="aggregator">The aggregator whose exceptions should be copied.</param>
		public void Aggregate(ExceptionAggregator aggregator)
		{
			exceptions.AddRange(aggregator.exceptions);
		}

		/// <summary>
		/// Clears the aggregator.
		/// </summary>
		public void Clear()
		{
			exceptions.Clear();
		}

		/// <summary>
		/// Runs the code, catching the exception that is thrown and adding it to
		/// the aggregate.
		/// </summary>
		/// <param name="code">The code to be run.</param>
		public void Run(Action code)
		{
			try
			{
				code();
			}
			catch (Exception ex)
			{
				exceptions.Add(ex.Unwrap());
			}
		}

		/// <summary>
		/// Runs the code, catching the exception that is thrown and adding it to
		/// the aggregate.
		/// </summary>
		/// <param name="code">The code to be run.</param>
		public async Task RunAsync(Func<Task> code)
		{
			try
			{
				await code();
			}
			catch (Exception ex)
			{
				exceptions.Add(ex.Unwrap());
			}
		}

		/// <summary>
		/// Runs the code, catching the exception that is thrown and adding it to
		/// the aggregate.
		/// </summary>
		/// <param name="code">The code to be run.</param>
		public async Task<T> RunAsync<T>(Func<Task<T>> code)
		{
			try
			{
				return await code();
			}
			catch (Exception ex)
			{
				exceptions.Add(ex.Unwrap());
				return default(T);
			}
		}

		/// <summary>
		/// Returns an exception that represents the exceptions thrown by the code
		/// passed to the <see cref="Run"/> or <see cref="RunAsync"/> method.
		/// </summary>
		/// <returns>Returns <c>null</c> if no exceptions were thrown; returns the
		/// exact exception is a single exception was thrown; returns <see cref="AggregateException"/>
		/// if more than one exception was thrown.</returns>
		public Exception ToException()
		{
			if (exceptions.Count == 0)
				return null;
			if (exceptions.Count == 1)
				return exceptions[0];
			return new AggregateException(exceptions);
		}
	}
}


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

<title>Uses of Class oracle.kv.Durability.ReplicaAckPolicy (Oracle NoSQL Database API)</title>
<meta name="date" content="2015-12-03">
<link rel="stylesheet" type="text/css" href="../../../style.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Oracle NoSQL Database
 version 12cR1.3.5.2

Prev

Next

Frames

No Frames

All Classes

Uses of Class
oracle.kv.Durability.ReplicaAckPolicy

Packages that use Durability.ReplicaAckPolicy

Package
Description

oracle.kv

This package contains the public API for using Oracle NoSQL Database.

Uses of Durability.ReplicaAckPolicy in oracle.kv

Methods in oracle.kv that return Durability.ReplicaAckPolicy

Modifier and Type
Method and Description

Durability.ReplicaAckPolicy
DurabilityException.getCommitPolicy()

Returns the Replica ack policy that was in effect for the operation.

Durability.ReplicaAckPolicy
Durability.getReplicaAck()

Returns the replica acknowledgment policy used by the master when
 committing changes to a replicated environment.

static Durability.ReplicaAckPolicy
Durability.ReplicaAckPolicy.valueOf(String name)

Returns the enum constant of this type with the specified name.

static Durability.ReplicaAckPolicy[]
Durability.ReplicaAckPolicy.values()

Returns an array containing the constants of this enum type, in
the order they are declared.

Constructors in oracle.kv with parameters of type Durability.ReplicaAckPolicy

Constructor and Description

Durability(Durability.SyncPolicy masterSync,
          Durability.SyncPolicy replicaSync,
          Durability.ReplicaAckPolicy replicaAck)

Creates an instance of a Durability specification.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Oracle NoSQL Database
 version 12cR1.3.5.2

Prev

Next

Frames

No Frames

All Classes

Copyright (c) 2011, 2015 Oracle and/or its affiliates.  All rights reserved.


text:
package org.motechproject.server.demo.model;

import org.motechproject.commons.api.MotechException;
import org.springframework.beans.factory.InitializingBean;

import java.util.List;

public class NodeRecord implements InitializingBean {
    private Long id;
    private String name;
    private String message;
    private List<String> actionsBefore;
    private List<String> actionsAfter;
    private List<TransitionRecord> transitions;

    public Long getId() {
        return id;
    }

    public void setId(final Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(final String message) {
        this.message = message;
    }

    public List<String> getActionsBefore() {
        return actionsBefore;
    }

    public void setActionsBefore(final List<String> actionsBefore) {
        this.actionsBefore = actionsBefore;
    }

    public List<String> getActionsAfter() {
        return actionsAfter;
    }

    public void setActionsAfter(final List<String> actionsAfter) {
        this.actionsAfter = actionsAfter;
    }

    public List<TransitionRecord> getTransitions() {
        return transitions;
    }

    public void setTransitions(final List<TransitionRecord> transitions) {
        this.transitions = transitions;
    }

    @Override
    public void afterPropertiesSet() {
        if (getMessage() == null || getMessage().trim().isEmpty()) {
            throw new MotechException("Message content is required");
        }
    }

    @Override
    public String toString() {
        return "NodeRecord{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", message='" + message + '\'' +
                ", actionsBefore=" + actionsBefore +
                ", actionsAfter=" + actionsAfter +
                ", transitions=" + transitions +
                '}';
    }
}


text:
[sharq-server]
host                : localhost
port                : 7777
ssl                 : False

[webhooks]
queue_type          : webhooks
workers             : 10

[logging]
file                : /tmp/sharq_webhooks.log
level               : debug


text:
namespace CGAL {
  namespace SphericalFunctors {

    template < class SK >
    typename SK::Plane_3
    construct_plane_3(const typename SK::Polynomial_1_3 &eq)
    {
      typedef typename SK::Plane_3 Plane_3;
      return Plane_3(eq.a(),eq.b(),eq.c(),eq.d());
    }

  }//SphericalFunctors
}//CGAL

#endif //CGAL_SPHERICAL_KERNEL_PREDICATES_ON_PLANE_3_H


text:
using namespace std;

int main () {
  short n;
  unsigned short n1;
  cout << "Enter a number: ";
  cin >> n;
  cout << "You have entered: " << n << endl;
  assert((int)cin.gcount() >= 0);
  cout << "Enter a hexadecimal number: ";
  cin >> hex >> n;            // manipulator
//  assert(cin.flags() & ios::hex == iostream::hex);
  cout << "Its decimal equivalent is: " << n << endl;

  cout << "Enter a number: ";
  cin >> dec >> n1;
  cout << "You have entered: " << n1 << endl;
  assert((int)cin.gcount() >= 0);
  cout << "Enter a hexadecimal number: ";
  cin >> hex >> n1;            // manipulator
//  assert(cin.flags() & ios::hex == iostream::hex);
  cout << "Its decimal equivalent is: " << n1 << endl;

  assert((int)cin.gcount() >= 0);
  return 0;
}


text:
<?xml version="1.0" encoding="utf-8" ?>
<Suite Title="Twitter" Id="Twitter" Category="Social" RequireVersion="8.2" LoginButton="https://seotoolsforexcel.com/logins/twitter.png" SourceUrl="https://github.com/nielsbosma/SeoTools-for-Excel-Connectors/blob/master/Twitter.xml" HelpUrl="http://seotoolsforexcel.com/twitter/" HelpText="Documentation">

  <Author Name="Victor Sandberg" Url="http://community.seotoolsforexcel.com/users/diskborste/activity" />

  <SeoToolsAuthenticator StayAuthenticated="true" Key="twitter"/>

  <Resources>
    <Resource Id="Languages">
      <Item Id="ar" Title="Arabic"/>
      <Item Id="cs" Title="Czech"/>
      <Item Id="da" Title="Danish"/>
      <Item Id="de" Title="German"/>
      <Item Id="en" Title="English"/>
      <Item Id="et" Title="Estonian"/>
      <Item Id="fi" Title="Finnish"/>
      <Item Id="fr" Title="French"/>
      <Item Id="nl" Title="Dutch"/>
      <Item Id="he" Title="Hebrew"/>
      <Item Id="hu" Title="Hungarian"/>
      <Item Id="id" Title="Indonesian"/>
      <Item Id="it" Title="Italian"/>
      <Item Id="lt" Title="Lithuanian"/>
      <Item Id="lv" Title="Latvian"/>
      <Item Id="no" Title="Norwegian"/>
      <Item Id="pl" Title="Polish"/>
      <Item Id="pt" Title="Portuguese"/>
      <Item Id="ro" Title="Romanian"/>
      <Item Id="es" Title="Spanish"/>
      <Item Id="ru" Title="Russian"/>
      <Item Id="sv" Title="Swedish"/>
    </Resource>
    <Resource Id="HttpSettings">
      <HttpSettings>
        <OAuth>
          <ConsumerKey>@Model.OAuthConsumerKey</ConsumerKey>
          <ConsumerSecret>@Model.OAuthConsumerSecret</ConsumerSecret>
          <Token>@Model.OAuthToken</Token>
          <TokenSecret>@Model.OAuthTokenSecret</TokenSecret>
        </OAuth>
      </HttpSettings>
		</Resource>
    <Resource Id="Fail">
		  <Fail>
				<JsonPath Expr="errors[0].code" Fail.If="RegexMatches" Fail.ComparedTo="34" Fail.Action="EmptyResult"/>
				<JsonPath Expr="errors[0].message"/>
			</Fail>
		</Resource>
    <Resource Id="Tweet">
			<Compute Expr="https://www.twitter.com/@(Model.Inp1)/statuses/@(Model.Inp2)/" Id="Url" Title="URL">
				<JsonPath Expr="user.screen_name" Id="Inp1" DefaultValue=""/>
				<JsonPath Expr="id_str" Id="Inp2" DefaultValue=""/>
			</Compute>
			<JsonPath Expr="id_str" Id="Id" Title="Id" Converter="String"/>
			<JsonPath Expr="created_at" Id="CreatedAt" Title="Date" Converter="DateTime" Converter.SourceFormat="ddd MMM dd HH:mm:ss +ffff yyyy"/>
			<JsonPath Expr="text" Id="Text" Title="Text" Converter="String" DefaultValue=""/>
			<Compute Expr="@(GetTweetType(Model.txt))" Id="Type" Title="Type">
				<JsonPath Expr="text" Id="txt" Converter="String" DefaultValue=""/>
			</Compute>
			<Compute Expr="@(AdjustEngagement(Model.txt))" Id="Retweets" Title="Retweets" Converter="Int">
				<JsonPath Expr="retweet_count" Id="Inp" Converter="Int"/>
				<JsonPath Expr="text" Id="txt" Converter="String" DefaultValue=""/>
			</Compute>
			<Compute Expr="@(AdjustEngagement(Model.txt))" Id="Likes" Title="Likes" Converter="Int">
				<JsonPath Expr="favorite_count" Id="Inp" Converter="Int"/>
				<JsonPath Expr="text" Id="txt" Converter="String" DefaultValue=""/>
			</Compute>
			<JsonPath Expr="csv(entities.hashtags[*].text)" Id="HashtagEntities" Title="Hashtag Entities" Converter="Auto" DefaultValue=""/>
			<JsonPath Expr="csv(entities.urls[*].url)" Id="UrlEntities" Title="URL Entities" Converter="String" DefaultValue=""/>
			<JsonPath Expr="csv(entities.user_mentions[*].screen_name)" Id="MentionsEntities" Title="User Mentions Entities" Converter="Auto" DefaultValue=""/>
			<JsonPath Expr="entities.media[0].media_url" Id="PhotoUrl" Title="Media URL" Converter="String" DefaultValue=""/>
			<JsonPath Expr="csv(retweeted_status.entities.hashtags[*].text)" Id="RTHashtagEntities" Title="Retweeted Hashtag Entities" Converter="Auto" DefaultValue="" Checked="false"/>
			<JsonPath Expr="csv(retweeted_status.entities.urls[*].url)" Id="RTUrlEntities" Title="Retweeted URL Entities" Converter="String" DefaultValue="" Checked="false"/>
			<JsonPath Expr="csv(retweeted_status.entities.user_mentions[*].screen_name)" Id="RTMentionsEntities" Title="Retweeted User Mentions Entities" Converter="Auto" DefaultValue="" Checked="false"/>
			<JsonPath Expr="retweeted_status.entities.media[0].media_url" Id="RTPhotoUrl" Title="Retweeted Media URL" Converter="String" DefaultValue="" Checked="false"/>
			<JsonPath Expr="user.id_str" Id="UserId" Title="User ID" Converter="String"/>
			<JsonPath Expr="user.screen_name" Id="Username" Title="Username" Converter="String"/>
			<Compute Expr="https://www.twitter.com/@(Model.Inp)/" Id="UserUrl" Title="User URL">
				<JsonPath Expr="user.screen_name" Id="Inp" Converter="String" DefaultValue=""/>
			</Compute>
			<JsonPath Expr="user.followers_count" Id="Followers" Title="Followers" Converter="Int"/>
			<JsonPath Expr="user.name" Id="Name" Title="Name" Converter="String"/>
			<JsonPath Expr="user.location" Id="Location" Title="Location" Converter="String"/>
			<JsonPath Expr="user.description" Id="Bio" Title="Bio" Converter="String"/>
			<JsonPath Expr="user.friends_count" Id="Follows" Title="Follows" Converter="Int"/>
			<JsonPath Expr="user.listed_count" Id="Lists" Title="Lists" Converter="Int"/>
			<JsonPath Expr="user.statuses_count" Id="Tweets" Title="Tweets" Converter="Int"/>
			<JsonPath Expr="user.lang" Id="Language" Title="Language" Converter="String"/>
			<JsonPath Expr="user.favourites_count" Id="UserLikes" Title="UserLikes" Converter="Int"/>
			<JsonPath Expr="user.created_at" Id="Registered" Title="Registered" Converter="DateTime" Converter.SourceFormat="ddd MMM dd HH:mm:ss +ffff yyyy"/>
			<JsonPath Expr="user.url" Id="Website" Title="Website" Converter="String"/>
			<Compute Expr="@Model.Inp.Replace("_normal",string.Empty)" Id="Avatar" Title="Avatar">
				<JsonPath Expr="user.profile_image_url" Id="Inp" DefaultValue=""/>
			</Compute>
			<Compute Expr="@Utils.StripTags(Model.Inp)" Id="Source" Title="Source">
				<JsonPath Expr="source" Id="Inp" DefaultValue=""/>
			</Compute>
			<JsonPath Expr="retweeted_status.id_str" Id="RetweetedTweet" Title="Retweeted TweetId" Converter="String" DefaultValue="" Checked="false"/>
			<JsonPath Expr="retweeted_status.user.screen_name" Id="RetweetedUser" Title="Retweeted User" Converter="String" DefaultValue="" Checked="false"/>
			<JsonPath Expr="in_reply_to_status_id" Id="RepliedTweet" Title="Replied TweetId" Checked="false"/>
			<JsonPath Expr="in_reply_to_screen_name" Id="RepliedUser" Title="Replied User" Checked="false"/>
			<JsonPath Expr="place.full_name" Id="PlaceFullName" Title="Place Name" DefaultValue="" Checked="false"/>
			<JsonPath Expr="place.country" Id="PlaceCountry" Title="Place Country" DefaultValue="" Checked="false"/>
			<JsonPath Expr="place.bounding_box.coordinates" Id="PlaceCoordinates" Title="Place Coordinates" DefaultValue="" Checked="false"/>
		</Resource>
    <Resource Id="User">
			<Compute Expr="https://www.twitter.com/@(Model.Inp)/" Id="Url" Title="URL">
				<JsonPath Expr="screen_name" Id="Inp" DefaultValue=""/>
			</Compute>
			<JsonPath Expr="id_str" Id="Id" Title="User ID" Converter="String"/>
			<JsonPath Expr="screen_name" Id="ScreenName" Title="Username"/>
			<JsonPath Expr="name" Id="Name" Title="Name"/>
			<JsonPath Expr="favourites_count" Id="FavouritesCount" Title="Likes" Converter="Int"/>
			<JsonPath Expr="followers_count" Id="FollowersCount" Title="Followers" Converter="Int"/>
			<JsonPath Expr="friends_count" Id="FriendsCount" Title="Following" Converter="Int"/>
			<JsonPath Expr="statuses_count" Id="StatusesCount" Title="Tweets" Converter="Int"/>
			<JsonPath Expr="listed_count" Id="ListedCount" Title="Listed" Converter="Int"/>
			<JsonPath Expr="description" Id="Description" Title="Description"/>
			<JsonPath Expr="location" Id="Location" Title="Location"/>
			<JsonPath Expr="created_at" Id="CreatedAt" Title="Created" Converter="DateTime" Converter.SourceFormat="ddd MMM dd HH:mm:ss +ffff yyyy"/>
			<JsonPath Expr="lang" Id="Language" Title="Language" DefaultValue=""/>
			<JsonPath Expr="url" Id="Link" Title="Link"/>
			<Compute Expr="@Model.Inp.Replace("_normal",string.Empty)" Id="Avatar" Title="Avatar">
				<JsonPath Expr="profile_image_url" Id="Inp" DefaultValue=""/>
			</Compute>
		</Resource>
  </Resources>

  <RestConnector Id="TweetSearch" Title="Tweets Search" Group="Tweets" HelpUrl="https://developer.twitter.com/en/docs/tweets/search/api-reference/get-search-tweets.html">
    <Parameters>
      <Text Id="Query" Title="Query" Required="true" Debug.DefaultValue="obama" HelpUrl="https://dev.twitter.com/rest/public/search"/>
			<Checkbox Id="IncludeRtEng" Title="Include Engagement from Retweets" DefaultValue="true" HelpText="If false, sets retweets and likes count to 0 for all retweets"/>
      <Select Id="Language" Title="Language" Required="false" DefaultValue="">
        <DataSource>
          <Item Id="" Title="All"/>
          <Resource Id="Languages"/>
        </DataSource>
      </Select>
      <Select Id="Sorting" Title="Sorting" DefaultValue="Recent" Required="true">
        <DataSource>
          <Item Id="recent" Title="Recent"/>
          <Item Id="popular" Title="Popular"/>
          <Item Id="mixed" Title="Mixed"/>
        </DataSource>
      </Select>
    </Parameters>
    <Paging PageSize="100" EvenPages="false">
      <Parse>
        <JsonPath Expr="$.search_metadata.next_results" Id="NextResults" Converter="String"/>
      </Parse>
    </Paging>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/search/tweets.json
        @(Model.PageCursor.Page == 0 ? "?q=" + Utils.UrlEncode(Model.Query) + "&lang=" + Model.Language + "&sort=" + Model.Sorting + "&count=" + Model.PageCursor.NextTake : Model.NextResults)
				]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$.statuses[*]">
				<Resource Id="Tweet"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="TweetsLookup" Title="Tweets Lookup" Group="Tweets" HelpUrl="https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/get-statuses-lookup">
    <Parameters>
      <Text Id="Ids" Title="Tweet URLs or Ids (One per row)" Multiline="true" Debug.DefaultValue="1088844064236228608" Required="true"/>
			<Checkbox Id="IncludeRtEng" Title="Include Engagement from Retweets" DefaultValue="true" HelpText="If false, sets retweets and likes count to 0 for all retweets"/>
    </Parameters>
    <Batch Parameter="Ids" Separator="\n" ItemsPerBatch="100"/>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
				https://api.twitter.com/1.1/statuses
				@(Model.Ids.Split('\n').Length == 1 ? "/show.json" : "/lookup.json")
				?id=@FetchTweetString()
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="@bool2dim()">
				<Resource Id="Tweet"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="UserTweets" Title="Tweets from Users" Group="Tweets" HelpUrl="https://developer.twitter.com/en/docs/tweets/timelines/api-reference/get-statuses-user_timeline.html">
    <Parameters>
      <Text Id="Username" Title="Username" Debug.DefaultValue="nielsbosma" Required="true" Multiline="true"/>
      <Checkbox Id="IncludeRts" Title="Include Retweets" DefaultValue="true"/>
      <Checkbox Id="IncludeReplies" Title="Include Replies" DefaultValue="true"/>
			<Checkbox Id="IncludeRtEng" Title="Include Engagement from Retweets" DefaultValue="true" HelpText="If false, sets retweets and likes count to 0 for all retweets"/>
    </Parameters>
    <Paging PageSize="200" EvenPages="false">
      <Parse>
        <Compute Expr="@(Model.MaxIdString - 1)" Id="MaxId">
            <JsonPath Expr="$[-1:].id_str" Id="MaxIdString" Converter="Long"/>
        </Compute>
      </Parse>
    </Paging>
		<Batch Parameter="Username" Separator="\n"/>
    <Fetch>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/statuses/user_timeline.json?
        screen_name=@(StripTag(Model.Username))
        &count=@(Model.PageCursor.NextTake)
        &include_rts=@(Model.IncludeRts)
				&exclude_replies=@(!Model.IncludeReplies)
        @(Model.PageCursor.Page != 0 ? "&max_id=" + Model.MaxId : "")
        ]]>
      </Fetch.Url>
      <Resource Id="HttpSettings"/>
    </Fetch>
    <Parse>
      <JsonPath Expr="$[*]">
				<Resource Id="Tweet"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="TweetRetweets" Title="Tweets Retweets" Group="Tweets" HelpUrl="https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/get-statuses-retweets-id">
    <Parameters>
			<Text Id="Tweet" Title="Tweet Id or URL" Debug.DefaultValue="900341109343363072" HelpText="Returns up to 100 latest retweets of a tweet." Required="true" Multiline="true"/>
    	<Checkbox Id="IncludeRtEng" Title="Include Engagement from Retweets" DefaultValue="true" HelpText="If false, sets retweets and likes count to 0 for all retweets"/>
		</Parameters>
    <Paging PageSize="100" MaxTake="100" EvenPages="false"/>
		<Batch Parameter="Tweet" Separator="\n"/>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/statuses/retweets/
        @(FetchSingleTweet()).json?
        count=@(Model.PageCursor.PageSize)
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$[*]">
				<Resource Id="Tweet"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="UserSearch" Title="Users Search" Group="Users" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-search">
    <Parameters>
      <Text Id="Query" Title="Query" Required="true" Debug.DefaultValue="obama" HelpUrl="https://dev.twitter.com/rest/public/search"/>
    </Parameters>
    <Paging PageSize="20" EvenPages="false"/>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/users/search.json?
        &q=@Utils.UrlEncode(Model.Query)
        &count=@(Model.PageCursor.NextTake)
        &page=@(Model.PageCursor.Page+1)
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$[*]">
				<Resource Id="User"/>
				<Compute Expr="https://www.twitter.com/@(Model.Inp1)/statuses/@(Model.Inp2)/" Id="LastTweet" Title="Last Tweet">
					<JsonPath Expr="screen_name" Id="Inp1" DefaultValue=""/>
					<JsonPath Expr="status.id_str" Id="Inp2" DefaultValue=""/>
				</Compute>
				<JsonPath Expr="status.created_at" Id="LastTweeted" Title="Last Tweeted" Converter="DateTime" Converter.SourceFormat="ddd MMM dd HH:mm:ss +ffff yyyy"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="Followers" Title="User Followers" Group="Users" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-followers-list">
    <Parameters>
      <Text Id="Username" Title="Username" Debug.DefaultValue="nielsbosma" Required="true"/>
      <Text Id="CustomCursor" Title="Custom Cursor" Required="false"/>
    </Parameters>
    <Paging PageSize="200">
      <Parse>
        <JsonPath Id="NextCursor" Expr="next_cursor_str"/>
      </Parse>
    </Paging>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/followers/list.json?skip_status=true
        &screen_name=@(StripTag(Model.Username))
        &count=@(Model.PageCursor.NextTake)
        @(Model.PageCursor.Page != 0 ? "&cursor=" + Model.NextCursor
					: Model.PageCursor.Page == 0 && !string.IsNullOrEmpty(Model.CustomCursor)
					? "&cursor=" + Model.CustomCursor : "")
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$.users[*]">
				<Resource Id="User"/>
      </JsonPath>
      <JsonPath Expr="next_cursor_str" Id="NextCursor" Title="NextCursor" Converter="String" Checked="false"/>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="Following" Title="User Following" Group="Users" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friends-list">
    <Parameters>
      <Text Id="Username" Title="Username" Debug.DefaultValue="nielsbosma" Required="true"/>
      <Text Id="CustomCursor" Title="Custom Cursor" Required="false"/>
    </Parameters>
    <Paging PageSize="200">
      <Parse>
        <JsonPath Id="NextCursor" Expr="next_cursor_str"/>
      </Parse>
    </Paging>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/friends/list.json?skip_status=true
        &screen_name=@(StripTag(Model.Username))
        &count=@(Model.PageCursor.NextTake)
        @(Model.PageCursor.Page != 0 ? "&cursor=" + Model.NextCursor
					: Model.PageCursor.Page == 0 && !string.IsNullOrEmpty(Model.CustomCursor)
					? "&cursor=" + Model.CustomCursor : "")
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$.users[*]">
				<Resource Id="User"/>
      </JsonPath>
      <JsonPath Expr="next_cursor_str" Id="NextCursor" Title="NextCursor" Converter="String" Checked="false"/>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="UsersLookup" Title="Users Lookup" Group="Users" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-users-lookup">
    <Parameters>
      <Text Id="Ids" Title="Usernames (One per row)" Debug.DefaultValue="zaralarsson" Multiline="true" Required="true"/>
    </Parameters>
    <Batch Parameter="Ids" Separator="\n" ItemsPerBatch="100"/>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/users
				@(Model.Ids.Split('\n').Length == 1 ? "/show.json" : "/lookup.json")
				?screen_name=@FetchUserString()
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="@bool2dim()">
				<Resource Id="User"/>
				<Compute Expr="https://www.twitter.com/@(Model.Inp1)/statuses/@(Model.Inp2)/" Id="LastTweet" Title="Last Tweet">
					<JsonPath Expr="screen_name" Id="Inp1" DefaultValue=""/>
					<JsonPath Expr="status.id_str" Id="Inp2" DefaultValue=""/>
				</Compute>
				<JsonPath Expr="status.created_at" Id="LastTweeted" Title="Last Tweeted" Converter="DateTime" Converter.SourceFormat="ddd MMM dd HH:mm:ss +ffff yyyy"/>
			</JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="MyFriendshipsLookup" Title="My Friendships Lookup" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-lookup">
    <Parameters>
      <Radio Id="InputType" Title="Input Type" DefaultValue="ScreenName" Required="false">
        <DataSource>
          <Item Id="screen_name" Title="Screen Names"/>
          <Item Id="user_id" Title="User Ids"/>
        </DataSource>
      </Radio>
      <Text Id="Ids" Title="List of Users" Debug.DefaultValue="BroTommy2" HelpText="Enter usernames or user ids separated by a new line" Required="true" Multiline="true"/>
    </Parameters>
    <Batch Parameter="Ids" Separator="\n" ItemsPerBatch="100"/>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/friendships/lookup.json?
        @(Model.InputType)=@(FetchUserString())
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$[*]">
				<Compute Expr="https://www.twitter.com/@(Model.Inp)/" Id="Url" Title="URL">
					<JsonPath Expr="user.screen_name" Id="Inp" Converter="String" DefaultValue=""/>
				</Compute>
        <JsonPath Expr="id_str" Id="Id" Title="User ID" Converter="String"/>
        <JsonPath Expr="screen_name" Id="ScreenName" Title="Username"/>
        <JsonPath Expr="name" Id="Name" Title="Name"/>
        <JsonPath Expr="csv(connections)" Id="Connections" Title="Connections"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="FriendshipLookup" Title="Friendship Lookup" HelpUrl="https://developer.twitter.com/en/docs/accounts-and-users/follow-search-get-users/api-reference/get-friendships-show">
    <Parameters>
      <Radio Id="InputType" Title="Input Type" DefaultValue="ScreenName" Required="false">
        <DataSource>
          <Item Id="screen_name" Title="Screen Names"/>
          <Item Id="user_id" Title="User Ids"/>
        </DataSource>
      </Radio>
      <Text Id="SourceUser" Title="Source Username" Debug.DefaultValue="wearebuddler" HelpText="The subject username." Required="true"/>
      <Text Id="TargetUser" Title="Target Username" Debug.DefaultValue="kenyavic" HelpText="The taget username." Required="true"/>
    </Parameters>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/friendships/show.json?
        source_@(Model.InputType)=@(StripTag(Model.SourceUser))
        &target_@(Model.InputType)=@(StripTag(Model.TargetUser))
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$.relationship.source">
        <JsonPath Expr="followed_by" Id="FollowedBy" Title="Followed By" Converter="Bool"/>
        <JsonPath Expr="following" Id="Following" Title="Following" Converter="Bool"/>
        <JsonPath Expr="live_following" Id="LiveFollowing" Title="Live Following" Converter="Bool" Checked="false"/>
        <JsonPath Expr="following_received" Id="FollowingReceived" Title="Following Received" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="following_requested" Id="FollowingRequested" Title="Following Requested" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="notifications_enabled" Id="NotificationsEnabled" Title="Notifications Enabled" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="can_dm" Id="CanDM" Title="Can DM" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="blocking" Id="Blocking" Title="Blocking" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="blocked_by" Id="BlockedBy" Title="Blocked By" Converter="String" DefaultValue="" Checked="false"/>
        <JsonPath Expr="muting" Id="Muting" Title="Muting" Converter="String" DefaultValue="" Checked="false"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="TrendsInPlace" Title="Trends In Place" HelpUrl="https://developer.twitter.com/en/docs/trends/trends-for-location/api-reference/get-trends-place">
    <Parameters>
      <Text Id="WOEID" Title="WOE Id" Debug.DefaultValue="906057" HelpText="The Yahoo! Where On Earth ID of the location to return trending information for." Required="true"/>
    </Parameters>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/trends/place.json?id=@(Model.WOEID)
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$..trends[*]">
        <JsonPath Expr="name" Id="Name" Title="Name" Converter="String"/>
        <JsonPath Expr="tweet_volume" Id="Volume" Title="Volume" Converter="Long"/>
        <JsonPath Expr="url" Id="Url" Title="Search URL" Converter="String"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RestConnector Id="ListMembers" Title="Members of List" HelpUrl="https://developer.twitter.com/en/docs/twitter-api/v1/accounts-and-users/create-manage-lists/api-reference/get-lists-members">
    <Parameters>
      <Text Id="ListId" Title="List Id" Debug.DefaultValue="888737722378145797" HelpText="The numerical id of the list." Required="true"/>
    </Parameters>
    <Fetch>
			<Resource Id="HttpSettings"/>
      <Fetch.Url>
        <![CDATA[
        https://api.twitter.com/1.1/lists/members.json?
        list_id=@Model.ListId
				&count=5000
        ]]>
      </Fetch.Url>
    </Fetch>
    <Parse>
      <JsonPath Expr="$.users[*]">
				<Resource Id="User"/>
      </JsonPath>
    </Parse>
    <Resource Id="Fail"/>
  </RestConnector>

  <RazorFunctions>
    <![CDATA[
    string FetchUserString() {
			string[] lines = ((string)Model.Ids).Trim().Split('\n').Select(e => e.Trim()).Where(e => !string.IsNullOrEmpty(e)).ToArray();
      return string.Join(",",lines.Select(e => Regex.Replace(e, @"^@", string.Empty)).ToArray());
    }

    string FetchTweetString() {
			string[] lines = ((string)Model.Ids).Trim().Split('\n').Select(e => e.Trim()).Where(e => !string.IsNullOrEmpty(e)).ToArray();
      return string.Join(",",lines.Select(e => Regex.Replace(e, @"(\w*)\/status", string.Empty)).Select((e, i) => Regex.Replace(e, @"[^\d]", string.Empty)).ToArray());
    }

		string FetchSingleTweet() {
			Regex regex = new Regex(@"/status(es)?/(\d+)");

			if(!regex.IsMatch(Model.Tweet))
				return Model.Tweet;

			Match match = regex.Match(Model.Tweet);
			return match.Groups[1].Value;
		}

		string bool2dim() {
			return (Model.Ids.Split('\n').Length > 1 ? "$[*]" : "$");
		}

		string GetTweetType(string txt) {
			if(txt.StartsWith("RT @"))
			{
				return "Retweet";
			}
			if(txt.StartsWith("@"))
			{
				return "Reply";
			}
			return "Tweet";
		}

		long AdjustEngagement(string txt) {
			return (!Model.IncludeRtEng && GetTweetType(txt) == "Retweet") ? 0 : Model.Inp;
		}

    string StripTag(string username) {
			return username.StartsWith("@") ? username.Substring(1) : username;
		}
    ]]>
  </RazorFunctions>

</Suite>


text:
workshop-recipe-geneticist
==========================

Recipe for hosting a geneticist workshop


text:
package root.time;

import root.lang.Extractable;
import root.lang.StringExtractor;

/**
 *
 * @author Edward Smith
 * @version 0.5
 * @since 0.5
 */
public final class Time implements Extractable {

	// <><><><><><><><><><><><><><><> Attributes <><><><><><><><><><><><><><><>

	public int hour;
	public int minute;
	public int second;

	// <><><><><><><><><><><><><><>< Constructors ><><><><><><><><><><><><><><>

	public Time() {
		// No-op default constructor
	}

	public Time(final int hour, final int minute, final int second) {
		this.hour = hour;
		this.minute = minute;
		this.second = second;
	}

	// <><><><><><><><><><><><><><> Public Methods <><><><><><><><><><><><><><>

	@Override
	public final void extract(final StringExtractor extractor) {
		// 1. Append the hour
		if (this.hour < 10) {
			extractor.append('0');
		}
		extractor.append(this.hour);
		extractor.append(':');

		// 2. Append the minute
		if (this.minute < 10) {
			extractor.append('0');
		}
		extractor.append(this.minute);
		extractor.append(':');

		// 3. Append the second
		if (this.second < 10) {
			extractor.append('0');
		}
		extractor.append(this.second);
	}

	@Override
	public final String toString() {
		final StringExtractor extractor = new StringExtractor(8);
		this.extract(extractor);
		return extractor.toString();
	}

} // End Time


text:
namespace media {

// The Common Encryption spec provides for subsample encryption, where portions
// of a sample are set in cleartext. A SubsampleEntry specifies the number of
// clear and encrypted bytes in each subsample. For decryption, all of the
// encrypted bytes in a sample should be considered a single logical stream,
// regardless of how they are divided into subsamples, and the clear bytes
// should not be considered as part of decryption. This is logically equivalent
// to concatenating all 'cypher_bytes' portions of subsamples, decrypting that
// result, and then copying each byte from the decrypted block over the
// position of the corresponding encrypted byte.
struct SubsampleEntry {
  SubsampleEntry() : clear_bytes(0), cypher_bytes(0) {}
  SubsampleEntry(uint32_t clear_bytes, uint32_t cypher_bytes)
      : clear_bytes(clear_bytes), cypher_bytes(cypher_bytes) {}
  uint32_t clear_bytes;
  uint32_t cypher_bytes;
};

}  // namespace media

#endif  // MEDIA_BASE_SUBSAMPLE_ENTRY_H_


text:
- PHP 5.6 improvements ([#482](https://github.com/phpseclib/phpseclib/pull/482), [#491](https://github.com/phpseclib/phpseclib/issues/491))

## 0.3.8 - 2014-09-12

- improve support for indef lengths in File_ASN1
- add hmac-sha2-256 support to Net_SSH2
- make it so negotiated algorithms can be seen before Net_SSH2 login
- add sha256-96 and sha512-96 to Crypt_Hash
- window size handling adjustments in Net_SSH2

## 0.3.7 - 2014-07-05

- auto-detect public vs private keys
- add file_exists, is_dir, is_file, readlink and symlink to Net_SFTP
- add support for recursive nlist and rawlist
- make it so nlist and rawlist can return pre-sorted output
- make it so callback functions can make exec() return early
- add signSPKAC and saveSPKAC methods to File_X509
- add support for PKCS8 keys in Crypt_RSA
- add pbkdf1 support to setPassword() in Crypt_Base
- add getWindowColumns, getWindowRows, setWindowColumns, setWindowRows to Net_SSH2
- add support for filenames with spaces in them to Net_SCP

## 0.3.6 - 2014-02-23

- add preliminary support for custom SSH subsystems
- add ssh-agent support

## 0.3.5 - 2013-07-11

- numerous SFTP changes:
 - chown
 - chgrp
 - truncate
 - improved file type detection
 - put() can write to te middle of a file
 - mkdir accepts the same paramters that PHP's mkdir does
 - the ability to upload/download 2GB files
- across-the-board speedups for the various encryption algorithms
- multi-factor authentication support for Net_SSH2
- a $callback parameter for Net_SSH2::exec
- new classes:
 - Net_SFTP_StreamWrapper
 - Net_SCP
 - Crypt_Twofish
 - Crypt_Blowfish

## 0.3.1 - 2012-11-20

- add Net_SSH2::enableQuietMode() for suppressing stderr
- add Crypt_RSA::__toString() and Crypt_RSA::getSize()
- fix problems with File_X509::validateDate(), File_X509::sign() and Crypt_RSA::verify()
- use OpenSSL to speed up modular exponention in Math_BigInteger
- improved timeout functionality in Net_SSH2
- add support for SFTPv2
- add support for CRLs in File_X509
- SSH-2.0-SSH doesn't implement hmac-*-96 correctly

## 0.3.0 - 2012-07-08

- add support for reuming Net_SFTP::put()
- add support for recursive deletes and recursive chmods to Net_SFTP
- add setTimeout() to Net_SSH2
- add support for PBKDF2 to the various Crypt_* classes via setPassword()
- add File_X509 and File_ASN1
- add the ability to decode various formats in Crypt_RSA
- make Net_SSH2::getServerPublicHostKey() return a printer-friendly version of the public key

## 0.2.2 - 2011-05-09

- CFB and OFB modes were added to all block ciphers
- support for interactive mode was added to Net_SSH2
- Net_SSH2 now has limited keyboard_interactive authentication support
- support was added for PuTTY formatted RSA private keys and XML formatted RSA private keys
- Crypt_RSA::loadKey() will now try all key types automatically
= add support for AES-128-CBC and DES-EDE3-CFB encrypted RSA private keys
- add Net_SFTP::stat(), Net_SFTP::lstat() and Net_SFTP::rawlist()
- logging was added to Net_SSH1
- the license was changed to the less restrictive MIT license


text:
package com.coiney.akka.rabbit.example

import akka.actor.{Props, ActorSystem}

import com.coiney.akka.rabbit.{QueueConfig, RabbitSystem}
import com.coiney.akka.rabbit.protocol._

object ConsumerExample1 extends App {

  implicit val system = ActorSystem("ConsumerSystem")

  val rabbitSystem = RabbitSystem()

  // create the connection keeper and wait for it to be connected
  val connectionKeeper = rabbitSystem waitFor rabbitSystem.createConnection("connection")
  // // alternatively, you can also
  // val connectionKeeper = rabbitSystem.createConnection("connection")
  // rabbitSystem.waitForConnection(connectionKeeper)

  // create the producer and wait for it to be connected
  val consumeActor = system.actorOf(Props(classOf[ConsumeActor]))
  val consumer = rabbitSystem waitFor rabbitSystem.createConsumer(connectionKeeper, consumeActor, "consumer")
  // // Same here: alternatively, you can also
  // val consumer = rabbitSystem.createConsumer(connectionKeeper, consumeActor, "consumer")
  // rabbitSystem.waitForConnection(consumer)

  // consume the queue
  consumer ! ConsumeQueue(QueueConfig("my_queue"))

  // shutdown the system
  Thread.sleep(1000)
  system.shutdown()
}


text:
#define LOG_TAG "WebCore"

#include "config.h"
#include "RenderSkinMediaButton.h"

#include "Document.h"
#include "IntRect.h"
#include "Node.h"
#include "RenderObject.h"
#include "RenderSkinAndroid.h"
#include "RenderSlider.h"
#include "SkCanvas.h"
#include "SkNinePatch.h"
#include "SkRect.h"
#include <androidfw/AssetManager.h>
#include <utils/Debug.h>
#include <utils/Log.h>
#include <wtf/text/CString.h>

extern android::AssetManager* globalAssetManager();

struct PatchData {
    const char* name;
    int8_t outset, margin;
};

static const PatchData gFiles[] =
    {
        { "scrubber_primary_holo.9.png", 0, 0 }, // SLIDER_TRACK, left of the SLIDER_THUMB
        { "ic_media_pause.png", 0, 0}, // PAUSE
        { "ic_media_play.png", 0, 0 }, // PLAY
        { "ic_media_pause.png", 0, 0 }, // MUTE
        { "ic_media_rew.png", 0, 0 }, // REWIND
        { "ic_media_ff.png", 0, 0 }, // FORWARD
        { "ic_media_fullscreen.png", 0, 0 }, // FULLSCREEN
        { "spinner_76_outer_holo.png", 0, 0 }, // SPINNER_OUTER
        { "spinner_76_inner_holo.png", 0, 0 }, // SPINNER_INNER
        { "ic_media_video_poster.png", 0, 0 }, // VIDEO
        { "btn_media_player_disabled.9.png", 0, 0 }, // BACKGROUND_SLIDER
        { "scrubber_track_holo_dark.9.png", 0, 0 },  // SLIDER_TRACK
        { "scrubber_control_normal_holo.png", 0, 0 }      // SLIDER_THUMB
    };

static SkBitmap gButton[sizeof(gFiles)/sizeof(gFiles[0])];
static bool gDecoded;
static bool gDecodingFailed;

namespace WebCore {

void RenderSkinMediaButton::Decode()
{
    String drawableDirectory = RenderSkinAndroid::DrawableDirectory();

    gDecoded = true;
    gDecodingFailed = false;
    android::AssetManager* am = globalAssetManager();
    for (size_t i = 0; i < sizeof(gFiles)/sizeof(gFiles[0]); i++) {
        String path = drawableDirectory + gFiles[i].name;
        if (!RenderSkinAndroid::DecodeBitmap(am, path.utf8().data(), &gButton[i])) {
            gDecodingFailed = true;
            ALOGD("RenderSkinButton::Init: button assets failed to decode\n\tBrowser buttons will not draw");
            break;
        }
    }
}

void RenderSkinMediaButton::Draw(SkCanvas* canvas, const IntRect& r,
                                 MediaButton buttonType, bool translucent,
                                 bool drawBackground, const IntRect& thumb)
{
    if (!gDecoded) {
        Decode();
    }

    if (!canvas)
        return;

    // If we failed to decode, do nothing.  This way the browser still works,
    // and webkit will still draw the label and layout space for us.
    if (gDecodingFailed)
        return;

    bool drawsNinePatch = false;
    bool drawsImage = true;

    int ninePatchIndex = 0;
    int imageIndex = 0;

    SkRect bounds(r);
    SkScalar imageMargin = 8;
    SkPaint paint;

    int alpha = 255;
    if (translucent)
        alpha = 190;

    SkColor backgroundColor = SkColorSetARGB(alpha, 34, 34, 34);
    SkColor trackBackgroundColor = SkColorSetARGB(255, 100, 100, 100);
    paint.setColor(backgroundColor);
#if ENABLE(OLD_SKIA)
    paint.setFlags(SkPaint::kFilterBitmap_Flag);
#else
    paint.setFilterBitmap(true);
#endif

    switch (buttonType) {
    case PAUSE:
    case PLAY:
    case MUTE:
    case REWIND:
    case FORWARD:
    case FULLSCREEN:
    {
         imageIndex = buttonType + 1;
         paint.setColor(backgroundColor);
         break;
    }
    case SPINNER_OUTER:
    case SPINNER_INNER:
    case VIDEO:
    {
         imageIndex = buttonType + 1;
         break;
    }
    case BACKGROUND_SLIDER:
    {
         drawsImage = false;
         break;
    }
    case SLIDER_TRACK:
    {
         drawsNinePatch = true;
         drawsImage = false;
         ninePatchIndex = buttonType + 1;
         break;
    }
    case SLIDER_THUMB:
    {
         imageMargin = 0;
         imageIndex = buttonType + 1;
         break;
    }
    default:
         return;
    }

    if (drawBackground) {
        canvas->drawRect(r, paint);
    }

    if (drawsNinePatch) {
        const PatchData& pd = gFiles[ninePatchIndex];
        int marginValue = pd.margin + pd.outset;

        SkIRect margin;
        margin.set(marginValue, marginValue, marginValue, marginValue);
        if (buttonType == SLIDER_TRACK) {
            // Cut the height in half (with some extra slop determined by trial
            // and error to get the placement just right.
            SkScalar quarterHeight = SkScalarHalf(SkScalarHalf(bounds.height()));
            bounds.fTop += quarterHeight + SkScalarHalf(3);
            bounds.fBottom += -quarterHeight + SK_ScalarHalf;
            if (!thumb.isEmpty()) {
                // Inset the track by half the width of the thumb, so the track
                // does not appear to go beyond the space where the thumb can
                // be.
                SkScalar thumbHalfWidth = SkIntToScalar(thumb.width()/2);
                bounds.fLeft += thumbHalfWidth;
                bounds.fRight -= thumbHalfWidth;
                if (thumb.x() > 0) {
                    // The video is past the starting point.  Show the area to
                    // left of the thumb as having been played.
                    SkScalar alreadyPlayed = SkIntToScalar(thumb.center().x() + r.x());
                    SkRect playedRect(bounds);
                    playedRect.fRight = alreadyPlayed;
                    SkNinePatch::DrawNine(canvas, playedRect, gButton[0], margin);
                    bounds.fLeft = alreadyPlayed;
                }

            }
        }
        SkNinePatch::DrawNine(canvas, bounds, gButton[ninePatchIndex], margin);
    }

    if (drawsImage) {
        SkScalar SIZE = gButton[imageIndex].width();
        SkScalar width = r.width();
        SkScalar scale = SkScalarDiv(width - 2*imageMargin, SIZE);
        int saveScaleCount = canvas->save();
        canvas->translate(bounds.fLeft + imageMargin, bounds.fTop + imageMargin);
        canvas->scale(scale, scale);
        canvas->drawBitmap(gButton[imageIndex], 0, 0, &paint);
        canvas->restoreToCount(saveScaleCount);
    }
}

} // WebCore