BatchReadOperation.h

 
#pragma once
#include <aws/clouddirectory/CloudDirectory_EXPORTS.h>
#include <aws/clouddirectory/model/BatchGetLinkAttributes.h>
#include <aws/clouddirectory/model/BatchGetObjectAttributes.h>
#include <aws/clouddirectory/model/BatchGetObjectInformation.h>
#include <aws/clouddirectory/model/BatchListAttachedIndices.h>
#include <aws/clouddirectory/model/BatchListIncomingTypedLinks.h>
#include <aws/clouddirectory/model/BatchListIndex.h>
#include <aws/clouddirectory/model/BatchListObjectAttributes.h>
#include <aws/clouddirectory/model/BatchListObjectChildren.h>
#include <aws/clouddirectory/model/BatchListObjectParentPaths.h>
#include <aws/clouddirectory/model/BatchListObjectParents.h>
#include <aws/clouddirectory/model/BatchListObjectPolicies.h>
#include <aws/clouddirectory/model/BatchListOutgoingTypedLinks.h>
#include <aws/clouddirectory/model/BatchListPolicyAttachments.h>
#include <aws/clouddirectory/model/BatchLookupPolicy.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CloudDirectory {
namespace Model {
 
class BatchReadOperation {
 public:
  AWS_CLOUDDIRECTORY_API BatchReadOperation() = default;
  AWS_CLOUDDIRECTORY_API BatchReadOperation(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDDIRECTORY_API BatchReadOperation& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDDIRECTORY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const BatchListObjectAttributes& GetListObjectAttributes() const { return m_listObjectAttributes; }
  inline bool ListObjectAttributesHasBeenSet() const { return m_listObjectAttributesHasBeenSet; }
  template <typename ListObjectAttributesT = BatchListObjectAttributes>
  void SetListObjectAttributes(ListObjectAttributesT&& value) {
    m_listObjectAttributesHasBeenSet = true;
    m_listObjectAttributes = std::forward<ListObjectAttributesT>(value);
  }
  template <typename ListObjectAttributesT = BatchListObjectAttributes>
  BatchReadOperation& WithListObjectAttributes(ListObjectAttributesT&& value) {
    SetListObjectAttributes(std::forward<ListObjectAttributesT>(value));
    return *this;
  }
 
 
  inline const BatchListObjectChildren& GetListObjectChildren() const { return m_listObjectChildren; }
  inline bool ListObjectChildrenHasBeenSet() const { return m_listObjectChildrenHasBeenSet; }
  template <typename ListObjectChildrenT = BatchListObjectChildren>
  void SetListObjectChildren(ListObjectChildrenT&& value) {
    m_listObjectChildrenHasBeenSet = true;
    m_listObjectChildren = std::forward<ListObjectChildrenT>(value);
  }
  template <typename ListObjectChildrenT = BatchListObjectChildren>
  BatchReadOperation& WithListObjectChildren(ListObjectChildrenT&& value) {
    SetListObjectChildren(std::forward<ListObjectChildrenT>(value));
    return *this;
  }
 
 
  inline const BatchListAttachedIndices& GetListAttachedIndices() const { return m_listAttachedIndices; }
  inline bool ListAttachedIndicesHasBeenSet() const { return m_listAttachedIndicesHasBeenSet; }
  template <typename ListAttachedIndicesT = BatchListAttachedIndices>
  void SetListAttachedIndices(ListAttachedIndicesT&& value) {
    m_listAttachedIndicesHasBeenSet = true;
    m_listAttachedIndices = std::forward<ListAttachedIndicesT>(value);
  }
  template <typename ListAttachedIndicesT = BatchListAttachedIndices>
  BatchReadOperation& WithListAttachedIndices(ListAttachedIndicesT&& value) {
    SetListAttachedIndices(std::forward<ListAttachedIndicesT>(value));
    return *this;
  }
 
 
  inline const BatchListObjectParentPaths& GetListObjectParentPaths() const { return m_listObjectParentPaths; }
  inline bool ListObjectParentPathsHasBeenSet() const { return m_listObjectParentPathsHasBeenSet; }
  template <typename ListObjectParentPathsT = BatchListObjectParentPaths>
  void SetListObjectParentPaths(ListObjectParentPathsT&& value) {
    m_listObjectParentPathsHasBeenSet = true;
    m_listObjectParentPaths = std::forward<ListObjectParentPathsT>(value);
  }
  template <typename ListObjectParentPathsT = BatchListObjectParentPaths>
  BatchReadOperation& WithListObjectParentPaths(ListObjectParentPathsT&& value) {
    SetListObjectParentPaths(std::forward<ListObjectParentPathsT>(value));
    return *this;
  }
 
 
  inline const BatchGetObjectInformation& GetGetObjectInformation() const { return m_getObjectInformation; }
  inline bool GetObjectInformationHasBeenSet() const { return m_getObjectInformationHasBeenSet; }
  template <typename GetObjectInformationT = BatchGetObjectInformation>
  void SetGetObjectInformation(GetObjectInformationT&& value) {
    m_getObjectInformationHasBeenSet = true;
    m_getObjectInformation = std::forward<GetObjectInformationT>(value);
  }
  template <typename GetObjectInformationT = BatchGetObjectInformation>
  BatchReadOperation& WithGetObjectInformation(GetObjectInformationT&& value) {
    SetGetObjectInformation(std::forward<GetObjectInformationT>(value));
    return *this;
  }
 
 
  inline const BatchGetObjectAttributes& GetGetObjectAttributes() const { return m_getObjectAttributes; }
  inline bool GetObjectAttributesHasBeenSet() const { return m_getObjectAttributesHasBeenSet; }
  template <typename GetObjectAttributesT = BatchGetObjectAttributes>
  void SetGetObjectAttributes(GetObjectAttributesT&& value) {
    m_getObjectAttributesHasBeenSet = true;
    m_getObjectAttributes = std::forward<GetObjectAttributesT>(value);
  }
  template <typename GetObjectAttributesT = BatchGetObjectAttributes>
  BatchReadOperation& WithGetObjectAttributes(GetObjectAttributesT&& value) {
    SetGetObjectAttributes(std::forward<GetObjectAttributesT>(value));
    return *this;
  }
 
 
  inline const BatchListObjectParents& GetListObjectParents() const { return m_listObjectParents; }
  inline bool ListObjectParentsHasBeenSet() const { return m_listObjectParentsHasBeenSet; }
  template <typename ListObjectParentsT = BatchListObjectParents>
  void SetListObjectParents(ListObjectParentsT&& value) {
    m_listObjectParentsHasBeenSet = true;
    m_listObjectParents = std::forward<ListObjectParentsT>(value);
  }
  template <typename ListObjectParentsT = BatchListObjectParents>
  BatchReadOperation& WithListObjectParents(ListObjectParentsT&& value) {
    SetListObjectParents(std::forward<ListObjectParentsT>(value));
    return *this;
  }
 
 
  inline const BatchListObjectPolicies& GetListObjectPolicies() const { return m_listObjectPolicies; }
  inline bool ListObjectPoliciesHasBeenSet() const { return m_listObjectPoliciesHasBeenSet; }
  template <typename ListObjectPoliciesT = BatchListObjectPolicies>
  void SetListObjectPolicies(ListObjectPoliciesT&& value) {
    m_listObjectPoliciesHasBeenSet = true;
    m_listObjectPolicies = std::forward<ListObjectPoliciesT>(value);
  }
  template <typename ListObjectPoliciesT = BatchListObjectPolicies>
  BatchReadOperation& WithListObjectPolicies(ListObjectPoliciesT&& value) {
    SetListObjectPolicies(std::forward<ListObjectPoliciesT>(value));
    return *this;
  }
 
 
  inline const BatchListPolicyAttachments& GetListPolicyAttachments() const { return m_listPolicyAttachments; }
  inline bool ListPolicyAttachmentsHasBeenSet() const { return m_listPolicyAttachmentsHasBeenSet; }
  template <typename ListPolicyAttachmentsT = BatchListPolicyAttachments>
  void SetListPolicyAttachments(ListPolicyAttachmentsT&& value) {
    m_listPolicyAttachmentsHasBeenSet = true;
    m_listPolicyAttachments = std::forward<ListPolicyAttachmentsT>(value);
  }
  template <typename ListPolicyAttachmentsT = BatchListPolicyAttachments>
  BatchReadOperation& WithListPolicyAttachments(ListPolicyAttachmentsT&& value) {
    SetListPolicyAttachments(std::forward<ListPolicyAttachmentsT>(value));
    return *this;
  }
 
 
  inline const BatchLookupPolicy& GetLookupPolicy() const { return m_lookupPolicy; }
  inline bool LookupPolicyHasBeenSet() const { return m_lookupPolicyHasBeenSet; }
  template <typename LookupPolicyT = BatchLookupPolicy>
  void SetLookupPolicy(LookupPolicyT&& value) {
    m_lookupPolicyHasBeenSet = true;
    m_lookupPolicy = std::forward<LookupPolicyT>(value);
  }
  template <typename LookupPolicyT = BatchLookupPolicy>
  BatchReadOperation& WithLookupPolicy(LookupPolicyT&& value) {
    SetLookupPolicy(std::forward<LookupPolicyT>(value));
    return *this;
  }
 
 
  inline const BatchListIndex& GetListIndex() const { return m_listIndex; }
  inline bool ListIndexHasBeenSet() const { return m_listIndexHasBeenSet; }
  template <typename ListIndexT = BatchListIndex>
  void SetListIndex(ListIndexT&& value) {
    m_listIndexHasBeenSet = true;
    m_listIndex = std::forward<ListIndexT>(value);
  }
  template <typename ListIndexT = BatchListIndex>
  BatchReadOperation& WithListIndex(ListIndexT&& value) {
    SetListIndex(std::forward<ListIndexT>(value));
    return *this;
  }
 
 
  inline const BatchListOutgoingTypedLinks& GetListOutgoingTypedLinks() const { return m_listOutgoingTypedLinks; }
  inline bool ListOutgoingTypedLinksHasBeenSet() const { return m_listOutgoingTypedLinksHasBeenSet; }
  template <typename ListOutgoingTypedLinksT = BatchListOutgoingTypedLinks>
  void SetListOutgoingTypedLinks(ListOutgoingTypedLinksT&& value) {
    m_listOutgoingTypedLinksHasBeenSet = true;
    m_listOutgoingTypedLinks = std::forward<ListOutgoingTypedLinksT>(value);
  }
  template <typename ListOutgoingTypedLinksT = BatchListOutgoingTypedLinks>
  BatchReadOperation& WithListOutgoingTypedLinks(ListOutgoingTypedLinksT&& value) {
    SetListOutgoingTypedLinks(std::forward<ListOutgoingTypedLinksT>(value));
    return *this;
  }
 
 
  inline const BatchListIncomingTypedLinks& GetListIncomingTypedLinks() const { return m_listIncomingTypedLinks; }
  inline bool ListIncomingTypedLinksHasBeenSet() const { return m_listIncomingTypedLinksHasBeenSet; }
  template <typename ListIncomingTypedLinksT = BatchListIncomingTypedLinks>
  void SetListIncomingTypedLinks(ListIncomingTypedLinksT&& value) {
    m_listIncomingTypedLinksHasBeenSet = true;
    m_listIncomingTypedLinks = std::forward<ListIncomingTypedLinksT>(value);
  }
  template <typename ListIncomingTypedLinksT = BatchListIncomingTypedLinks>
  BatchReadOperation& WithListIncomingTypedLinks(ListIncomingTypedLinksT&& value) {
    SetListIncomingTypedLinks(std::forward<ListIncomingTypedLinksT>(value));
    return *this;
  }
 
 
  inline const BatchGetLinkAttributes& GetGetLinkAttributes() const { return m_getLinkAttributes; }
  inline bool GetLinkAttributesHasBeenSet() const { return m_getLinkAttributesHasBeenSet; }
  template <typename GetLinkAttributesT = BatchGetLinkAttributes>
  void SetGetLinkAttributes(GetLinkAttributesT&& value) {
    m_getLinkAttributesHasBeenSet = true;
    m_getLinkAttributes = std::forward<GetLinkAttributesT>(value);
  }
  template <typename GetLinkAttributesT = BatchGetLinkAttributes>
  BatchReadOperation& WithGetLinkAttributes(GetLinkAttributesT&& value) {
    SetGetLinkAttributes(std::forward<GetLinkAttributesT>(value));
    return *this;
  }
 private:
  BatchListObjectAttributes m_listObjectAttributes;
 
  BatchListObjectChildren m_listObjectChildren;
 
  BatchListAttachedIndices m_listAttachedIndices;
 
  BatchListObjectParentPaths m_listObjectParentPaths;
 
  BatchGetObjectInformation m_getObjectInformation;
 
  BatchGetObjectAttributes m_getObjectAttributes;
 
  BatchListObjectParents m_listObjectParents;
 
  BatchListObjectPolicies m_listObjectPolicies;
 
  BatchListPolicyAttachments m_listPolicyAttachments;
 
  BatchLookupPolicy m_lookupPolicy;
 
  BatchListIndex m_listIndex;
 
  BatchListOutgoingTypedLinks m_listOutgoingTypedLinks;
 
  BatchListIncomingTypedLinks m_listIncomingTypedLinks;
 
  BatchGetLinkAttributes m_getLinkAttributes;
  bool m_listObjectAttributesHasBeenSet = false;
  bool m_listObjectChildrenHasBeenSet = false;
  bool m_listAttachedIndicesHasBeenSet = false;
  bool m_listObjectParentPathsHasBeenSet = false;
  bool m_getObjectInformationHasBeenSet = false;
  bool m_getObjectAttributesHasBeenSet = false;
  bool m_listObjectParentsHasBeenSet = false;
  bool m_listObjectPoliciesHasBeenSet = false;
  bool m_listPolicyAttachmentsHasBeenSet = false;
  bool m_lookupPolicyHasBeenSet = false;
  bool m_listIndexHasBeenSet = false;
  bool m_listOutgoingTypedLinksHasBeenSet = false;
  bool m_listIncomingTypedLinksHasBeenSet = false;
  bool m_getLinkAttributesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudDirectory
}  // namespace Aws