text:
#pragma once
#include <aws/workmail/WorkMail_EXPORTS.h>
#include <aws/workmail/WorkMailErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/workmail/model/AssociateDelegateToResourceResult.h>
#include <aws/workmail/model/AssociateMemberToGroupResult.h>
#include <aws/workmail/model/CreateAliasResult.h>
#include <aws/workmail/model/CreateGroupResult.h>
#include <aws/workmail/model/CreateResourceResult.h>
#include <aws/workmail/model/CreateUserResult.h>
#include <aws/workmail/model/DeleteAliasResult.h>
#include <aws/workmail/model/DeleteGroupResult.h>
#include <aws/workmail/model/DeleteMailboxPermissionsResult.h>
#include <aws/workmail/model/DeleteResourceResult.h>
#include <aws/workmail/model/DeleteUserResult.h>
#include <aws/workmail/model/DeregisterFromWorkMailResult.h>
#include <aws/workmail/model/DescribeGroupResult.h>
#include <aws/workmail/model/DescribeOrganizationResult.h>
#include <aws/workmail/model/DescribeResourceResult.h>
#include <aws/workmail/model/DescribeUserResult.h>
#include <aws/workmail/model/DisassociateDelegateFromResourceResult.h>
#include <aws/workmail/model/DisassociateMemberFromGroupResult.h>
#include <aws/workmail/model/ListAliasesResult.h>
#include <aws/workmail/model/ListGroupMembersResult.h>
#include <aws/workmail/model/ListGroupsResult.h>
#include <aws/workmail/model/ListMailboxPermissionsResult.h>
#include <aws/workmail/model/ListOrganizationsResult.h>
#include <aws/workmail/model/ListResourceDelegatesResult.h>
#include <aws/workmail/model/ListResourcesResult.h>
#include <aws/workmail/model/ListUsersResult.h>
#include <aws/workmail/model/PutMailboxPermissionsResult.h>
#include <aws/workmail/model/RegisterToWorkMailResult.h>
#include <aws/workmail/model/ResetPasswordResult.h>
#include <aws/workmail/model/UpdatePrimaryEmailAddressResult.h>
#include <aws/workmail/model/UpdateResourceResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

namespace Aws
{

namespace Http
{
  class HttpClient;
  class HttpClientFactory;
} // namespace Http

namespace Utils
{
  template< typename R, typename E> class Outcome;

namespace Threading
{
  class Executor;
} // namespace Threading
} // namespace Utils

namespace Auth
{
  class AWSCredentials;
  class AWSCredentialsProvider;
} // namespace Auth

namespace Client
{
  class RetryStrategy;
} // namespace Client

namespace WorkMail
{

namespace Model
{
        class AssociateDelegateToResourceRequest;
        class AssociateMemberToGroupRequest;
        class CreateAliasRequest;
        class CreateGroupRequest;
        class CreateResourceRequest;
        class CreateUserRequest;
        class DeleteAliasRequest;
        class DeleteGroupRequest;
        class DeleteMailboxPermissionsRequest;
        class DeleteResourceRequest;
        class DeleteUserRequest;
        class DeregisterFromWorkMailRequest;
        class DescribeGroupRequest;
        class DescribeOrganizationRequest;
        class DescribeResourceRequest;
        class DescribeUserRequest;
        class DisassociateDelegateFromResourceRequest;
        class DisassociateMemberFromGroupRequest;
        class ListAliasesRequest;
        class ListGroupMembersRequest;
        class ListGroupsRequest;
        class ListMailboxPermissionsRequest;
        class ListOrganizationsRequest;
        class ListResourceDelegatesRequest;
        class ListResourcesRequest;
        class ListUsersRequest;
        class PutMailboxPermissionsRequest;
        class RegisterToWorkMailRequest;
        class ResetPasswordRequest;
        class UpdatePrimaryEmailAddressRequest;
        class UpdateResourceRequest;

        typedef Aws::Utils::Outcome<AssociateDelegateToResourceResult, Aws::Client::AWSError<WorkMailErrors>> AssociateDelegateToResourceOutcome;
        typedef Aws::Utils::Outcome<AssociateMemberToGroupResult, Aws::Client::AWSError<WorkMailErrors>> AssociateMemberToGroupOutcome;
        typedef Aws::Utils::Outcome<CreateAliasResult, Aws::Client::AWSError<WorkMailErrors>> CreateAliasOutcome;
        typedef Aws::Utils::Outcome<CreateGroupResult, Aws::Client::AWSError<WorkMailErrors>> CreateGroupOutcome;
        typedef Aws::Utils::Outcome<CreateResourceResult, Aws::Client::AWSError<WorkMailErrors>> CreateResourceOutcome;
        typedef Aws::Utils::Outcome<CreateUserResult, Aws::Client::AWSError<WorkMailErrors>> CreateUserOutcome;
        typedef Aws::Utils::Outcome<DeleteAliasResult, Aws::Client::AWSError<WorkMailErrors>> DeleteAliasOutcome;
        typedef Aws::Utils::Outcome<DeleteGroupResult, Aws::Client::AWSError<WorkMailErrors>> DeleteGroupOutcome;
        typedef Aws::Utils::Outcome<DeleteMailboxPermissionsResult, Aws::Client::AWSError<WorkMailErrors>> DeleteMailboxPermissionsOutcome;
        typedef Aws::Utils::Outcome<DeleteResourceResult, Aws::Client::AWSError<WorkMailErrors>> DeleteResourceOutcome;
        typedef Aws::Utils::Outcome<DeleteUserResult, Aws::Client::AWSError<WorkMailErrors>> DeleteUserOutcome;
        typedef Aws::Utils::Outcome<DeregisterFromWorkMailResult, Aws::Client::AWSError<WorkMailErrors>> DeregisterFromWorkMailOutcome;
        typedef Aws::Utils::Outcome<DescribeGroupResult, Aws::Client::AWSError<WorkMailErrors>> DescribeGroupOutcome;
        typedef Aws::Utils::Outcome<DescribeOrganizationResult, Aws::Client::AWSError<WorkMailErrors>> DescribeOrganizationOutcome;
        typedef Aws::Utils::Outcome<DescribeResourceResult, Aws::Client::AWSError<WorkMailErrors>> DescribeResourceOutcome;
        typedef Aws::Utils::Outcome<DescribeUserResult, Aws::Client::AWSError<WorkMailErrors>> DescribeUserOutcome;
        typedef Aws::Utils::Outcome<DisassociateDelegateFromResourceResult, Aws::Client::AWSError<WorkMailErrors>> DisassociateDelegateFromResourceOutcome;
        typedef Aws::Utils::Outcome<DisassociateMemberFromGroupResult, Aws::Client::AWSError<WorkMailErrors>> DisassociateMemberFromGroupOutcome;
        typedef Aws::Utils::Outcome<ListAliasesResult, Aws::Client::AWSError<WorkMailErrors>> ListAliasesOutcome;
        typedef Aws::Utils::Outcome<ListGroupMembersResult, Aws::Client::AWSError<WorkMailErrors>> ListGroupMembersOutcome;
        typedef Aws::Utils::Outcome<ListGroupsResult, Aws::Client::AWSError<WorkMailErrors>> ListGroupsOutcome;
        typedef Aws::Utils::Outcome<ListMailboxPermissionsResult, Aws::Client::AWSError<WorkMailErrors>> ListMailboxPermissionsOutcome;
        typedef Aws::Utils::Outcome<ListOrganizationsResult, Aws::Client::AWSError<WorkMailErrors>> ListOrganizationsOutcome;
        typedef Aws::Utils::Outcome<ListResourceDelegatesResult, Aws::Client::AWSError<WorkMailErrors>> ListResourceDelegatesOutcome;
        typedef Aws::Utils::Outcome<ListResourcesResult, Aws::Client::AWSError<WorkMailErrors>> ListResourcesOutcome;
        typedef Aws::Utils::Outcome<ListUsersResult, Aws::Client::AWSError<WorkMailErrors>> ListUsersOutcome;
        typedef Aws::Utils::Outcome<PutMailboxPermissionsResult, Aws::Client::AWSError<WorkMailErrors>> PutMailboxPermissionsOutcome;
        typedef Aws::Utils::Outcome<RegisterToWorkMailResult, Aws::Client::AWSError<WorkMailErrors>> RegisterToWorkMailOutcome;
        typedef Aws::Utils::Outcome<ResetPasswordResult, Aws::Client::AWSError<WorkMailErrors>> ResetPasswordOutcome;
        typedef Aws::Utils::Outcome<UpdatePrimaryEmailAddressResult, Aws::Client::AWSError<WorkMailErrors>> UpdatePrimaryEmailAddressOutcome;
        typedef Aws::Utils::Outcome<UpdateResourceResult, Aws::Client::AWSError<WorkMailErrors>> UpdateResourceOutcome;

