text:
package android.support.multidex;

import android.app.Application;
import android.content.Context;

/**
 * Minimal MultiDex capable application. To use the legacy multidex library there is 3 possibility:
 *

 *
Declare this class as the application in your AndroidManifest.xml.

 *
Have your {@link Application} extends this class.

 *
Have your {@link Application} override attachBaseContext starting with

 *
  protected void attachBaseContext(Context base) {

    super.attachBaseContext(base);

    MultiDex.install(this);

 *

 */
public class MultiDexApplication extends Application {
  @Override
  protected void attachBaseContext(Context base) {
    super.attachBaseContext(base);
    MultiDex.install(this);
  }
}


text:
#pragma once
#include <aws/macie2/Macie2_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <aws/macie2/model/JobStatus.h>
#include <aws/macie2/model/JobType.h>
#include <aws/macie2/model/LastRunErrorStatus.h>
#include <aws/macie2/model/ManagedDataIdentifierSelector.h>
#include <aws/macie2/model/S3JobDefinition.h>
#include <aws/macie2/model/JobScheduleFrequency.h>
#include <aws/macie2/model/Statistics.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/macie2/model/UserPausedDetails.h>
#include <utility>
#include <aws/core/utils/UUID.h>

namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;

namespace Utils
{
namespace Json
{
  class JsonValue;
} // namespace Json
} // namespace Utils
namespace Macie2
{
namespace Model
{
  class AWS_MACIE2_API DescribeClassificationJobResult
  {
  public:
    DescribeClassificationJobResult();
    DescribeClassificationJobResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
    DescribeClassificationJobResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline const Aws::Vector<Aws::String>& GetAllowListIds() const{ return m_allowListIds; }

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline void SetAllowListIds(const Aws::Vector<Aws::String>& value) { m_allowListIds = value; }

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline void SetAllowListIds(Aws::Vector<Aws::String>&& value) { m_allowListIds = std::move(value); }

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline DescribeClassificationJobResult& WithAllowListIds(const Aws::Vector<Aws::String>& value) { SetAllowListIds(value); return *this;}

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline DescribeClassificationJobResult& WithAllowListIds(Aws::Vector<Aws::String>&& value) { SetAllowListIds(std::move(value)); return *this;}

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline DescribeClassificationJobResult& AddAllowListIds(const Aws::String& value) { m_allowListIds.push_back(value); return *this; }

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline DescribeClassificationJobResult& AddAllowListIds(Aws::String&& value) { m_allowListIds.push_back(std::move(value)); return *this; }

    /**
     *
An array of unique identifiers, one for each allow list that the job uses
     * when it analyzes data.

     */
    inline DescribeClassificationJobResult& AddAllowListIds(const char* value) { m_allowListIds.push_back(value); return *this; }

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline const Aws::String& GetClientToken() const{ return m_clientToken; }

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline void SetClientToken(const Aws::String& value) { m_clientToken = value; }

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline void SetClientToken(Aws::String&& value) { m_clientToken = std::move(value); }

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline void SetClientToken(const char* value) { m_clientToken.assign(value); }

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline DescribeClassificationJobResult& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline DescribeClassificationJobResult& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}

    /**
     *
The token that was provided to ensure the idempotency of the request to
     * create the job.

     */
    inline DescribeClassificationJobResult& WithClientToken(const char* value) { SetClientToken(value); return *this;}

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job was
     * created.

     */
    inline const Aws::Utils::DateTime& GetCreatedAt() const{ return m_createdAt; }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job was
     * created.

     */
    inline void SetCreatedAt(const Aws::Utils::DateTime& value) { m_createdAt = value; }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job was
     * created.

     */
    inline void SetCreatedAt(Aws::Utils::DateTime&& value) { m_createdAt = std::move(value); }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job was
     * created.

     */
    inline DescribeClassificationJobResult& WithCreatedAt(const Aws::Utils::DateTime& value) { SetCreatedAt(value); return *this;}

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job was
     * created.

     */
    inline DescribeClassificationJobResult& WithCreatedAt(Aws::Utils::DateTime&& value) { SetCreatedAt(std::move(value)); return *this;}

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline const Aws::Vector<Aws::String>& GetCustomDataIdentifierIds() const{ return m_customDataIdentifierIds; }

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline void SetCustomDataIdentifierIds(const Aws::Vector<Aws::String>& value) { m_customDataIdentifierIds = value; }

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline void SetCustomDataIdentifierIds(Aws::Vector<Aws::String>&& value) { m_customDataIdentifierIds = std::move(value); }

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline DescribeClassificationJobResult& WithCustomDataIdentifierIds(const Aws::Vector<Aws::String>& value) { SetCustomDataIdentifierIds(value); return *this;}

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline DescribeClassificationJobResult& WithCustomDataIdentifierIds(Aws::Vector<Aws::String>&& value) { SetCustomDataIdentifierIds(std::move(value)); return *this;}

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline DescribeClassificationJobResult& AddCustomDataIdentifierIds(const Aws::String& value) { m_customDataIdentifierIds.push_back(value); return *this; }

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline DescribeClassificationJobResult& AddCustomDataIdentifierIds(Aws::String&& value) { m_customDataIdentifierIds.push_back(std::move(value)); return *this; }

    /**
     *
An array of unique identifiers, one for each custom data identifier that the
     * job uses when it analyzes data. This value is null if the job uses only managed
     * data identifiers to analyze data.

     */
    inline DescribeClassificationJobResult& AddCustomDataIdentifierIds(const char* value) { m_customDataIdentifierIds.push_back(value); return *this; }

    /**
     *
The custom description of the job.

     */
    inline const Aws::String& GetDescription() const{ return m_description; }

    /**
     *
The custom description of the job.

     */
    inline void SetDescription(const Aws::String& value) { m_description = value; }

    /**
     *
The custom description of the job.

     */
    inline void SetDescription(Aws::String&& value) { m_description = std::move(value); }

    /**
     *
The custom description of the job.

     */
    inline void SetDescription(const char* value) { m_description.assign(value); }

    /**
     *
The custom description of the job.

     */
    inline DescribeClassificationJobResult& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}