        typedef std::future<AssociateDelegateToResourceOutcome> AssociateDelegateToResourceOutcomeCallable;
        typedef std::future<AssociateMemberToGroupOutcome> AssociateMemberToGroupOutcomeCallable;
        typedef std::future<CreateAliasOutcome> CreateAliasOutcomeCallable;
        typedef std::future<CreateGroupOutcome> CreateGroupOutcomeCallable;
        typedef std::future<CreateResourceOutcome> CreateResourceOutcomeCallable;
        typedef std::future<CreateUserOutcome> CreateUserOutcomeCallable;
        typedef std::future<DeleteAliasOutcome> DeleteAliasOutcomeCallable;
        typedef std::future<DeleteGroupOutcome> DeleteGroupOutcomeCallable;
        typedef std::future<DeleteMailboxPermissionsOutcome> DeleteMailboxPermissionsOutcomeCallable;
        typedef std::future<DeleteResourceOutcome> DeleteResourceOutcomeCallable;
        typedef std::future<DeleteUserOutcome> DeleteUserOutcomeCallable;
        typedef std::future<DeregisterFromWorkMailOutcome> DeregisterFromWorkMailOutcomeCallable;
        typedef std::future<DescribeGroupOutcome> DescribeGroupOutcomeCallable;
        typedef std::future<DescribeOrganizationOutcome> DescribeOrganizationOutcomeCallable;
        typedef std::future<DescribeResourceOutcome> DescribeResourceOutcomeCallable;
        typedef std::future<DescribeUserOutcome> DescribeUserOutcomeCallable;
        typedef std::future<DisassociateDelegateFromResourceOutcome> DisassociateDelegateFromResourceOutcomeCallable;
        typedef std::future<DisassociateMemberFromGroupOutcome> DisassociateMemberFromGroupOutcomeCallable;
        typedef std::future<ListAliasesOutcome> ListAliasesOutcomeCallable;
        typedef std::future<ListGroupMembersOutcome> ListGroupMembersOutcomeCallable;
        typedef std::future<ListGroupsOutcome> ListGroupsOutcomeCallable;
        typedef std::future<ListMailboxPermissionsOutcome> ListMailboxPermissionsOutcomeCallable;
        typedef std::future<ListOrganizationsOutcome> ListOrganizationsOutcomeCallable;
        typedef std::future<ListResourceDelegatesOutcome> ListResourceDelegatesOutcomeCallable;
        typedef std::future<ListResourcesOutcome> ListResourcesOutcomeCallable;
        typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;
        typedef std::future<PutMailboxPermissionsOutcome> PutMailboxPermissionsOutcomeCallable;
        typedef std::future<RegisterToWorkMailOutcome> RegisterToWorkMailOutcomeCallable;
        typedef std::future<ResetPasswordOutcome> ResetPasswordOutcomeCallable;
        typedef std::future<UpdatePrimaryEmailAddressOutcome> UpdatePrimaryEmailAddressOutcomeCallable;
        typedef std::future<UpdateResourceOutcome> UpdateResourceOutcomeCallable;
} // namespace Model

  class WorkMailClient;

    typedef std::function<void(const WorkMailClient*, const Model::AssociateDelegateToResourceRequest&, const Model::AssociateDelegateToResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AssociateDelegateToResourceResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::AssociateMemberToGroupRequest&, const Model::AssociateMemberToGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AssociateMemberToGroupResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::CreateAliasRequest&, const Model::CreateAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateAliasResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::CreateGroupRequest&, const Model::CreateGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGroupResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::CreateResourceRequest&, const Model::CreateResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateResourceResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::CreateUserRequest&, const Model::CreateUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateUserResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeleteAliasRequest&, const Model::DeleteAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAliasResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeleteGroupRequest&, const Model::DeleteGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteGroupResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeleteMailboxPermissionsRequest&, const Model::DeleteMailboxPermissionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteMailboxPermissionsResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeleteResourceRequest&, const Model::DeleteResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteResourceResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeleteUserRequest&, const Model::DeleteUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DeregisterFromWorkMailRequest&, const Model::DeregisterFromWorkMailOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterFromWorkMailResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DescribeGroupRequest&, const Model::DescribeGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGroupResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DescribeOrganizationRequest&, const Model::DescribeOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeOrganizationResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DescribeResourceRequest&, const Model::DescribeResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeResourceResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DescribeUserRequest&, const Model::DescribeUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DisassociateDelegateFromResourceRequest&, const Model::DisassociateDelegateFromResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisassociateDelegateFromResourceResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::DisassociateMemberFromGroupRequest&, const Model::DisassociateMemberFromGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisassociateMemberFromGroupResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListAliasesRequest&, const Model::ListAliasesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListAliasesResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListGroupMembersRequest&, const Model::ListGroupMembersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGroupMembersResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListGroupsRequest&, const Model::ListGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGroupsResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListMailboxPermissionsRequest&, const Model::ListMailboxPermissionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListMailboxPermissionsResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListOrganizationsRequest&, const Model::ListOrganizationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListOrganizationsResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListResourceDelegatesRequest&, const Model::ListResourceDelegatesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourceDelegatesResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListResourcesRequest&, const Model::ListResourcesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourcesResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ListUsersRequest&, const Model::ListUsersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUsersResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::PutMailboxPermissionsRequest&, const Model::PutMailboxPermissionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutMailboxPermissionsResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::RegisterToWorkMailRequest&, const Model::RegisterToWorkMailOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterToWorkMailResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::ResetPasswordRequest&, const Model::ResetPasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ResetPasswordResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::UpdatePrimaryEmailAddressRequest&, const Model::UpdatePrimaryEmailAddressOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdatePrimaryEmailAddressResponseReceivedHandler;
    typedef std::function<void(const WorkMailClient*, const Model::UpdateResourceRequest&, const Model::UpdateResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateResourceResponseReceivedHandler;

  /**
   *
Amazon WorkMail is a secure, managed business email and calendaring service
   * with support for existing desktop and mobile email clients. You can access your
   * email, contacts, and calendars using Microsoft Outlook, your browser, or their
   * native iOS and Android email applications. You can integrate Amazon WorkMail
   * with your existing corporate directory and control both the keys that encrypt
   * your data and the location in which your data is stored.

The Amazon
   * WorkMail API is designed for the following scenarios:

Listing
   * and describing organizations

Managing users

   *

Managing groups

Managing
   * resources

All Amazon WorkMail API actions are
   * Amazon-authenticated and certificate-signed. They not only require the use of
   * the AWS SDK, but also allow for the exclusive use of IAM users and roles to help
   * facilitate access, trust, and permission policies. By creating a role and
   * allowing an IAM user to access the Amazon WorkMail site, the IAM user gains full
   * administrative visibility into the entire Amazon WorkMail organization (or as
   * set in the IAM policy). This includes, but is not limited to, the ability to
   * create, update, and delete users, groups, and resources. This allows developers
   * to perform the scenarios listed above, as well as give users the ability to
   * grant access on a selective basis using the IAM model.

   */
  class AWS_WORKMAIL_API WorkMailClient : public Aws::Client::AWSJsonClient
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;

       /**
        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        WorkMailClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        WorkMailClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
        * the default http client factory will be used
        */
        WorkMailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

        virtual ~WorkMailClient();

        inline virtual const char* GetServiceClientName() const override { return "workmail"; }

        /**
         *
Adds a member to the resource's set of delegates.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::AssociateDelegateToResourceOutcome AssociateDelegateToResource(const Model::AssociateDelegateToResourceRequest& request) const;

        /**
         *
Adds a member to the resource's set of delegates.

See Also:

         * AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::AssociateDelegateToResourceOutcomeCallable AssociateDelegateToResourceCallable(const Model::AssociateDelegateToResourceRequest& request) const;

        /**
         *
Adds a member to the resource's set of delegates.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void AssociateDelegateToResourceAsync(const Model::AssociateDelegateToResourceRequest& request, const AssociateDelegateToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Adds a member to the group's set.

See Also:
   AWS
         * API Reference

         */
        virtual Model::AssociateMemberToGroupOutcome AssociateMemberToGroup(const Model::AssociateMemberToGroupRequest& request) const;

        /**
         *
Adds a member to the group's set.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::AssociateMemberToGroupOutcomeCallable AssociateMemberToGroupCallable(const Model::AssociateMemberToGroupRequest& request) const;

        /**
         *
Adds a member to the group's set.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void AssociateMemberToGroupAsync(const Model::AssociateMemberToGroupRequest& request, const AssociateMemberToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Adds an alias to the set of a given member of Amazon WorkMail.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;

        /**
         *
Adds an alias to the set of a given member of Amazon WorkMail.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateAliasOutcomeCallable CreateAliasCallable(const Model::CreateAliasRequest& request) const;

        /**
         *
Adds an alias to the set of a given member of Amazon WorkMail.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateAliasAsync(const Model::CreateAliasRequest& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a group that can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;

        /**
         *
Creates a group that can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateGroupOutcomeCallable CreateGroupCallable(const Model::CreateGroupRequest& request) const;

        /**
         *
Creates a group that can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateGroupAsync(const Model::CreateGroupRequest& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a new Amazon WorkMail resource. The available types are equipment and
         * room.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateResourceOutcome CreateResource(const Model::CreateResourceRequest& request) const;

        /**
         *
Creates a new Amazon WorkMail resource. The available types are equipment and
         * room.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateResourceOutcomeCallable CreateResourceCallable(const Model::CreateResourceRequest& request) const;

        /**
         *
Creates a new Amazon WorkMail resource. The available types are equipment and
         * room.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateResourceAsync(const Model::CreateResourceRequest& request, const CreateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a user who can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;

        /**
         *
Creates a user who can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateUserOutcomeCallable CreateUserCallable(const Model::CreateUserRequest& request) const;

        /**
         *
Creates a user who can be used in Amazon WorkMail by calling the
         * RegisterToWorkMail operation.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateUserAsync(const Model::CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Remove the alias from a set of aliases for a given user.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const;

        /**
         *
Remove the alias from a set of aliases for a given user.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const Model::DeleteAliasRequest& request) const;

        /**
         *
Remove the alias from a set of aliases for a given user.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteAliasAsync(const Model::DeleteAliasRequest& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a group from Amazon WorkMail.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;

        /**
         *
Deletes a group from Amazon WorkMail.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const Model::DeleteGroupRequest& request) const;

        /**
         *
Deletes a group from Amazon WorkMail.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteGroupAsync(const Model::DeleteGroupRequest& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes permissions granted to a user or group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteMailboxPermissionsOutcome DeleteMailboxPermissions(const Model::DeleteMailboxPermissionsRequest& request) const;

        /**
         *
Deletes permissions granted to a user or group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteMailboxPermissionsOutcomeCallable DeleteMailboxPermissionsCallable(const Model::DeleteMailboxPermissionsRequest& request) const;

        /**
         *
Deletes permissions granted to a user or group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteMailboxPermissionsAsync(const Model::DeleteMailboxPermissionsRequest& request, const DeleteMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes the specified resource.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteResourceOutcome DeleteResource(const Model::DeleteResourceRequest& request) const;

        /**
         *
Deletes the specified resource.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteResourceOutcomeCallable DeleteResourceCallable(const Model::DeleteResourceRequest& request) const;

        /**
         *
Deletes the specified resource.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteResourceAsync(const Model::DeleteResourceRequest& request, const DeleteResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a user from Amazon WorkMail and all subsequent systems. The action
         * can't be undone. The mailbox is kept as-is for a minimum of 30 days, without any
         * means to restore it.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;

        /**
         *
Deletes a user from Amazon WorkMail and all subsequent systems. The action
         * can't be undone. The mailbox is kept as-is for a minimum of 30 days, without any
         * means to restore it.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteUserOutcomeCallable DeleteUserCallable(const Model::DeleteUserRequest& request) const;

        /**
         *
Deletes a user from Amazon WorkMail and all subsequent systems. The action
         * can't be undone. The mailbox is kept as-is for a minimum of 30 days, without any
         * means to restore it.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteUserAsync(const Model::DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Mark a user, group, or resource as no longer used in Amazon WorkMail. This
         * action disassociates the mailbox and schedules it for clean-up. Amazon WorkMail
         * keeps mailboxes for 30 days before they are permanently removed. The
         * functionality in the console is Disable.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeregisterFromWorkMailOutcome DeregisterFromWorkMail(const Model::DeregisterFromWorkMailRequest& request) const;

        /**
         *
Mark a user, group, or resource as no longer used in Amazon WorkMail. This
         * action disassociates the mailbox and schedules it for clean-up. Amazon WorkMail
         * keeps mailboxes for 30 days before they are permanently removed. The
         * functionality in the console is Disable.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeregisterFromWorkMailOutcomeCallable DeregisterFromWorkMailCallable(const Model::DeregisterFromWorkMailRequest& request) const;

        /**
         *
Mark a user, group, or resource as no longer used in Amazon WorkMail. This
         * action disassociates the mailbox and schedules it for clean-up. Amazon WorkMail
         * keeps mailboxes for 30 days before they are permanently removed. The
         * functionality in the console is Disable.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeregisterFromWorkMailAsync(const Model::DeregisterFromWorkMailRequest& request, const DeregisterFromWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the data available for the group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeGroupOutcome DescribeGroup(const Model::DescribeGroupRequest& request) const;

        /**
         *
Returns the data available for the group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeGroupOutcomeCallable DescribeGroupCallable(const Model::DescribeGroupRequest& request) const;

        /**
         *
Returns the data available for the group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeGroupAsync(const Model::DescribeGroupRequest& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Provides more information regarding a given organization based on its
         * identifier.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeOrganizationOutcome DescribeOrganization(const Model::DescribeOrganizationRequest& request) const;

        /**
         *
Provides more information regarding a given organization based on its
         * identifier.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeOrganizationOutcomeCallable DescribeOrganizationCallable(const Model::DescribeOrganizationRequest& request) const;

        /**
         *
Provides more information regarding a given organization based on its
         * identifier.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeOrganizationAsync(const Model::DescribeOrganizationRequest& request, const DescribeOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the data available for the resource.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeResourceOutcome DescribeResource(const Model::DescribeResourceRequest& request) const;

        /**
         *
Returns the data available for the resource.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeResourceOutcomeCallable DescribeResourceCallable(const Model::DescribeResourceRequest& request) const;

        /**
         *
Returns the data available for the resource.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeResourceAsync(const Model::DescribeResourceRequest& request, const DescribeResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Provides information regarding the user.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;

        /**
         *
Provides information regarding the user.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeUserOutcomeCallable DescribeUserCallable(const Model::DescribeUserRequest& request) const;

        /**
         *
Provides information regarding the user.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeUserAsync(const Model::DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Removes a member from the resource's set of delegates.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::DisassociateDelegateFromResourceOutcome DisassociateDelegateFromResource(const Model::DisassociateDelegateFromResourceRequest& request) const;

        /**
         *
Removes a member from the resource's set of delegates.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DisassociateDelegateFromResourceOutcomeCallable DisassociateDelegateFromResourceCallable(const Model::DisassociateDelegateFromResourceRequest& request) const;

        /**
         *
Removes a member from the resource's set of delegates.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DisassociateDelegateFromResourceAsync(const Model::DisassociateDelegateFromResourceRequest& request, const DisassociateDelegateFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Removes a member from a group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DisassociateMemberFromGroupOutcome DisassociateMemberFromGroup(const Model::DisassociateMemberFromGroupRequest& request) const;

        /**
         *
Removes a member from a group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DisassociateMemberFromGroupOutcomeCallable DisassociateMemberFromGroupCallable(const Model::DisassociateMemberFromGroupRequest& request) const;

        /**
         *
Removes a member from a group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DisassociateMemberFromGroupAsync(const Model::DisassociateMemberFromGroupRequest& request, const DisassociateMemberFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a paginated call to list the aliases associated with a given
         * entity.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const;

        /**
         *
Creates a paginated call to list the aliases associated with a given
         * entity.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListAliasesOutcomeCallable ListAliasesCallable(const Model::ListAliasesRequest& request) const;

        /**
         *
Creates a paginated call to list the aliases associated with a given
         * entity.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListAliasesAsync(const Model::ListAliasesRequest& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns an overview of the members of a group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListGroupMembersOutcome ListGroupMembers(const Model::ListGroupMembersRequest& request) const;

        /**
         *
Returns an overview of the members of a group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListGroupMembersOutcomeCallable ListGroupMembersCallable(const Model::ListGroupMembersRequest& request) const;

        /**
         *
Returns an overview of the members of a group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListGroupMembersAsync(const Model::ListGroupMembersRequest& request, const ListGroupMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns summaries of the organization's groups.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const;

        /**
         *
Returns summaries of the organization's groups.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListGroupsOutcomeCallable ListGroupsCallable(const Model::ListGroupsRequest& request) const;

        /**
         *
Returns summaries of the organization's groups.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListGroupsAsync(const Model::ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Lists the mailbox permissions associated with a mailbox.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::ListMailboxPermissionsOutcome ListMailboxPermissions(const Model::ListMailboxPermissionsRequest& request) const;

        /**
         *
Lists the mailbox permissions associated with a mailbox.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListMailboxPermissionsOutcomeCallable ListMailboxPermissionsCallable(const Model::ListMailboxPermissionsRequest& request) const;

        /**
         *
Lists the mailbox permissions associated with a mailbox.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListMailboxPermissionsAsync(const Model::ListMailboxPermissionsRequest& request, const ListMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns summaries of the customer's non-deleted organizations.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::ListOrganizationsOutcome ListOrganizations(const Model::ListOrganizationsRequest& request) const;

        /**
         *
Returns summaries of the customer's non-deleted organizations.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListOrganizationsOutcomeCallable ListOrganizationsCallable(const Model::ListOrganizationsRequest& request) const;

        /**
         *
Returns summaries of the customer's non-deleted organizations.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListOrganizationsAsync(const Model::ListOrganizationsRequest& request, const ListOrganizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Lists the delegates associated with a resource. Users and groups can be
         * resource delegates and answer requests on behalf of the resource.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::ListResourceDelegatesOutcome ListResourceDelegates(const Model::ListResourceDelegatesRequest& request) const;

        /**
         *
Lists the delegates associated with a resource. Users and groups can be
         * resource delegates and answer requests on behalf of the resource.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListResourceDelegatesOutcomeCallable ListResourceDelegatesCallable(const Model::ListResourceDelegatesRequest& request) const;

        /**
         *
Lists the delegates associated with a resource. Users and groups can be
         * resource delegates and answer requests on behalf of the resource.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListResourceDelegatesAsync(const Model::ListResourceDelegatesRequest& request, const ListResourceDelegatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns summaries of the organization's resources.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::ListResourcesOutcome ListResources(const Model::ListResourcesRequest& request) const;

        /**
         *
Returns summaries of the organization's resources.

See Also:

         * AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListResourcesOutcomeCallable ListResourcesCallable(const Model::ListResourcesRequest& request) const;

        /**
         *
Returns summaries of the organization's resources.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListResourcesAsync(const Model::ListResourcesRequest& request, const ListResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns summaries of the organization's users.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;

        /**
         *
Returns summaries of the organization's users.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListUsersOutcomeCallable ListUsersCallable(const Model::ListUsersRequest& request) const;

        /**
         *
Returns summaries of the organization's users.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListUsersAsync(const Model::ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Sets permissions for a user or group. This replaces any pre-existing
         * permissions set for the entity.

See Also:
   AWS
         * API Reference

         */
        virtual Model::PutMailboxPermissionsOutcome PutMailboxPermissions(const Model::PutMailboxPermissionsRequest& request) const;

        /**
         *
Sets permissions for a user or group. This replaces any pre-existing
         * permissions set for the entity.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::PutMailboxPermissionsOutcomeCallable PutMailboxPermissionsCallable(const Model::PutMailboxPermissionsRequest& request) const;

        /**
         *
Sets permissions for a user or group. This replaces any pre-existing
         * permissions set for the entity.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void PutMailboxPermissionsAsync(const Model::PutMailboxPermissionsRequest& request, const PutMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Registers an existing and disabled user, group, or resource/entity for Amazon
         * WorkMail use by associating a mailbox and calendaring capabilities. It performs
         * no change if the entity is enabled and fails if the entity is deleted. This
         * operation results in the accumulation of costs. For more information, see Pricing. The equivalent
         * console functionality for this operation is Enable. Users can either be
         * created by calling the CreateUser API or they can be synchronized from your
         * directory. For more information, see DeregisterFromWorkMail.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::RegisterToWorkMailOutcome RegisterToWorkMail(const Model::RegisterToWorkMailRequest& request) const;

        /**
         *
Registers an existing and disabled user, group, or resource/entity for Amazon
         * WorkMail use by associating a mailbox and calendaring capabilities. It performs
         * no change if the entity is enabled and fails if the entity is deleted. This
         * operation results in the accumulation of costs. For more information, see Pricing. The equivalent
         * console functionality for this operation is Enable. Users can either be
         * created by calling the CreateUser API or they can be synchronized from your
         * directory. For more information, see DeregisterFromWorkMail.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::RegisterToWorkMailOutcomeCallable RegisterToWorkMailCallable(const Model::RegisterToWorkMailRequest& request) const;

        /**
         *
Registers an existing and disabled user, group, or resource/entity for Amazon
         * WorkMail use by associating a mailbox and calendaring capabilities. It performs
         * no change if the entity is enabled and fails if the entity is deleted. This
         * operation results in the accumulation of costs. For more information, see Pricing. The equivalent
         * console functionality for this operation is Enable. Users can either be
         * created by calling the CreateUser API or they can be synchronized from your
         * directory. For more information, see DeregisterFromWorkMail.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void RegisterToWorkMailAsync(const Model::RegisterToWorkMailRequest& request, const RegisterToWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Allows the administrator to reset the password for a user.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::ResetPasswordOutcome ResetPassword(const Model::ResetPasswordRequest& request) const;

        /**
         *
Allows the administrator to reset the password for a user.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ResetPasswordOutcomeCallable ResetPasswordCallable(const Model::ResetPasswordRequest& request) const;

        /**
         *
Allows the administrator to reset the password for a user.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ResetPasswordAsync(const Model::ResetPasswordRequest& request, const ResetPasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Updates the primary email for an entity. The current email is moved into the
         * list of aliases (or swapped between an existing alias and the current primary
         * email) and the email provided in the input is promoted as the
         * primary.

See Also:
   AWS
         * API Reference

         */
        virtual Model::UpdatePrimaryEmailAddressOutcome UpdatePrimaryEmailAddress(const Model::UpdatePrimaryEmailAddressRequest& request) const;

        /**
         *
Updates the primary email for an entity. The current email is moved into the
         * list of aliases (or swapped between an existing alias and the current primary
         * email) and the email provided in the input is promoted as the
         * primary.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdatePrimaryEmailAddressOutcomeCallable UpdatePrimaryEmailAddressCallable(const Model::UpdatePrimaryEmailAddressRequest& request) const;

        /**
         *
Updates the primary email for an entity. The current email is moved into the
         * list of aliases (or swapped between an existing alias and the current primary
         * email) and the email provided in the input is promoted as the
         * primary.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdatePrimaryEmailAddressAsync(const Model::UpdatePrimaryEmailAddressRequest& request, const UpdatePrimaryEmailAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Updates data for the resource. It must be preceded by a describe call in
         * order to have the latest information. The dataset in the request should be the
         * one expected when performing another describe call.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::UpdateResourceOutcome UpdateResource(const Model::UpdateResourceRequest& request) const;

        /**
         *
Updates data for the resource. It must be preceded by a describe call in
         * order to have the latest information. The dataset in the request should be the
         * one expected when performing another describe call.

See Also:

         * AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateResourceOutcomeCallable UpdateResourceCallable(const Model::UpdateResourceRequest& request) const;

        /**
         *
Updates data for the resource. It must be preceded by a describe call in
         * order to have the latest information. The dataset in the request should be the
         * one expected when performing another describe call.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateResourceAsync(const Model::UpdateResourceRequest& request, const UpdateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);

        /**Async helpers**/
        void AssociateDelegateToResourceAsyncHelper(const Model::AssociateDelegateToResourceRequest& request, const AssociateDelegateToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void AssociateMemberToGroupAsyncHelper(const Model::AssociateMemberToGroupRequest& request, const AssociateMemberToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateAliasAsyncHelper(const Model::CreateAliasRequest& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateGroupAsyncHelper(const Model::CreateGroupRequest& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateResourceAsyncHelper(const Model::CreateResourceRequest& request, const CreateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateUserAsyncHelper(const Model::CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteAliasAsyncHelper(const Model::DeleteAliasRequest& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteGroupAsyncHelper(const Model::DeleteGroupRequest& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteMailboxPermissionsAsyncHelper(const Model::DeleteMailboxPermissionsRequest& request, const DeleteMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteResourceAsyncHelper(const Model::DeleteResourceRequest& request, const DeleteResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteUserAsyncHelper(const Model::DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeregisterFromWorkMailAsyncHelper(const Model::DeregisterFromWorkMailRequest& request, const DeregisterFromWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeGroupAsyncHelper(const Model::DescribeGroupRequest& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeOrganizationAsyncHelper(const Model::DescribeOrganizationRequest& request, const DescribeOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeResourceAsyncHelper(const Model::DescribeResourceRequest& request, const DescribeResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeUserAsyncHelper(const Model::DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DisassociateDelegateFromResourceAsyncHelper(const Model::DisassociateDelegateFromResourceRequest& request, const DisassociateDelegateFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DisassociateMemberFromGroupAsyncHelper(const Model::DisassociateMemberFromGroupRequest& request, const DisassociateMemberFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListAliasesAsyncHelper(const Model::ListAliasesRequest& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListGroupMembersAsyncHelper(const Model::ListGroupMembersRequest& request, const ListGroupMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListGroupsAsyncHelper(const Model::ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListMailboxPermissionsAsyncHelper(const Model::ListMailboxPermissionsRequest& request, const ListMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListOrganizationsAsyncHelper(const Model::ListOrganizationsRequest& request, const ListOrganizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListResourceDelegatesAsyncHelper(const Model::ListResourceDelegatesRequest& request, const ListResourceDelegatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListResourcesAsyncHelper(const Model::ListResourcesRequest& request, const ListResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListUsersAsyncHelper(const Model::ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void PutMailboxPermissionsAsyncHelper(const Model::PutMailboxPermissionsRequest& request, const PutMailboxPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void RegisterToWorkMailAsyncHelper(const Model::RegisterToWorkMailRequest& request, const RegisterToWorkMailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ResetPasswordAsyncHelper(const Model::ResetPasswordRequest& request, const ResetPasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdatePrimaryEmailAddressAsyncHelper(const Model::UpdatePrimaryEmailAddressRequest& request, const UpdatePrimaryEmailAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateResourceAsyncHelper(const Model::UpdateResourceRequest& request, const UpdateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

      Aws::String m_uri;
      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
  };

} // namespace WorkMail
} // namespace Aws


text:
require File.expand_path(File.dirname(__FILE__) + '/../../../lib/duxml/doc/lazy_ox')
require 'ox'
require 'test/unit'

module Duxml
  class El < ::Ox::Element
    include LazyOx

    def simple_name
      name.split(':').last
    end
  end

  module Root
    def foo
      'hi!'
    end
  end
end

class Generic
  include Duxml::LazyOx
  def initialize(*a)
    @nodes = a
  end

  attr_reader :nodes
end

class Duck
  def name; 'duck' end
end

class Goose;
  def name; 'goose' end
end

module Outer
  module Inner
    def doit
      'hi!'
    end
  end
end

class LazyOxTest < Test::Unit::TestCase
  include Duxml
  include Ox

  def setup
    @x = El.new('root')
  end

  attr_accessor :x

  def test_module_extension
    assert_equal 'hi!', x.foo
  end

  def test_module_nesting_main_module
    outer = El.new('outer:inner')
    assert_equal 'hi!', outer.doit
  end

  def test_module_nesting_duxml
    outer = El.new('duxml:root')
    assert_equal 'hi!', outer.foo
  end

  def test_module_nesting_default
    outer = El.new('root')
    assert_equal 'hi!', outer.foo
  end

  def test_no_method_error
    assert_raise(NoMethodError, "undefined method `asdf' for class `Duxml::El'") do x.asdf end
  end

  def test_class_match_array
    g = Generic.new(Duck.new, Goose.new, Goose.new)
    a = g.Goose
    assert_equal 2, a.size
    assert_equal "goose", a.first.name
    assert_equal "goose", a[1].name
  end

  def test_element_name_array
    #unfiltered
    %w(one two two two).each do |name| x << El.new(name) end
    a = x.two
    assert_equal x.nodes[1], a
    a = x.Two
    assert_equal x.nodes[1], a.first
    a = x.Two
    assert_equal x.nodes[3], a.last

    #filtered by member
    a.first[:attr] = 'val'
    a.last[:attr] = 'value'
    assert_equal [a.first, a.last], x.Two(:attr)

    #filtered by member value
    assert_equal [a.first], x.Two(attr: 'val')

    #selected by block
    assert_equal [a.first], x.Two{|n| n[:attr] == 'val'}
  end

  def test_namespaced_children
    r = El.new('asdf:root') << El.new('asdf:child')
    c = r.child
    assert_equal 'asdf:child', c.value
  end

  def test_misnavigation
    %w(one two two two).each do |name| x << El.new(name) end
    assert_raise(NoMethodError) do x.three end

    o = El.new('outer:inner_fake') << El.new('coo')
    assert_raise(NoMethodError) do o.coo.yeah end
  end

  def tear_down
  end
end

redpajama_set_name: RedPajamaGithub


text:
package io.grpc.internal;

import static com.google.common.base.Charsets.US_ASCII;
import static com.google.common.base.Charsets.UTF_8;
import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
import static io.grpc.Metadata.BINARY_BYTE_MARSHALLER;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import com.google.common.collect.Iterables;
import com.google.common.io.BaseEncoding;
import io.grpc.InternalMetadata;
import io.grpc.Metadata;
import io.grpc.Metadata.BinaryMarshaller;
import java.util.Arrays;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Unit tests for {@link TransportFrameUtil}. */
@RunWith(JUnit4.class)
public class TransportFrameUtilTest {

  private static final String NONCOMPLIANT_ASCII_STRING = new String(new char[]{1, 2, 3});

  private static final String COMPLIANT_ASCII_STRING = "Kyle";

  private static final BinaryMarshaller<String> UTF8_STRING_MARSHALLER =
      new BinaryMarshaller<String>() {
    @Override
    public byte[] toBytes(String value) {
      return value.getBytes(UTF_8);
    }

    @Override
    public String parseBytes(byte[] serialized) {
      return new String(serialized, UTF_8);
    }
  };

  private static final Metadata.Key<String> PLAIN_STRING =
      Metadata.Key.of("plainstring", ASCII_STRING_MARSHALLER);
  private static final Metadata.Key<String> BINARY_STRING =
      Metadata.Key.of("string-bin", UTF8_STRING_MARSHALLER);
  private static final Metadata.Key<String> BINARY_STRING_WITHOUT_SUFFIX =
      Metadata.Key.of("string", ASCII_STRING_MARSHALLER);
  private static final Metadata.Key<byte[]> BINARY_BYTES =
      Metadata.Key.of("bytes-bin", BINARY_BYTE_MARSHALLER);

  @Test
  public void testToHttp2Headers() {
    Metadata headers = new Metadata();
    headers.put(PLAIN_STRING, COMPLIANT_ASCII_STRING);
    headers.put(BINARY_STRING, NONCOMPLIANT_ASCII_STRING);
    headers.put(BINARY_STRING_WITHOUT_SUFFIX, NONCOMPLIANT_ASCII_STRING);
    byte[][] http2Headers = TransportFrameUtil.toHttp2Headers(headers);
    // BINARY_STRING_WITHOUT_SUFFIX should not get in because it contains non-compliant ASCII
    // characters but doesn't have "-bin" in the name.
    byte[][] answer = new byte[][] {
        "plainstring".getBytes(US_ASCII), COMPLIANT_ASCII_STRING.getBytes(US_ASCII),
        "string-bin".getBytes(US_ASCII),
        base64Encode(NONCOMPLIANT_ASCII_STRING.getBytes(US_ASCII))};
    assertEquals(answer.length, http2Headers.length);
    // http2Headers may re-sort the keys, so we cannot compare it with the answer side-by-side.
    for (int i = 0; i < answer.length; i += 2) {
      assertContains(http2Headers, answer[i], answer[i + 1]);
    }
  }

  @Test(expected = IllegalArgumentException.class)
  public void binaryHeaderWithoutSuffix() {
    Metadata.Key.of("plainstring", UTF8_STRING_MARSHALLER);
  }

  @Test
  public void testToAndFromHttp2Headers() {
    Metadata headers = new Metadata();
    headers.put(PLAIN_STRING, COMPLIANT_ASCII_STRING);
    headers.put(BINARY_STRING, NONCOMPLIANT_ASCII_STRING);
    headers.put(BINARY_STRING_WITHOUT_SUFFIX, NONCOMPLIANT_ASCII_STRING);
    byte[][] http2Headers = TransportFrameUtil.toHttp2Headers(headers);
    byte[][] rawSerialized = TransportFrameUtil.toRawSerializedHeaders(http2Headers);
    Metadata recoveredHeaders = InternalMetadata.newMetadata(rawSerialized);
    assertEquals(COMPLIANT_ASCII_STRING, recoveredHeaders.get(PLAIN_STRING));
    assertEquals(NONCOMPLIANT_ASCII_STRING, recoveredHeaders.get(BINARY_STRING));
    assertNull(recoveredHeaders.get(BINARY_STRING_WITHOUT_SUFFIX));
  }

  @Test
  public void dupBinHeadersWithComma() {
    byte[][] http2Headers = new byte[][] {
        BINARY_BYTES.name().getBytes(US_ASCII),
        "BaS,e6,,4+,padding==".getBytes(US_ASCII),
        BINARY_BYTES.name().getBytes(US_ASCII),
        "more".getBytes(US_ASCII),
        BINARY_BYTES.name().getBytes(US_ASCII),
        "".getBytes(US_ASCII)};
    byte[][] rawSerialized = TransportFrameUtil.toRawSerializedHeaders(http2Headers);
    Metadata recoveredHeaders = InternalMetadata.newMetadata(rawSerialized);
    byte[][] values = Iterables.toArray(recoveredHeaders.getAll(BINARY_BYTES), byte[].class);

    assertTrue(Arrays.deepEquals(
        new byte[][] {
            BaseEncoding.base64().decode("BaS"),
            BaseEncoding.base64().decode("e6"),
            BaseEncoding.base64().decode(""),
            BaseEncoding.base64().decode("4+"),
            BaseEncoding.base64().decode("padding"),
            BaseEncoding.base64().decode("more"),
            BaseEncoding.base64().decode("")},
        values));
  }

  private static void assertContains(byte[][] headers, byte[] key, byte[] value) {
    String keyString = new String(key, US_ASCII);
    for (int i = 0; i < headers.length; i += 2) {
      if (Arrays.equals(headers[i], key)) {
        assertArrayEquals("value for key=" + keyString, value, headers[i + 1]);
        return;
      }
    }
    fail("key=" + keyString + " not found");
  }

  private static byte[] base64Encode(byte[] input) {
    return InternalMetadata.BASE64_ENCODING_OMIT_PADDING.encode(input).getBytes(US_ASCII);
  }

}


text:
package shijimi.app;

import java.util.List;

/**
 * The interface for structured member information.
 */
public interface GuiInfo {
    public String getName();
    public List<GuiInfo> getChildren();
}


text:
#ifndef _COMBO_ACTION_EVAL_H
#define _COMBO_ACTION_EVAL_H

#include "combo/vertex.h"
#include "util/exception.h"
#include "combo/using.h"
#include "combo/tree_type.h"
#include "util/tree.h"

namespace combo {
  inline vertex& binding(int idx) {
    static util::hash_map<int,vertex> map;
    return map[idx];
  }

  template<typename It>
  vertex action_eval_throws(It it) throw(EvalException) {
    typedef typename It::sibling_iterator sib_it;
    //argument
    //WARNING : we assume the argument is necessarily an action and therefor
    //never has a negative index
    if(is_argument(*it)) {
      int idx=get_argument(*it).idx;
      //assumption : when idx is negative the argument is necessary boolean
      assert(idx>0);
      return binding(idx);
    }
    //action sequence
    if(*it==id::sequential_and) {
      for(sib_it sib = it.begin(); sib != it.end(); ++sib) {
	if(action_eval_throws(sib) != id::action_success)
	  return id::action_failure;
      }
      return id::action_success;
    }
    else if(*it==id::sequential_or) {
      for(sib_it sib = it.begin(); sib != it.end(); ++sib) {
	if(action_eval_throws(sib) == id::action_success)
	  return id::action_success;
      }
      return id::action_failure;
    }
    else if(*it==id::sequential_exec) {
      for(sib_it sib = it.begin(); sib != it.end(); ++sib)
	action_eval_throws(sib);
      return id::action_success;
    }
    //action_if
    else if(*it==id::boolean_action_if) {
      assert(it.number_of_children()==3);
      sib_it sib = it.begin();
      vertex vcond = action_eval_throws(sib);
      ++sib;
      if(vcond==id::action_success) {
	//TODO : check that b1 and b2 have type boolean
	return eval_throws(sib);
      }
      else {
	++sib;
	return eval_throws(sib);
      }
    }
    else if(*it==id::contin_action_if) {
      assert(it.number_of_children()==3);
      sib_it sib = it.begin();
      vertex vcond = action_eval_throws(sib);
      ++sib;
      if(vcond==id::action_success) {
	//TODO : check that b1 and b2 have type contin
	return eval_throws(sib);
      }
      else {
	++sib;
	return eval_throws(sib);
      }
    }
    else if(*it==id::action_action_if) {
      assert(it.number_of_children()==3);
      sib_it sib = it.begin();
      vertex vcond = action_eval_throws(sib);
      ++sib;
      if(vcond==id::action_success) {
	//TODO : check that b1 and b2 have type action
	return action_eval_throws(sib);
      }
      else {
	++sib;
	return action_eval_throws(sib);
      }
    }
    //elementary action
    else if(*it==id::dummy_action) {
      std::cout << "Performing dummy_action" << std::endl;
      return id::action_success;
    }
    else {
      return *it;
    }
  }

}

#endif


text:
package org.apache.hadoop.hbase.replication;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

import java.util.EnumSet;
import java.util.List;
import org.apache.hadoop.hbase.ClusterMetrics;
import org.apache.hadoop.hbase.ClusterMetrics.Option;
import org.apache.hadoop.hbase.HBaseClassTestRule;
import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.testclassification.MediumTests;
import org.apache.hadoop.hbase.testclassification.ReplicationTests;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.experimental.categories.Category;

@Category({ ReplicationTests.class, MediumTests.class })
public class TestReplicationStatusSourceStartedTargetStoppedNoOps extends TestReplicationBase {

  @ClassRule
  public static final HBaseClassTestRule CLASS_RULE =
    HBaseClassTestRule.forClass(TestReplicationStatusSourceStartedTargetStoppedNoOps.class);

  @Test
  public void testReplicationStatusSourceStartedTargetStoppedNoOps() throws Exception {
    UTIL2.shutdownMiniHBaseCluster();
    restartSourceCluster(1);
    Admin hbaseAdmin = UTIL1.getAdmin();
    ServerName serverName = UTIL1.getHBaseCluster().getRegionServer(0).getServerName();
    Thread.sleep(10000);
    ClusterMetrics metrics = hbaseAdmin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS));
    List<ReplicationLoadSource> loadSources =
      metrics.getLiveServerMetrics().get(serverName).getReplicationLoadSourceList();
    assertEquals(1, loadSources.size());
    ReplicationLoadSource loadSource = loadSources.get(0);
    assertFalse(loadSource.hasEditsSinceRestart());
    assertEquals(0, loadSource.getTimestampOfLastShippedOp());
    assertEquals(0, loadSource.getReplicationLag());
    assertFalse(loadSource.isRecovered());
  }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<openerp>
    <data>

        <!-- add google drive config field in user form -->

        <record model="ir.ui.view" id="view_ir_attachment_google_spreadsheet_tree">
            <field name="name">ir.attachment.google.spreadsheet.tree</field>
            <field name="model">ir.attachment</field>
            <field name="arch" type="xml">
                <tree string="Google Spreadsheets">
                    <field name="name" string="Name"/>
                    <field name="url" />
                </tree>
            </field>
        </record>

        <record model="ir.ui.view" id="view_ir_attachment_google_spreadsheet_form">
            <field name="name">ir.attachment.google.spreadsheet.form</field>
            <field name="model">ir.attachment</field>
            <field name="arch" type="xml">
                <form string="Google Spreadsheets">
                    <sheet>
                        <group>
                            <group>
                                <field name="name" string="Name"/>
                                <field name="url" widget="url"/>
                            </group>
                            <group colspan="2">
                                <label for="description" colspan="2"/>
                                <field name="description" nolabel="1" colspan="2"/>
                            </group>
                        </group>
                    </sheet>
                </form>
            </field>
        </record>

        <record id="action_ir_attachment_google_spreadsheet_tree" model="ir.actions.act_window">
            <field name="name">Google Spreadsheets</field>
            <field name="res_model">ir.attachment</field>
            <field name="view_type">form</field>
            <field name="view_mode">tree,form</field>
            <field name="context">{}</field>
            <field name="domain">[('url', 'like', '/spreadsheet/')]</field>
            <field name="help">Google Spreadsheets</field>
        </record>

        <record id="action_ir_attachment_google_spreadsheet_tree_view" model="ir.actions.act_window.view">
            <field eval="1" name="sequence"/>
            <field name="view_mode">tree</field>
            <field name="view_id" ref="view_ir_attachment_google_spreadsheet_tree"/>
            <field name="act_window_id" ref="action_ir_attachment_google_spreadsheet_tree"/>
        </record>

        <record id="action_ir_attachment_google_spreadsheet_form_view" model="ir.actions.act_window.view">
            <field eval="2" name="sequence"/>
            <field name="view_mode">form</field>
            <field name="view_id" ref="view_ir_attachment_google_spreadsheet_form"/>
            <field name="act_window_id" ref="action_ir_attachment_google_spreadsheet_tree"/>
        </record>

        <menuitem id="menu_reporting_dashboard_google_spreadsheets" parent="base.menu_reporting_dashboard" action="action_ir_attachment_google_spreadsheet_tree"/>
    </data>
</openerp>