    /**
     *
The custom description of the job.

     */
    inline DescribeClassificationJobResult& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}

    /**
     *
The custom description of the job.

     */
    inline DescribeClassificationJobResult& WithDescription(const char* value) { SetDescription(value); return *this;}

    /**
     *
For a recurring job, specifies whether you configured the job to analyze all
     * existing, eligible objects immediately after the job was created (true). If you
     * configured the job to analyze only those objects that were created or changed
     * after the job was created and before the job's first scheduled run, this value
     * is false. This value is also false for a one-time job.

     */
    inline bool GetInitialRun() const{ return m_initialRun; }

    /**
     *
For a recurring job, specifies whether you configured the job to analyze all
     * existing, eligible objects immediately after the job was created (true). If you
     * configured the job to analyze only those objects that were created or changed
     * after the job was created and before the job's first scheduled run, this value
     * is false. This value is also false for a one-time job.

     */
    inline void SetInitialRun(bool value) { m_initialRun = value; }

    /**
     *
For a recurring job, specifies whether you configured the job to analyze all
     * existing, eligible objects immediately after the job was created (true). If you
     * configured the job to analyze only those objects that were created or changed
     * after the job was created and before the job's first scheduled run, this value
     * is false. This value is also false for a one-time job.

     */
    inline DescribeClassificationJobResult& WithInitialRun(bool value) { SetInitialRun(value); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline const Aws::String& GetJobArn() const{ return m_jobArn; }

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline void SetJobArn(const Aws::String& value) { m_jobArn = value; }

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline void SetJobArn(Aws::String&& value) { m_jobArn = std::move(value); }

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline void SetJobArn(const char* value) { m_jobArn.assign(value); }

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline DescribeClassificationJobResult& WithJobArn(const Aws::String& value) { SetJobArn(value); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline DescribeClassificationJobResult& WithJobArn(Aws::String&& value) { SetJobArn(std::move(value)); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the job.

     */
    inline DescribeClassificationJobResult& WithJobArn(const char* value) { SetJobArn(value); return *this;}

    /**
     *
The unique identifier for the job.

     */
    inline const Aws::String& GetJobId() const{ return m_jobId; }

    /**
     *
The unique identifier for the job.

     */
    inline void SetJobId(const Aws::String& value) { m_jobId = value; }

    /**
     *
The unique identifier for the job.

     */
    inline void SetJobId(Aws::String&& value) { m_jobId = std::move(value); }

    /**
     *
The unique identifier for the job.

     */
    inline void SetJobId(const char* value) { m_jobId.assign(value); }

    /**
     *
The unique identifier for the job.

     */
    inline DescribeClassificationJobResult& WithJobId(const Aws::String& value) { SetJobId(value); return *this;}

    /**
     *
The unique identifier for the job.

     */
    inline DescribeClassificationJobResult& WithJobId(Aws::String&& value) { SetJobId(std::move(value)); return *this;}

    /**
     *
The unique identifier for the job.

     */
    inline DescribeClassificationJobResult& WithJobId(const char* value) { SetJobId(value); return *this;}

    /**
     *
The current status of the job. Possible values are:

CANCELLED
     * - You cancelled the job or, if it's a one-time job, you paused the job and
     * didn't resume it within 30 days.

COMPLETE - For a one-time job,
     * Amazon Macie finished processing the data specified for the job. This value
     * doesn't apply to recurring jobs.

IDLE - For a recurring job, the
     * previous scheduled run is complete and the next scheduled run is pending. This
     * value doesn't apply to one-time jobs.

PAUSED - Macie started
     * running the job but additional processing would exceed the monthly sensitive
     * data discovery quota for your account or one or more member accounts that the
     * job analyzes data for.

RUNNING - For a one-time job, the job is
     * in progress. For a recurring job, a scheduled run is in progress.

     *

USER_PAUSED - You paused the job. If you paused the job while it had a
     * status of RUNNING and you don't resume it within 30 days of pausing it, the job
     * or job run will expire and be cancelled, depending on the job's type. To check
     * the expiration date, refer to the UserPausedDetails.jobExpiresAt
     * property.

     */
    inline const JobStatus& GetJobStatus() const{ return m_jobStatus; }

    /**
     *
The current status of the job. Possible values are:

CANCELLED
     * - You cancelled the job or, if it's a one-time job, you paused the job and
     * didn't resume it within 30 days.

COMPLETE - For a one-time job,
     * Amazon Macie finished processing the data specified for the job. This value
     * doesn't apply to recurring jobs.

IDLE - For a recurring job, the
     * previous scheduled run is complete and the next scheduled run is pending. This
     * value doesn't apply to one-time jobs.

PAUSED - Macie started
     * running the job but additional processing would exceed the monthly sensitive
     * data discovery quota for your account or one or more member accounts that the
     * job analyzes data for.

RUNNING - For a one-time job, the job is
     * in progress. For a recurring job, a scheduled run is in progress.

     *

USER_PAUSED - You paused the job. If you paused the job while it had a
     * status of RUNNING and you don't resume it within 30 days of pausing it, the job
     * or job run will expire and be cancelled, depending on the job's type. To check
     * the expiration date, refer to the UserPausedDetails.jobExpiresAt
     * property.

     */
    inline void SetJobStatus(const JobStatus& value) { m_jobStatus = value; }

    /**
     *
The current status of the job. Possible values are:

CANCELLED
     * - You cancelled the job or, if it's a one-time job, you paused the job and
     * didn't resume it within 30 days.

COMPLETE - For a one-time job,
     * Amazon Macie finished processing the data specified for the job. This value
     * doesn't apply to recurring jobs.

IDLE - For a recurring job, the
     * previous scheduled run is complete and the next scheduled run is pending. This
     * value doesn't apply to one-time jobs.

PAUSED - Macie started
     * running the job but additional processing would exceed the monthly sensitive
     * data discovery quota for your account or one or more member accounts that the
     * job analyzes data for.

RUNNING - For a one-time job, the job is
     * in progress. For a recurring job, a scheduled run is in progress.

     *

USER_PAUSED - You paused the job. If you paused the job while it had a
     * status of RUNNING and you don't resume it within 30 days of pausing it, the job
     * or job run will expire and be cancelled, depending on the job's type. To check
     * the expiration date, refer to the UserPausedDetails.jobExpiresAt
     * property.

     */
    inline void SetJobStatus(JobStatus&& value) { m_jobStatus = std::move(value); }

    /**
     *
The current status of the job. Possible values are:

CANCELLED
     * - You cancelled the job or, if it's a one-time job, you paused the job and
     * didn't resume it within 30 days.

COMPLETE - For a one-time job,
     * Amazon Macie finished processing the data specified for the job. This value
     * doesn't apply to recurring jobs.

IDLE - For a recurring job, the
     * previous scheduled run is complete and the next scheduled run is pending. This
     * value doesn't apply to one-time jobs.

PAUSED - Macie started
     * running the job but additional processing would exceed the monthly sensitive
     * data discovery quota for your account or one or more member accounts that the
     * job analyzes data for.

RUNNING - For a one-time job, the job is
     * in progress. For a recurring job, a scheduled run is in progress.

     *

USER_PAUSED - You paused the job. If you paused the job while it had a
     * status of RUNNING and you don't resume it within 30 days of pausing it, the job
     * or job run will expire and be cancelled, depending on the job's type. To check
     * the expiration date, refer to the UserPausedDetails.jobExpiresAt
     * property.

     */
    inline DescribeClassificationJobResult& WithJobStatus(const JobStatus& value) { SetJobStatus(value); return *this;}

    /**
     *
The current status of the job. Possible values are:

CANCELLED
     * - You cancelled the job or, if it's a one-time job, you paused the job and
     * didn't resume it within 30 days.

COMPLETE - For a one-time job,
     * Amazon Macie finished processing the data specified for the job. This value
     * doesn't apply to recurring jobs.

IDLE - For a recurring job, the
     * previous scheduled run is complete and the next scheduled run is pending. This
     * value doesn't apply to one-time jobs.

PAUSED - Macie started
     * running the job but additional processing would exceed the monthly sensitive
     * data discovery quota for your account or one or more member accounts that the
     * job analyzes data for.

RUNNING - For a one-time job, the job is
     * in progress. For a recurring job, a scheduled run is in progress.

     *

USER_PAUSED - You paused the job. If you paused the job while it had a
     * status of RUNNING and you don't resume it within 30 days of pausing it, the job
     * or job run will expire and be cancelled, depending on the job's type. To check
     * the expiration date, refer to the UserPausedDetails.jobExpiresAt
     * property.

     */
    inline DescribeClassificationJobResult& WithJobStatus(JobStatus&& value) { SetJobStatus(std::move(value)); return *this;}

    /**
     *
The schedule for running the job. Possible values are:

     *

ONE_TIME - The job runs only once.

SCHEDULED - The
     * job runs on a daily, weekly, or monthly basis. The scheduleFrequency property
     * indicates the recurrence pattern for the job.

     */
    inline const JobType& GetJobType() const{ return m_jobType; }

    /**
     *
The schedule for running the job. Possible values are:

     *

ONE_TIME - The job runs only once.

SCHEDULED - The
     * job runs on a daily, weekly, or monthly basis. The scheduleFrequency property
     * indicates the recurrence pattern for the job.

     */
    inline void SetJobType(const JobType& value) { m_jobType = value; }

    /**
     *
The schedule for running the job. Possible values are:

     *

ONE_TIME - The job runs only once.

SCHEDULED - The
     * job runs on a daily, weekly, or monthly basis. The scheduleFrequency property
     * indicates the recurrence pattern for the job.

     */
    inline void SetJobType(JobType&& value) { m_jobType = std::move(value); }

    /**
     *
The schedule for running the job. Possible values are:

     *

ONE_TIME - The job runs only once.

SCHEDULED - The
     * job runs on a daily, weekly, or monthly basis. The scheduleFrequency property
     * indicates the recurrence pattern for the job.

     */
    inline DescribeClassificationJobResult& WithJobType(const JobType& value) { SetJobType(value); return *this;}

    /**
     *
The schedule for running the job. Possible values are:

     *

ONE_TIME - The job runs only once.

SCHEDULED - The
     * job runs on a daily, weekly, or monthly basis. The scheduleFrequency property
     * indicates the recurrence pattern for the job.

     */
    inline DescribeClassificationJobResult& WithJobType(JobType&& value) { SetJobType(std::move(value)); return *this;}

    /**
     *
Specifies whether any account- or bucket-level access errors occurred when
     * the job ran. For a recurring job, this value indicates the error status of the
     * job's most recent run.

     */
    inline const LastRunErrorStatus& GetLastRunErrorStatus() const{ return m_lastRunErrorStatus; }

    /**
     *
Specifies whether any account- or bucket-level access errors occurred when
     * the job ran. For a recurring job, this value indicates the error status of the
     * job's most recent run.

     */
    inline void SetLastRunErrorStatus(const LastRunErrorStatus& value) { m_lastRunErrorStatus = value; }

    /**
     *
Specifies whether any account- or bucket-level access errors occurred when
     * the job ran. For a recurring job, this value indicates the error status of the
     * job's most recent run.

     */
    inline void SetLastRunErrorStatus(LastRunErrorStatus&& value) { m_lastRunErrorStatus = std::move(value); }

    /**
     *
Specifies whether any account- or bucket-level access errors occurred when
     * the job ran. For a recurring job, this value indicates the error status of the
     * job's most recent run.

     */
    inline DescribeClassificationJobResult& WithLastRunErrorStatus(const LastRunErrorStatus& value) { SetLastRunErrorStatus(value); return *this;}

    /**
     *
Specifies whether any account- or bucket-level access errors occurred when
     * the job ran. For a recurring job, this value indicates the error status of the
     * job's most recent run.

     */
    inline DescribeClassificationJobResult& WithLastRunErrorStatus(LastRunErrorStatus&& value) { SetLastRunErrorStatus(std::move(value)); return *this;}

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job started.
     * If the job is a recurring job, this value indicates when the most recent run
     * started or, if the job hasn't run yet, when the job was created.

     */
    inline const Aws::Utils::DateTime& GetLastRunTime() const{ return m_lastRunTime; }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job started.
     * If the job is a recurring job, this value indicates when the most recent run
     * started or, if the job hasn't run yet, when the job was created.

     */
    inline void SetLastRunTime(const Aws::Utils::DateTime& value) { m_lastRunTime = value; }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job started.
     * If the job is a recurring job, this value indicates when the most recent run
     * started or, if the job hasn't run yet, when the job was created.

     */
    inline void SetLastRunTime(Aws::Utils::DateTime&& value) { m_lastRunTime = std::move(value); }

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job started.
     * If the job is a recurring job, this value indicates when the most recent run
     * started or, if the job hasn't run yet, when the job was created.

     */
    inline DescribeClassificationJobResult& WithLastRunTime(const Aws::Utils::DateTime& value) { SetLastRunTime(value); return *this;}

    /**
     *
The date and time, in UTC and extended ISO 8601 format, when the job started.
     * If the job is a recurring job, this value indicates when the most recent run
     * started or, if the job hasn't run yet, when the job was created.

     */
    inline DescribeClassificationJobResult& WithLastRunTime(Aws::Utils::DateTime&& value) { SetLastRunTime(std::move(value)); return *this;}

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline const Aws::Vector<Aws::String>& GetManagedDataIdentifierIds() const{ return m_managedDataIdentifierIds; }

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline void SetManagedDataIdentifierIds(const Aws::Vector<Aws::String>& value) { m_managedDataIdentifierIds = value; }

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline void SetManagedDataIdentifierIds(Aws::Vector<Aws::String>&& value) { m_managedDataIdentifierIds = std::move(value); }

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline DescribeClassificationJobResult& WithManagedDataIdentifierIds(const Aws::Vector<Aws::String>& value) { SetManagedDataIdentifierIds(value); return *this;}

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline DescribeClassificationJobResult& WithManagedDataIdentifierIds(Aws::Vector<Aws::String>&& value) { SetManagedDataIdentifierIds(std::move(value)); return *this;}

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline DescribeClassificationJobResult& AddManagedDataIdentifierIds(const Aws::String& value) { m_managedDataIdentifierIds.push_back(value); return *this; }

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline DescribeClassificationJobResult& AddManagedDataIdentifierIds(Aws::String&& value) { m_managedDataIdentifierIds.push_back(std::move(value)); return *this; }

    /**
     *
An array of unique identifiers, one for each managed data identifier that the
     * job is explicitly configured to include (use) or exclude (not use) when it
     * analyzes data. Inclusion or exclusion depends on the managed data identifier
     * selection type specified for the job (managedDataIdentifierSelector). This value
     * is null if the job's managed data identifier selection type is ALL or the job
     * uses only custom data identifiers (customDataIdentifierIds) to analyze data.

     */
    inline DescribeClassificationJobResult& AddManagedDataIdentifierIds(const char* value) { m_managedDataIdentifierIds.push_back(value); return *this; }

    /**
     *
The selection type that determines which managed data identifiers the job
     * uses to analyze data. Possible values are:

ALL - Use all the
     * managed data identifiers that Amazon Macie provides.

EXCLUDE -
     * Use all the managed data identifiers that Macie provides except the managed data
     * identifiers specified by the managedDataIdentifierIds property.

     *

INCLUDE - Use only the managed data identifiers specified by the
     * managedDataIdentifierIds property.

NONE - Don't use any managed
     * data identifiers.

If this value is null, the job uses all
     * managed data identifiers. If this value is null, ALL, or EXCLUDE for a recurring
     * job, the job also uses new managed data identifiers as they are released.

     */
    inline const ManagedDataIdentifierSelector& GetManagedDataIdentifierSelector() const{ return m_managedDataIdentifierSelector; }

    /**
     *
The selection type that determines which managed data identifiers the job
     * uses to analyze data. Possible values are:

ALL - Use all the
     * managed data identifiers that Amazon Macie provides.

EXCLUDE -
     * Use all the managed data identifiers that Macie provides except the managed data
     * identifiers specified by the managedDataIdentifierIds property.

     *

INCLUDE - Use only the managed data identifiers specified by the
     * managedDataIdentifierIds property.

NONE - Don't use any managed
     * data identifiers.

If this value is null, the job uses all
     * managed data identifiers. If this value is null, ALL, or EXCLUDE for a recurring
     * job, the job also uses new managed data identifiers as they are released.

     */
    inline void SetManagedDataIdentifierSelector(const ManagedDataIdentifierSelector& value) { m_managedDataIdentifierSelector = value; }

    /**
     *
The selection type that determines which managed data identifiers the job
     * uses to analyze data. Possible values are:

ALL - Use all the
     * managed data identifiers that Amazon Macie provides.

EXCLUDE -
     * Use all the managed data identifiers that Macie provides except the managed data
     * identifiers specified by the managedDataIdentifierIds property.

     *

INCLUDE - Use only the managed data identifiers specified by the
     * managedDataIdentifierIds property.

NONE - Don't use any managed
     * data identifiers.

If this value is null, the job uses all
     * managed data identifiers. If this value is null, ALL, or EXCLUDE for a recurring
     * job, the job also uses new managed data identifiers as they are released.

     */
    inline void SetManagedDataIdentifierSelector(ManagedDataIdentifierSelector&& value) { m_managedDataIdentifierSelector = std::move(value); }

    /**
     *
The selection type that determines which managed data identifiers the job
     * uses to analyze data. Possible values are:

ALL - Use all the
     * managed data identifiers that Amazon Macie provides.

EXCLUDE -
     * Use all the managed data identifiers that Macie provides except the managed data
     * identifiers specified by the managedDataIdentifierIds property.

     *

INCLUDE - Use only the managed data identifiers specified by the
     * managedDataIdentifierIds property.

NONE - Don't use any managed
     * data identifiers.

If this value is null, the job uses all
     * managed data identifiers. If this value is null, ALL, or EXCLUDE for a recurring
     * job, the job also uses new managed data identifiers as they are released.

     */
    inline DescribeClassificationJobResult& WithManagedDataIdentifierSelector(const ManagedDataIdentifierSelector& value) { SetManagedDataIdentifierSelector(value); return *this;}

    /**
     *
The selection type that determines which managed data identifiers the job
     * uses to analyze data. Possible values are:

ALL - Use all the
     * managed data identifiers that Amazon Macie provides.

EXCLUDE -
     * Use all the managed data identifiers that Macie provides except the managed data
     * identifiers specified by the managedDataIdentifierIds property.

     *

INCLUDE - Use only the managed data identifiers specified by the
     * managedDataIdentifierIds property.

NONE - Don't use any managed
     * data identifiers.

If this value is null, the job uses all
     * managed data identifiers. If this value is null, ALL, or EXCLUDE for a recurring
     * job, the job also uses new managed data identifiers as they are released.

     */
    inline DescribeClassificationJobResult& WithManagedDataIdentifierSelector(ManagedDataIdentifierSelector&& value) { SetManagedDataIdentifierSelector(std::move(value)); return *this;}

    /**
     *
The custom name of the job.

     */
    inline const Aws::String& GetName() const{ return m_name; }

    /**
     *
The custom name of the job.

     */
    inline void SetName(const Aws::String& value) { m_name = value; }

    /**
     *
The custom name of the job.

     */
    inline void SetName(Aws::String&& value) { m_name = std::move(value); }

    /**
     *
The custom name of the job.

     */
    inline void SetName(const char* value) { m_name.assign(value); }

    /**
     *
The custom name of the job.

     */
    inline DescribeClassificationJobResult& WithName(const Aws::String& value) { SetName(value); return *this;}

    /**
     *
The custom name of the job.

     */
    inline DescribeClassificationJobResult& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}

    /**
     *
The custom name of the job.

     */
    inline DescribeClassificationJobResult& WithName(const char* value) { SetName(value); return *this;}

    /**
     *
The S3 buckets that contain the objects to analyze, and the scope of that
     * analysis.

     */
    inline const S3JobDefinition& GetS3JobDefinition() const{ return m_s3JobDefinition; }

    /**
     *
The S3 buckets that contain the objects to analyze, and the scope of that
     * analysis.

     */
    inline void SetS3JobDefinition(const S3JobDefinition& value) { m_s3JobDefinition = value; }

    /**
     *
The S3 buckets that contain the objects to analyze, and the scope of that
     * analysis.

     */
    inline void SetS3JobDefinition(S3JobDefinition&& value) { m_s3JobDefinition = std::move(value); }

    /**
     *
The S3 buckets that contain the objects to analyze, and the scope of that
     * analysis.

     */
    inline DescribeClassificationJobResult& WithS3JobDefinition(const S3JobDefinition& value) { SetS3JobDefinition(value); return *this;}

    /**
     *
The S3 buckets that contain the objects to analyze, and the scope of that
     * analysis.

     */
    inline DescribeClassificationJobResult& WithS3JobDefinition(S3JobDefinition&& value) { SetS3JobDefinition(std::move(value)); return *this;}

    /**
     *
The sampling depth, as a percentage, that determines the percentage of
     * eligible objects that the job analyzes.

     */
    inline int GetSamplingPercentage() const{ return m_samplingPercentage; }

    /**
     *
The sampling depth, as a percentage, that determines the percentage of
     * eligible objects that the job analyzes.

     */
    inline void SetSamplingPercentage(int value) { m_samplingPercentage = value; }

    /**
     *
The sampling depth, as a percentage, that determines the percentage of
     * eligible objects that the job analyzes.

     */
    inline DescribeClassificationJobResult& WithSamplingPercentage(int value) { SetSamplingPercentage(value); return *this;}

    /**
     *
The recurrence pattern for running the job. This value is null if the job is
     * configured to run only once.

     */
    inline const JobScheduleFrequency& GetScheduleFrequency() const{ return m_scheduleFrequency; }

    /**
     *
The recurrence pattern for running the job. This value is null if the job is
     * configured to run only once.

     */
    inline void SetScheduleFrequency(const JobScheduleFrequency& value) { m_scheduleFrequency = value; }

    /**
     *
The recurrence pattern for running the job. This value is null if the job is
     * configured to run only once.

     */
    inline void SetScheduleFrequency(JobScheduleFrequency&& value) { m_scheduleFrequency = std::move(value); }

    /**
     *
The recurrence pattern for running the job. This value is null if the job is
     * configured to run only once.

     */
    inline DescribeClassificationJobResult& WithScheduleFrequency(const JobScheduleFrequency& value) { SetScheduleFrequency(value); return *this;}

    /**
     *
The recurrence pattern for running the job. This value is null if the job is
     * configured to run only once.

     */
    inline DescribeClassificationJobResult& WithScheduleFrequency(JobScheduleFrequency&& value) { SetScheduleFrequency(std::move(value)); return *this;}

    /**
     *
The number of times that the job has run and processing statistics for the
     * job's current run.

     */
    inline const Statistics& GetStatistics() const{ return m_statistics; }

    /**
     *
The number of times that the job has run and processing statistics for the
     * job's current run.

     */
    inline void SetStatistics(const Statistics& value) { m_statistics = value; }

    /**
     *
The number of times that the job has run and processing statistics for the
     * job's current run.

     */
    inline void SetStatistics(Statistics&& value) { m_statistics = std::move(value); }

    /**
     *
The number of times that the job has run and processing statistics for the
     * job's current run.

     */
    inline DescribeClassificationJobResult& WithStatistics(const Statistics& value) { SetStatistics(value); return *this;}

    /**
     *
The number of times that the job has run and processing statistics for the
     * job's current run.

     */
    inline DescribeClassificationJobResult& WithStatistics(Statistics&& value) { SetStatistics(std::move(value)); return *this;}

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline const Aws::Map<Aws::String, Aws::String>& GetTags() const{ return m_tags; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline void SetTags(const Aws::Map<Aws::String, Aws::String>& value) { m_tags = value; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline void SetTags(Aws::Map<Aws::String, Aws::String>&& value) { m_tags = std::move(value); }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& WithTags(const Aws::Map<Aws::String, Aws::String>& value) { SetTags(value); return *this;}

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& WithTags(Aws::Map<Aws::String, Aws::String>&& value) { SetTags(std::move(value)); return *this;}

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(const Aws::String& key, const Aws::String& value) { m_tags.emplace(key, value); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(Aws::String&& key, const Aws::String& value) { m_tags.emplace(std::move(key), value); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(const Aws::String& key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(Aws::String&& key, Aws::String&& value) { m_tags.emplace(std::move(key), std::move(value)); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(const char* key, Aws::String&& value) { m_tags.emplace(key, std::move(value)); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(Aws::String&& key, const char* value) { m_tags.emplace(std::move(key), value); return *this; }

    /**
     *
A map of key-value pairs that specifies which tags (keys and values) are
     * associated with the classification job.

     */
    inline DescribeClassificationJobResult& AddTags(const char* key, const char* value) { m_tags.emplace(key, value); return *this; }

    /**
     *
If the current status of the job is USER_PAUSED, specifies when the job was
     * paused and when the job or job run will expire and be cancelled if it isn't
     * resumed. This value is present only if the value for jobStatus is
     * USER_PAUSED.

     */
    inline const UserPausedDetails& GetUserPausedDetails() const{ return m_userPausedDetails; }

    /**
     *
If the current status of the job is USER_PAUSED, specifies when the job was
     * paused and when the job or job run will expire and be cancelled if it isn't
     * resumed. This value is present only if the value for jobStatus is
     * USER_PAUSED.

     */
    inline void SetUserPausedDetails(const UserPausedDetails& value) { m_userPausedDetails = value; }

    /**
     *
If the current status of the job is USER_PAUSED, specifies when the job was
     * paused and when the job or job run will expire and be cancelled if it isn't
     * resumed. This value is present only if the value for jobStatus is
     * USER_PAUSED.

     */
    inline void SetUserPausedDetails(UserPausedDetails&& value) { m_userPausedDetails = std::move(value); }

    /**
     *
If the current status of the job is USER_PAUSED, specifies when the job was
     * paused and when the job or job run will expire and be cancelled if it isn't
     * resumed. This value is present only if the value for jobStatus is
     * USER_PAUSED.

     */
    inline DescribeClassificationJobResult& WithUserPausedDetails(const UserPausedDetails& value) { SetUserPausedDetails(value); return *this;}

    /**
     *
If the current status of the job is USER_PAUSED, specifies when the job was
     * paused and when the job or job run will expire and be cancelled if it isn't
     * resumed. This value is present only if the value for jobStatus is
     * USER_PAUSED.

     */
    inline DescribeClassificationJobResult& WithUserPausedDetails(UserPausedDetails&& value) { SetUserPausedDetails(std::move(value)); return *this;}

  private:

    Aws::Vector<Aws::String> m_allowListIds;

    Aws::String m_clientToken;

    Aws::Utils::DateTime m_createdAt;

    Aws::Vector<Aws::String> m_customDataIdentifierIds;

    Aws::String m_description;

    bool m_initialRun;

    Aws::String m_jobArn;

    Aws::String m_jobId;

    JobStatus m_jobStatus;

    JobType m_jobType;

    LastRunErrorStatus m_lastRunErrorStatus;

    Aws::Utils::DateTime m_lastRunTime;

    Aws::Vector<Aws::String> m_managedDataIdentifierIds;

    ManagedDataIdentifierSelector m_managedDataIdentifierSelector;

    Aws::String m_name;

    S3JobDefinition m_s3JobDefinition;

    int m_samplingPercentage;

    JobScheduleFrequency m_scheduleFrequency;

    Statistics m_statistics;

    Aws::Map<Aws::String, Aws::String> m_tags;

    UserPausedDetails m_userPausedDetails;
  };

} // namespace Model
} // namespace Macie2
} // namespace Aws

redpajama_set_name: RedPajamaGithub


text:
/* Container Appearance */

.daterangepicker {
  position: absolute;
  background: #fff;
  top: 100px;
  left: 20px;
  padding: 4px;
  margin-top: 1px;
  border-radius: 4px;
}

.daterangepicker.opensleft:before {
  position: absolute;
  top: -7px;
  right: 9px;
  display: inline-block;
  border-right: 7px solid transparent;
  border-bottom: 7px solid #ccc;
  border-left: 7px solid transparent;
  border-bottom-color: rgba(0, 0, 0, 0.2);
  content: '';
}

.daterangepicker.opensleft:after {
  position: absolute;
  top: -6px;
  right: 10px;
  display: inline-block;
  border-right: 6px solid transparent;
  border-bottom: 6px solid #fff;
  border-left: 6px solid transparent;
  content: '';
}

.daterangepicker.openscenter:before {
  position: absolute;
  top: -7px;
  left: 0;
  right: 0;
  width: 0;
  margin-left: auto;
  margin-right: auto;
  display: inline-block;
  border-right: 7px solid transparent;
  border-bottom: 7px solid #ccc;
  border-left: 7px solid transparent;
  border-bottom-color: rgba(0, 0, 0, 0.2);
  content: '';
}

.daterangepicker.openscenter:after {
  position: absolute;
  top: -6px;
  left: 0;
  right: 0;
  width: 0;
  margin-left: auto;
  margin-right: auto;
  display: inline-block;
  border-right: 6px solid transparent;
  border-bottom: 6px solid #fff;
  border-left: 6px solid transparent;
  content: '';
}

.daterangepicker.opensright:before {
  position: absolute;
  top: -7px;
  left: 9px;
  display: inline-block;
  border-right: 7px solid transparent;
  border-bottom: 7px solid #ccc;
  border-left: 7px solid transparent;
  border-bottom-color: rgba(0, 0, 0, 0.2);
  content: '';
}

.daterangepicker.opensright:after {
  position: absolute;
  top: -6px;
  left: 10px;
  display: inline-block;
  border-right: 6px solid transparent;
  border-bottom: 6px solid #fff;
  border-left: 6px solid transparent;
  content: '';
}

.daterangepicker.dropup{
  margin-top: -5px;
}
.daterangepicker.dropup:before{
  top: initial;
  bottom:-7px;
  border-bottom: initial;
  border-top: 7px solid #ccc;
}
.daterangepicker.dropup:after{
  top: initial;
  bottom:-6px;
  border-bottom: initial;
  border-top: 6px solid #fff;
}

.daterangepicker.dropdown-menu {
  max-width: none;
  z-index: 3000;
}

.daterangepicker .ranges, .daterangepicker .calendar {
  float: left;
}

.daterangepicker.single .ranges, .daterangepicker.single .calendar {
  float: none;
}

.daterangepicker .ranges {
  margin: 4px;
  text-align: left;
}

.daterangepicker .calendar {
  display: none;
  max-width: 270px;
}

.daterangepicker.show-calendar .calendar {
  display: block;
}

.daterangepicker .calendar.single .calendar-table {
  border: none;
}

/* Calendars */

.daterangepicker .calendar th, .daterangepicker .calendar td {
  white-space: nowrap;
  text-align: center;
  min-width: 32px;
}

.daterangepicker .calendar-table {
  border: 1px solid #ddd;
  padding: 4px;
  border-radius: 4px;
  background: #fff;
}

.daterangepicker .calendar.left .calendar-table {
  border-right: none;
  border-top-right-radius: 0;
  border-bottom-right-radius: 0;
}

.daterangepicker .calendar.right .calendar-table {
  border-left: none;
  border-top-left-radius: 0;
  border-bottom-left-radius: 0;
}

.daterangepicker .calendar.left {
  margin: 4px 0 4px 4px;
}

.daterangepicker .calendar.right {
  margin: 4px 4px 4px 0;
}

.daterangepicker .calendar.left .calendar-table {
  padding-right: 12px;
}

.daterangepicker table {
  width: 100%;
  margin: 0;
}

.daterangepicker td, .daterangepicker th {
  text-align: center;
  width: 20px;
  height: 20px;
  border-radius: 4px;
  white-space: nowrap;
  cursor: pointer;
}

.daterangepicker td.off, .daterangepicker td.off.in-range, .daterangepicker td.off.start-date, .daterangepicker td.off.end-date {
  color: #999;
  background: #fff;
}

.daterangepicker td.disabled, .daterangepicker option.disabled {
  color: #999;
}

.daterangepicker td.available:hover, .daterangepicker th.available:hover {
  background: #eee;
}

.daterangepicker td.in-range {
  background: #ebf4f8;
  border-radius: 0;
}

.daterangepicker td.start-date {
  border-radius: 4px 0 0 4px;
}

.daterangepicker td.end-date {
  border-radius: 0 4px 4px 0;
}

.daterangepicker td.start-date.end-date {
  border-radius: 4px;
}

.daterangepicker td.active, .daterangepicker td.active:hover {
  background-color: #357ebd;
  border-color: #3071a9;
  color: #fff;
}

.daterangepicker td.week, .daterangepicker th.week {
  font-size: 80%;
  color: #ccc;
}

.daterangepicker select.monthselect, .daterangepicker select.yearselect {
  font-size: 12px;
  padding: 1px;
  height: auto;
  margin: 0;
  cursor: default;
}

.daterangepicker select.monthselect {
  margin-right: 2%;
  width: 56%;
}

.daterangepicker select.yearselect {
  width: 40%;
}

.daterangepicker select.hourselect, .daterangepicker select.minuteselect, .daterangepicker select.secondselect, .daterangepicker select.ampmselect {
  width: 50px;
  margin-bottom: 0;
}

.daterangepicker th.month {
  width: auto;
}

/* Text Input Above Each Calendar */

.daterangepicker .input-mini {
  border: 1px solid #ccc;
  border-radius: 4px;
  color: #555;
  display: block;
  height: 30px;
  line-height: 30px;
  vertical-align: middle;
  margin: 0 0 5px 0;
  padding: 0 6px 0 28px;
  width: 100%;
}

.daterangepicker .daterangepicker_input i {
  position: absolute;
  left: 8px;
  top: 8px;
}

.daterangepicker .left .daterangepicker_input {
  padding-right: 12px;
}

.daterangepicker .daterangepicker_input {
  position: relative;
}

/* Time Picker */

.daterangepicker .calendar-time {
  text-align: center;
  margin: 5px auto;
  line-height: 30px;
  position: relative;
  padding-left: 28px;
}

.daterangepicker .calendar-time select.disabled {
  color: #ccc;
  cursor: not-allowed;
}

/* Predefined Ranges */

.daterangepicker .ranges {
  font-size: 11px;
}

.daterangepicker .ranges ul {
  list-style: none;
  margin: 0;
  padding: 0;
  width: 160px;
}

.daterangepicker .ranges li {
  font-size: 13px;
  background: #f5f5f5;
  border: 1px solid #f5f5f5;
  color: #08c;
  padding: 3px 12px;
  margin-bottom: 8px;
  border-radius: 5px;
  cursor: pointer;
}

.daterangepicker .ranges li.active, .daterangepicker .ranges li:hover {
  background: #08c;
  border: 1px solid #08c;
  color: #fff;
}


text:
class AddActionToEvents < ActiveRecord::Migration
  def change
    add_column :events, :action, :string
  end
end


text:
import { NgModule } from '@angular/core';
import { ArtemisSharedModule } from 'app/shared/shared.module';
import { ProgrammingExerciseInstructorStatusComponent } from 'app/exercises/programming/manage/status/programming-exercise-instructor-status.component';
import { ProgrammingExerciseInstructorExerciseStatusComponent } from 'app/exercises/programming/manage/status/programming-exercise-instructor-exercise-status.component';

@NgModule({
    imports: [ArtemisSharedModule],
    declarations: [ProgrammingExerciseInstructorStatusComponent, ProgrammingExerciseInstructorExerciseStatusComponent],
    exports: [ProgrammingExerciseInstructorStatusComponent, ProgrammingExerciseInstructorExerciseStatusComponent],
})
export class ArtemisProgrammingExerciseStatusModule {}


text:
class CreateCores < ActiveRecord::Migration
  def change
    create_table :cores do |t|
      t.text :twitter
	  t.text :github
	  t.text :email
	  t.boolean :show_icons
	  t.boolean :show_login
      t.timestamps null: false
    end
  end
end


text:
<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<style type="text/css">
			.loginBox {
				border: 1px solid black;
				box-sizing: border-box;
				width: 400px;
				margin-left: auto;
				margin-right: auto;
				padding: 1em 10px;
				text-align: center;
				font-size: 1.5em;
			}

			input {
				box-sizing: border-box;
			}

			.id, .pw, .loginBtn, .googleLogin {
				width: 380px;
				font-size: 1em;
				margin-top: 10px;
			}

			.loginBtn {
				margin-bottom: 10px;
			}

		</style>

	</head>
	<body>
		<div class='loginBox'>
			Enter your ID and password
			<input class="id" type="text" placeholder="ID">
			<input class="pw" type="text" placeholder="Password">
			<button class="loginBtn">Click to sign in</button>
			Or
			<button class="googleLogin">Sign in with Google</button>
		</div>

		<script type="text/javascript">

//login with google account

		window.onload = ()=>{
			if(window.location.hash !== ""){
				let loginInfo = window.location.hash.slice(1);
				console.log("********************** google login info **************************");
				console.log(loginInfo);

				let loginReq = new XMLHttpRequest();

				loginReq.onload = ()=>{
					if(loginReq.status === 200){
						window.location.replace(loginReq.responseURL);
					}else{
						throw new Error("req.status is not 200 \n"+req);
					}
				}

				loginReq.open('POST', '/loginWithGoogle');
				loginReq.setRequestHeader('content-type', 'application/x-www-form-urlencoded');
				loginReq.send(loginInfo);
			}
		}

		document.querySelector('.googleLogin').addEventListener('click', ()=>{
			let endpoint = "https://accounts.google.com/o/oauth2/v2/auth?"
				+"response_type=token"
				+"&client_id=660527717768-3od23s46fpgd339laq3rsdpef0bb9bnc.apps.googleusercontent.com"
				+"&redirect_uri=http://localhost:8080"
				+"&scope=profile%20email"
				// +"&prompt=consent",
				+"&state=login";
			window.location.replace(endpoint);
		});

// login with id

		document.querySelector('.loginBtn').addEventListener('click', function(){
			console.log("login button clicked");
			console.log("id is "+document.querySelector(".id").value);
			console.log("pw is "+document.querySelector(".pw").value);
			var req = new XMLHttpRequest();

			req.onreadystatechange = function(){
				if(req.readyState === XMLHttpRequest.DONE){

					if(req.status === 200){
						console.log(req.responseURL);
						window.location.replace(req.responseURL);
					}else{
						alert(req.response);
						console.log("req status is not 200");
					}
				}
			};

			var inputId = document.querySelector(".id").value,
				inputPw = document.querySelector(".pw").value;

			var sendInfo = {
				id:inputId,
				pw:inputPw
			}

			// console.log(sendInfo);

			var url = "http://localhost:8080/loginClicked?random="+Math.floor(Math.random()*10000);

			req.open('POST', url);
			req.setRequestHeader('Content-type', 'application/json;charset=utf-8');
			req.send(JSON.stringify(sendInfo));
		})
		</script>
	</body>
</html>


text:
layout: post
title: "Male Steeder"
date: 2017-09-10
tags: [medium, beast, cr1/4, out-of-the-abyss]
---

**Medium beast, unaligned**

**Armor Class** 12 (natural armor)

**Hit Points** 13 (2d8+4)

**Speed** 30 ft., climb 30 ft.

|   STR   |   DEX   |   CON   |   INT   |   WIS   |   CHA   |
|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|
| 15 (+2) | 12 (+1) | 14 (+2) | 2 (-4) | 10 (0) | 3 (-4) |

**Skills** Stealth +5

**Senses** darkvision 120 ft.

**Languages** -

**Challenge** 1/4 (50 XP)

***Spider Climb.*** The steeder can climb difficult surfaces, including upside down on ceilings, without needing to make an ability check.

***Leap.*** The steeder can expend all its movement on its turn to jump up to 60 feet vertically or horizontally, provided that is speed is at least 30 feet.

**Actions**

***Bite.*** Melee Weapon Attack: +4 to hit, reach 5 ft., one creature. Hit: 7 (1d8 + 2) piercing damage, and the target must make a DC 12 Constitution saving throw, taking 4 (1d8) acid damage on a failed save, or half as much damage on a successful one.

***Sticky Leg (Recharges when the Steeder Has No Creatures Grappled.*** Melee Weapon Attack: +4 to hit, reach 5 ft., one Small or Tiny creature. Hit: The target is stuck ot the steeder's leg and grappled until it escapes (escape DC 12)


text:
describe('template', () => {
  const el = document.createElement('div');
  el.id = 'test-div-id';
  el.innerHTML = 'hello g6';
  document.querySelector('body').appendChild(el);

  it('div content', () => {
    expect(document.querySelector('#test-div-id').innerHTML).toBe('hello g6');
  });
});


text:
.. _upgrading.3-to-4:

==============
Version 3 to 4
==============

I've made great efforts to ensure that the upgrade experience for most will be
seamless and uneventful. However, no matter the degree to which you use
ramsey/uuid (customized or unchanged), there are a number of things to be aware
of as you upgrade your code to use version 4.

.. tip::

    These are the changes that are most likely to affect you. For a full list of
    changes, take a look at the `4.0.0 changelog`_.

.. _upgrading.3-to-4.new:

What's New?
###########

There are a lot of new features in ramsey/uuid! Here are a few of them:

* Support :ref:`version 6 UUIDs <nonstandard.version6>`.
* Support :ref:`version 2 (DCE Security) UUIDs <rfc4122.version2>`.
* Add classes to represent each version of RFC 4122 UUID. When generating new
  UUIDs or creating UUIDs from existing strings, bytes, or integers, if the UUID
  is an RFC 4122 variant, one of these instances will be returned:

  * :php:class:`Rfc4122\\UuidV1 <Ramsey\\Uuid\\Rfc4122\\UuidV1>`
  * :php:class:`Rfc4122\\UuidV2 <Ramsey\\Uuid\\Rfc4122\\UuidV2>`
  * :php:class:`Rfc4122\\UuidV3 <Ramsey\\Uuid\\Rfc4122\\UuidV3>`
  * :php:class:`Rfc4122\\UuidV4 <Ramsey\\Uuid\\Rfc4122\\UuidV4>`
  * :php:class:`Rfc4122\\UuidV5 <Ramsey\\Uuid\\Rfc4122\\UuidV5>`
  * :php:class:`Rfc4122\\NilUuid <Ramsey\\Uuid\\Rfc4122\\NilUuid>`

* Add classes to represent version 6 UUIDs, GUIDs, and nonstandard
  (non-RFC 4122 variants) UUIDs:

  * :php:class:`Nonstandard\\UuidV6 <Ramsey\\Uuid\\Nonstandard\\UuidV6>`
  * :php:class:`Nonstandard\\Uuid <Ramsey\\Uuid\\Nonstandard\\Uuid>`
  * :php:class:`Guid\\Guid <Ramsey\\Uuid\\Guid\\Guid>`

* Add :php:meth:`Uuid::fromDateTime() <Ramsey\\Uuid\\Uuid::fromDateTime>` to
  create version 1 UUIDs from instances of DateTimeInterface.

.. _upgrading.3-to-4.changed:

What's Changed?
###############

.. attention::

    ramsey/uuid version 4 requires PHP 7.2 or later.

Quite a bit has changed, but much remains familiar. Unless you've changed the
behavior of ramsey/uuid through custom codecs, providers, generators, etc., the
standard functionality and API found in version 3 will not differ much.

.. rubric:: Here are the highlights:

* ramsey/uuid now works on 32-bit and 64-bit systems, with no degradation in
  functionality! All Degraded\* classes are deprecated and no longer used;
  they'll go away in ramsey/uuid version 5.
* Pay attention to the :ref:`return types for the static methods
  <upgrading.3-to-4.static-methods>` on the :php:class:`Uuid <Ramsey\\Uuid\\Uuid>`
  class. They've changed slightly, but this won't affect you if your type hints
  use :php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`.
* The :ref:`return types for three methods <upgrading.3-to-4.return-types>`
  defined on :php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>` have
  changed, breaking backwards compatibility. **Take note and update your code.**
* :ref:`There are a number of deprecations. <upgrading.3-to-4.deprecations>`
  These shouldn't affect you now, but please take a look at the recommendations
  and update your code soon. These will go away in ramsey/uuid version 5.
* ramsey/uuid now :ref:`throws custom exceptions for everything
  <reference.exceptions>`. The exception UnsatisfiedDependencyException no
  longer exists.
* If you customize ramsey/uuid at all by implementing the interfaces, take a
  look at the :ref:`interface <upgrading.3-to-4.interfaces>` and
  :ref:`constructor <upgrading.3-to-4.constructors>` changes and update your
  code.

.. tip::

    If you maintain a public project that uses ramsey/uuid version 3 and you
    find that **your code does not require any changes to upgrade** to version
    4, consider using the following version constraint in your project's
    ``composer.json`` file:

    .. code-block:: bash

        composer require ramsey/uuid:"^3 || ^4"

    This will allow any `downstream users`_ of your project who aren't ready to
    upgrade to version 4 the ability to continue using your project while
    deciding on an appropriate upgrade schedule.

    If your downstream users do not specify ramsey/uuid as a dependency, and
    they use functionality specific to version 3, they may need to update their
    own Composer dependencies to use ramsey/uuid ``^3`` to avoid using version 4.

.. _upgrading.3-to-4.static-methods:

Uuid Static Methods
###################

All the static methods on the :php:class:`Uuid <Ramsey\\Uuid\\Uuid>` class
continue to work as they did in version 3, with this slight change: **they now
return more-specific types**, all of which implement the new interface
:php:interface:`Rfc4122\\UuidInterface <Ramsey\\Uuid\\Rfc4122\\UuidInterface>`,
which implements the familiar interface :php:interface:`UuidInterface
<Ramsey\\Uuid\\UuidInterface>`.

If your type hints are for :php:interface:`UuidInterface
<Ramsey\\Uuid\\UuidInterface>`, then you should not require any changes.

.. list-table:: Return types for Uuid static methods
    :align: center
    :header-rows: 1

    * - Method
      - 3.x Returned
      - 4.x Returns
    * - :php:meth:`Uuid::uuid1() <Ramsey\\Uuid\\Uuid::uuid1>`
      - :php:class:`Uuid <Ramsey\\Uuid\\Uuid>`
      - :php:class:`Rfc4122\\UuidV1 <Ramsey\\Uuid\\Rfc4122\\UuidV1>`
    * - :php:meth:`Uuid::uuid3() <Ramsey\\Uuid\\Uuid::uuid3>`
      - :php:class:`Uuid <Ramsey\\Uuid\\Uuid>`
      - :php:class:`Rfc4122\\UuidV3 <Ramsey\\Uuid\\Rfc4122\\UuidV3>`
    * - :php:meth:`Uuid::uuid4() <Ramsey\\Uuid\\Uuid::uuid4>`
      - :php:class:`Uuid <Ramsey\\Uuid\\Uuid>`
      - :php:class:`Rfc4122\\UuidV4 <Ramsey\\Uuid\\Rfc4122\\UuidV4>`
    * - :php:meth:`Uuid::uuid5() <Ramsey\\Uuid\\Uuid::uuid5>`
      - :php:class:`Uuid <Ramsey\\Uuid\\Uuid>`
      - :php:class:`Rfc4122\\UuidV5 <Ramsey\\Uuid\\Rfc4122\\UuidV5>`

:php:meth:`Uuid::fromString() <Ramsey\\Uuid\\Uuid::fromString>`,
:php:meth:`Uuid::fromBytes() <Ramsey\\Uuid\\Uuid::fromBytes>`, and
:php:meth:`Uuid::fromInteger() <Ramsey\\Uuid\\Uuid::fromInteger>` all return
an appropriate more-specific type, based on the input value. If the input value
is a version 1 UUID, for example, the return type will be an
:php:class:`Rfc4122\\UuidV1 <Ramsey\\Uuid\\Rfc4122\\UuidV1>`. If the input looks
like a UUID or is a 128-bit number, but it doesn't validate as an RFC 4122 UUID,
the return type will be a :php:class:`Nonstandard\\Uuid
<Ramsey\\Uuid\\Nonstandard\\Uuid>`. These return types implement
:php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`. If using this as
a type hint, you shouldn't need to make any changes.

.. _upgrading.3-to-4.return-types:

Changed Return Types
####################

The following :php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`
method return types have changed in version 4 and you will need to update your
code, if you use these methods.

.. list-table:: Changed UuidInterface method return types
    :widths: 40 30 30
    :align: center
    :header-rows: 1

    * - Method
      - 3.x Returned
      - 4.x Returns
    * - :php:meth:`UuidInterface::getFields() <Ramsey\\Uuid\\UuidInterface::getFields>`
      - ``array``
      - :php:class:`Rfc4122\\FieldsInterface <Ramsey\\Uuid\\Rfc4122\\FieldsInterface>`
    * - :php:meth:`UuidInterface::getHex() <Ramsey\\Uuid\\UuidInterface::getHex>`
      - ``string``
      - :php:class:`Type\\Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`
    * - :php:meth:`UuidInterface::getInteger() <Ramsey\\Uuid\\UuidInterface::getInteger>`
      - ``mixed`` [#f1]_
      - :php:class:`Type\\Integer <Ramsey\\Uuid\\Type\\Integer>`

In version 3, the following :php:class:`Uuid <Ramsey\\Uuid\\Uuid>` methods
return ``int``, ``string``, or Moontoast\\Math\\BigNumber, depending on the
environment. In version 4, they all return numeric ``string`` values for the
sake of consistency. These methods :ref:`are also deprecated
<upgrading.3-to-4.deprecations.uuid>` and will be removed in version 5.

* ``getClockSeqHiAndReserved()``
* ``getClockSeqLow()``
* ``getClockSequence()``
* ``getLeastSignificantBits()``
* ``getMostSignificantBits()``
* ``getNode()``
* ``getTimeHiAndVersion()``
* ``getTimeLow()``
* ``getTimeMid()``
* ``getTimestamp()``

.. _upgrading.3-to-4.deprecations:

Deprecations
############

.. _upgrading.3-to-4.deprecations.uuidinterface:

UuidInterface
-------------

The following :php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`
methods are deprecated, but upgrading to version 4 should not cause any problems
if using these methods. You are encouraged to update your code according to the
recommendations, though, since these methods will go away in version 5.

.. list-table:: Deprecated UuidInterface methods
    :widths: 30 70
    :align: center
    :header-rows: 1

    * - Deprecated Method
      - Update To
    * - ``getDateTime()``
      - Use ``getDateTime()`` on :php:meth:`UuidV1
        <Ramsey\\Uuid\\Rfc4122\\UuidV1::getDateTime>`, :php:meth:`UuidV2
        <Ramsey\\Uuid\\Rfc4122\\UuidV2::getDateTime>`, or :php:meth:`UuidV6
        <Ramsey\\Uuid\\Nonstandard\\UuidV6::getDateTime>`
    * - ``getClockSeqHiAndReservedHex()``
      - :php:meth:`getFields()->getClockSeqHiAndReserved()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getClockSeqHiAndReserved>`
    * - ``getClockSeqLowHex()``
      - :php:meth:`getFields()->getClockSeqLow()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getClockSeqLow>`
    * - ``getClockSequenceHex()``
      - :php:meth:`getFields()->getClockSeq()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getClockSeq>`
    * - ``getFieldsHex()``
      - :php:meth:`getFields() <Ramsey\\Uuid\\Rfc4122\\UuidInterface::getFields>` [#f2]_
    * - ``getLeastSignificantBitsHex()``
      - ``substr($uuid->getHex()->toString(), 0, 16)``
    * - ``getMostSignificantBitsHex()``
      - ``substr($uuid->getHex()->toString(), 16)``
    * - ``getNodeHex()``
      - :php:meth:`getFields()->getNode()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getNode>`
    * - ``getNumberConverter()``
      - This method has no replacement; plan accordingly.
    * - ``getTimeHiAndVersionHex()``
      - :php:meth:`getFields()->getTimeHiAndVersion()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getTimeHiAndVersion>`
    * - ``getTimeLowHex()``
      - :php:meth:`getFields()->getTimeLow()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getTimeLow>`
    * - ``getTimeMidHex()``
      - :php:meth:`getFields()->getTimeMid()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getTimeMid>`
    * - ``getTimestampHex()``
      - :php:meth:`getFields()->getTimestamp()->toString() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getTimestamp>`
    * - ``getUrn()``
      - :php:meth:`Ramsey\\Uuid\\Rfc4122\\UuidInterface::getUrn`
    * - ``getVariant()``
      - :php:meth:`getFields()->getVariant() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getVariant>`
    * - ``getVersion()``
      - :php:meth:`getFields()->getVersion() <Ramsey\\Uuid\\Rfc4122\\FieldsInterface::getVersion>`

.. _upgrading.3-to-4.deprecations.uuid:

Uuid
----

:php:class:`Uuid <Ramsey\\Uuid\\Uuid>` as an instantiable class is deprecated.
In ramsey/uuid version 5, its constructor will be ``private``, and the class
will be ``final``. For more information, see :ref:`faq.final`

.. note::

    :php:class:`Uuid <Ramsey\\Uuid\\Uuid>` is being replaced by more-specific
    concrete classes, such as:

    * :php:class:`Rfc4122\\UuidV1 <Ramsey\\Uuid\\Rfc4122\\UuidV1>`
    * :php:class:`Rfc4122\\UuidV3 <Ramsey\\Uuid\\Rfc4122\\UuidV3>`
    * :php:class:`Rfc4122\\UuidV4 <Ramsey\\Uuid\\Rfc4122\\UuidV4>`
    * :php:class:`Rfc4122\\UuidV5 <Ramsey\\Uuid\\Rfc4122\\UuidV5>`
    * :php:class:`Nonstandard\\Uuid <Ramsey\\Uuid\\Nonstandard\\Uuid>`

    However, the :php:class:`Uuid <Ramsey\\Uuid\\Uuid>` class isn't going away.
    It will still hold common constants and static methods.

* ``Uuid::UUID_TYPE_IDENTIFIER`` is deprecated. Use
  ``Uuid::UUID_TYPE_DCE_SECURITY`` instead.
* ``Uuid::VALID_PATTERN`` is deprecated. Use the following instead:

    .. code-block:: php

        use Ramsey\Uuid\Validator\GenericValidator;
        use Ramsey\Uuid\Rfc4122\Validator as Rfc4122Validator;

        $genericPattern = (new GenericValidator())->getPattern();
        $rfc4122Pattern = (new Rfc4122Validator())->getPattern();

The following :php:class:`Uuid <Ramsey\\Uuid\\Uuid>` methods are deprecated. If
using these methods, you shouldn't have any problems on version 4, but you are
encouraged to update your code, since they will go away in version 5.

* ``getClockSeqHiAndReserved()``
* ``getClockSeqLow()``
* ``getClockSequence()``
* ``getLeastSignificantBits()``
* ``getMostSignificantBits()``
* ``getNode()``
* ``getTimeHiAndVersion()``
* ``getTimeLow()``
* ``getTimeMid()``
* ``getTimestamp()``

.. hint::

    There are no direct replacements for these methods. In ramsey/uuid version
    3, they returned ``int`` or Moontoast\\Math\\BigNumber values, depending
    on the environment. To update your code, you should use the recommended
    alternates listed in :ref:`Deprecations: UuidInterface
    <upgrading.3-to-4.deprecations.uuidinterface>`, combined with the
    arbitrary-precision mathematics library of your choice (e.g., `brick/math`_,
    `gmp`_, `bcmath`_, etc.).

    .. code-block:: php
        :caption: Using brick/math to convert a node to a string integer

        use Brick\Math\BigInteger;

        $node = BigInteger::fromBase($uuid->getFields()->getNode()->toString(), 16);

.. _upgrading.3-to-4.interfaces:

Interface Changes
#################

For those who customize ramsey/uuid by implementing the interfaces provided,
there are a few breaking changes to note.

.. hint::

    Most existing methods on interfaces have type hints added to them. If you
    implement any interfaces, please be aware of this and update your classes.

UuidInterface
-------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - :php:meth:`__toString() <Ramsey\\Uuid\\UuidInterface::__toString>`
      - New method; returns ``string``
    * - :php:meth:`getDateTime() <Ramsey\\Uuid\\UuidInterface::getDateTime>`
      - Deprecated; now returns `DateTimeInterface`_
    * - :php:meth:`getFields() <Ramsey\\Uuid\\UuidInterface::getFields>`
      - Used to return ``array``; now returns :php:class:`Rfc4122\\FieldsInterface <Ramsey\\Uuid\\Rfc4122\\FieldsInterface>`
    * - :php:meth:`getHex() <Ramsey\\Uuid\\UuidInterface::getHex>`
      - Used to return ``string``; now returns :php:class:`Type\\Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`
    * - :php:meth:`getInteger() <Ramsey\\Uuid\\UuidInterface::getInteger>`
      - New method; returns :php:class:`Type\\Integer <Ramsey\\Uuid\\Type\\Integer>`

UuidFactoryInterface
--------------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - :php:meth:`uuid2() <Ramsey\\Uuid\\UuidFactoryInterface::uuid2>`
      - New method; returns :php:class:`Rfc4122\\UuidV2 <Ramsey\\Uuid\\Rfc4122\\UuidV2>`
    * - :php:meth:`uuid6() <Ramsey\\Uuid\\UuidFactoryInterface::uuid6>`
      - New method; returns :php:class:`Nonstandard\\UuidV6 <Ramsey\\Uuid\\Nonstandard\\UuidV6>`
    * - :php:meth:`fromDateTime() <Ramsey\\Uuid\\UuidFactoryInterface::fromDateTime>`
      - New method; returns :php:class:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`
    * - :php:meth:`fromInteger() <Ramsey\\Uuid\\UuidFactoryInterface::fromInteger>`
      - Changed to accept only strings
    * - :php:meth:`getValidator() <Ramsey\\Uuid\\UuidFactoryInterface::getValidator>`
      - New method; returns :php:class:`UuidInterface <Ramsey\\Uuid\\Validator\\ValidatorInterface>`

Builder\\UuidBuilderInterface
-----------------------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - ``build()``
      - The second parameter used to accept ``array $fields``; now accepts ``string $bytes``

Converter\\TimeConverterInterface
---------------------------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - ``calculateTime()``
      - Used to return ``string[]``; now returns :php:class:`Type\\Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`
    * - ``convertTime()``
      - New method; returns :php:class:`Type\\Time <Ramsey\\Uuid\\Type\\Time>`

Provider\\TimeProviderInterface
---------------------------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - ``currentTime()``
      - Method removed from interface; use ``getTime()`` instead
    * - ``getTime()``
      - New method; returns :php:class:`Type\\Time <Ramsey\\Uuid\\Type\\Time>`

Provider\\NodeProviderInterface
---------------------------------

.. list-table::
    :widths: 25 75
    :align: center
    :header-rows: 1

    * - Method
      - Description
    * - ``getNode()``
      - Used to return ``string|false|null``; now returns :php:class:`Type\\Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`

.. _upgrading.3-to-4.constructors:

Constructor Changes
###################

There are a handful of constructor changes that might affect your use of
ramsey/uuid, especially if you customize the library.

Uuid
----

The constructor for :php:class:`Ramsey\\Uuid\\Uuid` is deprecated. However,
there are a few changes to it that might affect your use of this class.

The first constructor parameter used to be ``array $fields`` and is now
:php:interface:`Rfc4122\\FieldsInterface $fields
<Ramsey\\Uuid\\Rfc4122\\FieldsInterface>`.

``Converter\TimeConverterInterface $timeConverter`` is required as a new fourth
parameter.

Builder\\DefaultUuidBuilder
---------------------------

While Builder\\DefaultUuidBuilder is deprecated, it now inherits from
Rfc4122\\UuidBuilder, which requires ``Converter\TimeConverterInterface
$timeConverter`` as its second constructor argument.

Provider\\Node\\FallbackNodeProvider
------------------------------------

Provider\\Node\\FallbackNodeProvider now requires
``iterable<Ramsey\Uuid\Provider\NodeProviderInterface>`` as its constructor
parameter.

.. code-block::

    use MyPackage\MyCustomNodeProvider;
    use Ramsey\Uuid\Provider\Node\FallbackNodeProvider;
    use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
    use Ramsey\Uuid\Provider\Node\SystemNodeProvider;

    $nodeProviders = [];
    $nodeProviders[] = new MyCustomNodeProvider();
    $nodeProviders[] = new SystemNodeProvider();
    $nodeProviders[] = new RandomNodeProvider();

    $provider = new FallbackNodeProvider($nodeProviders);

Provider\\Time\\FixedTimeProvider
---------------------------------

The constructor for Provider\\Time\\FixedTimeProvider no longer accepts an
array. It accepts :php:class:`Type\\Time <Ramsey\\Uuid\\Type\\Time>` instances.

-------------------------------------------------------------------------------

.. rubric:: Footnotes

.. [#f1] This ``mixed`` return type could have been an ``int``, ``string``, or
    Moontoast\\Math\\BigNumber. In version 4, ramsey/uuid cleans this up for
    the sake of consistency.

.. [#f2] The :php:meth:`getFields() <Ramsey\\Uuid\\Rfc4122\\UuidInterface::getFields>`
    method returns a :php:class:`Type\\Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`
    instance; you will need to construct an array if you wish to match the
    return value of the deprecated ``getFieldsHex()`` method.

.. _downstream users: https://en.wikipedia.org/wiki/Downstream_(software_development)
.. _version 6 UUIDs: http://gh.peabody.io/uuidv6/
.. _4.0.0 changelog: https://github.com/ramsey/uuid/releases/tag/4.0.0
.. _brick/math: https://github.com/brick/math
.. _gmp: https://www.php.net/gmp
.. _bcmath: https://www.php.net/bcmath
.. _DateTimeInterface: https://www.php.net/datetimeinterface


text:
package libvirt

/*
#cgo pkg-config: libvirt
#include <stdlib.h>
#include "domain_snapshot_wrapper.h"
*/
import "C"

import (
	"reflect"
	"unsafe"
)

type DomainSnapshotCreateFlags int

const (
	DOMAIN_SNAPSHOT_CREATE_REDEFINE    = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE)
	DOMAIN_SNAPSHOT_CREATE_CURRENT     = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT)
	DOMAIN_SNAPSHOT_CREATE_NO_METADATA = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)
	DOMAIN_SNAPSHOT_CREATE_HALT        = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_HALT)
	DOMAIN_SNAPSHOT_CREATE_DISK_ONLY   = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY)
	DOMAIN_SNAPSHOT_CREATE_REUSE_EXT   = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT)
	DOMAIN_SNAPSHOT_CREATE_QUIESCE     = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE)
	DOMAIN_SNAPSHOT_CREATE_ATOMIC      = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC)
	DOMAIN_SNAPSHOT_CREATE_LIVE        = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_LIVE)
	DOMAIN_SNAPSHOT_CREATE_VALIDATE    = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE)
)

type DomainSnapshotListFlags int

const (
	DOMAIN_SNAPSHOT_LIST_ROOTS       = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_ROOTS)
	DOMAIN_SNAPSHOT_LIST_DESCENDANTS = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS)
	DOMAIN_SNAPSHOT_LIST_LEAVES      = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_LEAVES)
	DOMAIN_SNAPSHOT_LIST_NO_LEAVES   = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES)
	DOMAIN_SNAPSHOT_LIST_METADATA    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_METADATA)
	DOMAIN_SNAPSHOT_LIST_NO_METADATA = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA)
	DOMAIN_SNAPSHOT_LIST_INACTIVE    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE)
	DOMAIN_SNAPSHOT_LIST_ACTIVE      = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE)
	DOMAIN_SNAPSHOT_LIST_DISK_ONLY   = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY)
	DOMAIN_SNAPSHOT_LIST_INTERNAL    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL)
	DOMAIN_SNAPSHOT_LIST_EXTERNAL    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL)
	DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL)
)

type DomainSnapshotRevertFlags int

const (
	DOMAIN_SNAPSHOT_REVERT_RUNNING = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING)
	DOMAIN_SNAPSHOT_REVERT_PAUSED  = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)
	DOMAIN_SNAPSHOT_REVERT_FORCE   = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)
)

type DomainSnapshotDeleteFlags int

const (
	DOMAIN_SNAPSHOT_DELETE_CHILDREN      = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN)
	DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY)
	DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY)
)

type DomainSnapshotXMLFlags int

const (
	DOMAIN_SNAPSHOT_XML_SECURE = DomainSnapshotXMLFlags(C.VIR_DOMAIN_SNAPSHOT_XML_SECURE)
)

type DomainSnapshot struct {
	ptr C.virDomainSnapshotPtr
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotFree
func (s *DomainSnapshot) Free() error {
	var err C.virError
	ret := C.virDomainSnapshotFreeWrapper(s.ptr, &err)
	if ret == -1 {
		return makeError(&err)
	}
	return nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotRef
func (c *DomainSnapshot) Ref() error {
	var err C.virError
	ret := C.virDomainSnapshotRefWrapper(c.ptr, &err)
	if ret == -1 {
		return makeError(&err)
	}
	return nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotDelete
func (s *DomainSnapshot) Delete(flags DomainSnapshotDeleteFlags) error {
	var err C.virError
	result := C.virDomainSnapshotDeleteWrapper(s.ptr, C.uint(flags), &err)
	if result != 0 {
		return makeError(&err)
	}
	return nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainRevertToSnapshot
func (s *DomainSnapshot) RevertToSnapshot(flags DomainSnapshotRevertFlags) error {
	var err C.virError
	result := C.virDomainRevertToSnapshotWrapper(s.ptr, C.uint(flags), &err)
	if result != 0 {
		return makeError(&err)
	}
	return nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotIsCurrent
func (s *DomainSnapshot) IsCurrent(flags uint32) (bool, error) {
	var err C.virError
	result := C.virDomainSnapshotIsCurrentWrapper(s.ptr, C.uint(flags), &err)
	if result == -1 {
		return false, makeError(&err)
	}
	if result == 1 {
		return true, nil
	}
	return false, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotHasMetadata
func (s *DomainSnapshot) HasMetadata(flags uint32) (bool, error) {
	var err C.virError
	result := C.virDomainSnapshotHasMetadataWrapper(s.ptr, C.uint(flags), &err)
	if result == -1 {
		return false, makeError(&err)
	}
	if result == 1 {
		return true, nil
	}
	return false, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetXMLDesc
func (s *DomainSnapshot) GetXMLDesc(flags DomainSnapshotXMLFlags) (string, error) {
	var err C.virError
	result := C.virDomainSnapshotGetXMLDescWrapper(s.ptr, C.uint(flags), &err)
	if result == nil {
		return "", makeError(&err)
	}
	xml := C.GoString(result)
	C.free(unsafe.Pointer(result))
	return xml, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetName
func (s *DomainSnapshot) GetName() (string, error) {
	var err C.virError
	name := C.virDomainSnapshotGetNameWrapper(s.ptr, &err)
	if name == nil {
		return "", makeError(&err)
	}
	return C.GoString(name), nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetParent
func (s *DomainSnapshot) GetParent(flags uint32) (*DomainSnapshot, error) {
	var err C.virError
	ptr := C.virDomainSnapshotGetParentWrapper(s.ptr, C.uint(flags), &err)
	if ptr == nil {
		return nil, makeError(&err)
	}
	return &DomainSnapshot{ptr: ptr}, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotNumChildren
func (s *DomainSnapshot) NumChildren(flags DomainSnapshotListFlags) (int, error) {
	var err C.virError
	result := int(C.virDomainSnapshotNumChildrenWrapper(s.ptr, C.uint(flags), &err))
	if result == -1 {
		return 0, makeError(&err)
	}
	return result, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListChildrenNames
func (s *DomainSnapshot) ListChildrenNames(flags DomainSnapshotListFlags) ([]string, error) {
	const maxNames = 1024
	var names [maxNames](*C.char)
	namesPtr := unsafe.Pointer(&names)
	var err C.virError
	numNames := C.virDomainSnapshotListChildrenNamesWrapper(
		s.ptr,
		(**C.char)(namesPtr),
		maxNames, C.uint(flags), &err)
	if numNames == -1 {
		return nil, makeError(&err)
	}
	goNames := make([]string, numNames)
	for k := 0; k < int(numNames); k++ {
		goNames[k] = C.GoString(names[k])
		C.free(unsafe.Pointer(names[k]))
	}
	return goNames, nil
}

// See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListAllChildren
func (d *DomainSnapshot) ListAllChildren(flags DomainSnapshotListFlags) ([]DomainSnapshot, error) {
	var cList *C.virDomainSnapshotPtr
	var err C.virError
	numVols := C.virDomainSnapshotListAllChildrenWrapper(d.ptr, (**C.virDomainSnapshotPtr)(&cList), C.uint(flags), &err)
	if numVols == -1 {
		return nil, makeError(&err)
	}
	hdr := reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(cList)),
		Len:  int(numVols),
		Cap:  int(numVols),
	}
	var pools []DomainSnapshot
	slice := *(*[]C.virDomainSnapshotPtr)(unsafe.Pointer(&hdr))
	for _, ptr := range slice {
		pools = append(pools, DomainSnapshot{ptr})
	}
	C.free(unsafe.Pointer(cList))
	return pools, nil
}


text:
/* jslint node:true, sloppy:true */

var fills = {};

fills.crypto = {
  getRandomValues: function (typedarray) {
    var buf = require('crypto').randomBytes(typedarray.length *
                                            typedarray.BYTES_PER_ELEMENT);
    var view = new DataView(typedarray.buffer);
    for (var i = 0; i < buf.length; i++) {
      view.setUint8(i, buf[i]);
    }
  }
};

module.exports = fills;


text:
package io.card.payment;

/* CreditCard.java
 * See the file "LICENSE.md" for the full license governing this code.
 */

import android.os.Parcel;
import android.os.Parcelable;

import java.util.UUID;

/**
 * Describes a credit card.
 *
 * @version 2.0
 */
public class CreditCard implements Parcelable {

    /**
     * Number of years into the future that a card expiration date is considered to be valid.
     */
    public static final int EXPIRY_MAX_FUTURE_YEARS = 15;

    private static final String TAG = CreditCard.class.getSimpleName();

    /**
     * 15 or 16 digit card number. All numbers, no spaces.
     */
    public String cardNumber;

    /**
     * Month in two digit natural form. {January=1, ..., December=12}
     */
    public int expiryMonth = 0;

    /**
     * Four digit year
     */
    public int expiryYear = 0;

    /**
     * Three or four character security code.
     */
    public String cvv;

    /**
     * Billing postal code for card.
     */
    public String postalCode;

    // these should NOT be public
    String scanId;
    boolean flipped = false;
    int yoff;
    int[] xoff;

    // constructors
    public CreditCard() {
        xoff = new int[16];
        scanId = UUID.randomUUID().toString();
    }

    public CreditCard(String number, int month, int year, String code, String postalCode) {
        this.cardNumber = number;
        this.expiryMonth = month;
        this.expiryYear = year;
        this.cvv = code;
        this.postalCode = postalCode;
    }

    // parcelable
    private CreditCard(Parcel src) {
        cardNumber = src.readString();
        expiryMonth = src.readInt();
        expiryYear = src.readInt();
        cvv = src.readString();
        postalCode = src.readString();
        scanId = src.readString();
        yoff = src.readInt();
        xoff = src.createIntArray();
    }

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

    @Override
    public final void writeToParcel(Parcel dest, int flags) {
        dest.writeString(cardNumber);
        dest.writeInt(expiryMonth);
        dest.writeInt(expiryYear);
        dest.writeString(cvv);
        dest.writeString(postalCode);
        dest.writeString(scanId);
        dest.writeInt(yoff);
        dest.writeIntArray(xoff);
    }

    public static final Parcelable.Creator<CreditCard> CREATOR = new Parcelable.Creator<CreditCard>() {

        @Override
        public CreditCard createFromParcel(Parcel source) {
            return new CreditCard(source);
        }

        @Override
        public CreditCard[] newArray(int size) {
            return new CreditCard[size];
        }
    };

    /**
     * @return The last four digits of the card number
     */
    public String getLastFourDigitsOfCardNumber() {
        if (cardNumber != null) {
            int available = Math.min(4, cardNumber.length());
            return cardNumber.substring(cardNumber.length() - available);
        } else {
            return "";
        }
    }

    /**
     * @return The card number string consisting of all but the last four digits replaced with
     * bullet ('\u2022').
     */
    public String getRedactedCardNumber() {
        if (cardNumber != null) {
            String redacted = "";
            if (cardNumber.length() > 4) {
                redacted += String.format("%" + (cardNumber.length() - 4) + "s", "").replace(' ',
                        '\u2022');
            }
            redacted += getLastFourDigitsOfCardNumber();
            return CreditCardNumber.formatString(redacted, false,
                    CardType.fromCardNumber(cardNumber));
        } else {
            return "";
        }
    }

    /**
     * @return The type of card, detected from the number
     */
    public CardType getCardType() {
        return CardType.fromCardNumber(cardNumber);
    }

    /**
     * @return A string suitable for display, with spaces inserted for readability.
     */
    public String getFormattedCardNumber() {
        return CreditCardNumber.formatString(cardNumber);
    }

    /**
     * @return true indicates a current, valid date.
     */
    public boolean isExpiryValid() {
        return CreditCardNumber.isDateValid(expiryMonth, expiryYear);
    }

    /**
     * @return a string suitable for writing to a log. Should not be displayed to the user.
     */
    @Override
    public String toString() {
        String s = "{" + getCardType() + ": " + getRedactedCardNumber();
        if (expiryMonth > 0 || expiryYear > 0) {
            s += "  expiry:" + expiryMonth + "/" + expiryYear;
        }
        if (postalCode != null) {
            s += "  postalCode:" + postalCode;
        }
        if (cvv != null) {
            s += "  cvvLength:" + ((cvv != null) ? cvv.length() : 0);
        }
        s += "}";
        return s;
    }
}


text:
namespace ArguMint.UnitTests.Dummies
{
   internal class DontCare
   {
      // An empty class to simplify unit testing where we don't care about the type parameter
   }
}