team_drive.h

// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

// This code was generated by google-apis-code-generator 1.5.1
//   Build date: 2018-10-08 17:45:39 UTC
//   on: 2020-03-19, 05:24:40 UTC
//   C++ generator version: 0.1.4

// ----------------------------------------------------------------------------
// NOTE: This file is generated from Google APIs Discovery Service.
// Service:
//   Drive API (drive/v2)
// Generated from:
//   Version: v2
//   Revision: 393
// Generated by:
//    Tool: google-apis-code-generator 1.5.1
//     C++: 0.1.4
#ifndef  GOOGLE_DRIVE_API_TEAM_DRIVE_H_
#define  GOOGLE_DRIVE_API_TEAM_DRIVE_H_

#include <string>
#include "googleapis/base/macros.h"
#include "googleapis/client/data/jsoncpp_data.h"
#include "googleapis/client/util/date_time.h"
#include "googleapis/strings/stringpiece.h"

namespace Json {
class Value;
}  // namespace Json

namespace google_drive_api {
using namespace googleapis;

class TeamDrive : public client::JsonCppData {
 public:
  class TeamDriveBackgroundImageFile : public client::JsonCppData {
   public:
    static TeamDriveBackgroundImageFile* New();

    explicit TeamDriveBackgroundImageFile(const Json::Value& storage);

    explicit TeamDriveBackgroundImageFile(Json::Value* storage);

    virtual ~TeamDriveBackgroundImageFile();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::TeamDriveBackgroundImageFile");
    }

    bool has_id() const {
      return Storage().isMember("id");
    }

    void clear_id() {
      MutableStorage()->removeMember("id");
    }


    const StringPiece get_id() const {
      const Json::Value& v = Storage("id");
      if (v == Json::Value::null) return StringPiece("");
      return StringPiece(v.asCString());
    }

    void set_id(const StringPiece& value) {
      *MutableStorage("id") = value.data();
    }

    bool has_width() const {
      return Storage().isMember("width");
    }

    void clear_width() {
      MutableStorage()->removeMember("width");
    }


    float get_width() const {
      const Json::Value& storage = Storage("width");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_width(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("width"));
    }

    bool has_x_coordinate() const {
      return Storage().isMember("xCoordinate");
    }

    void clear_x_coordinate() {
      MutableStorage()->removeMember("xCoordinate");
    }


    float get_x_coordinate() const {
      const Json::Value& storage = Storage("xCoordinate");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_x_coordinate(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("xCoordinate"));
    }

    bool has_y_coordinate() const {
      return Storage().isMember("yCoordinate");
    }

    void clear_y_coordinate() {
      MutableStorage()->removeMember("yCoordinate");
    }


    float get_y_coordinate() const {
      const Json::Value& storage = Storage("yCoordinate");
      return client::JsonValueToCppValueHelper<float >(storage);
    }

    void set_y_coordinate(float value) {
      client::SetJsonValueFromCppValueHelper<float >(
        value, MutableStorage("yCoordinate"));
    }

   private:
    void operator=(const TeamDriveBackgroundImageFile&);
  };  // TeamDriveBackgroundImageFile
  class TeamDriveCapabilities : public client::JsonCppData {
   public:
    static TeamDriveCapabilities* New();

    explicit TeamDriveCapabilities(const Json::Value& storage);

    explicit TeamDriveCapabilities(Json::Value* storage);

    virtual ~TeamDriveCapabilities();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::TeamDriveCapabilities");
    }

    bool has_can_add_children() const {
      return Storage().isMember("canAddChildren");
    }

    void clear_can_add_children() {
      MutableStorage()->removeMember("canAddChildren");
    }


    bool get_can_add_children() const {
      const Json::Value& storage = Storage("canAddChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_add_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canAddChildren"));
    }

    bool has_can_change_copy_requires_writer_permission_restriction() const {
      return Storage().isMember("canChangeCopyRequiresWriterPermissionRestriction");
    }

    void clear_can_change_copy_requires_writer_permission_restriction() {
      MutableStorage()->removeMember("canChangeCopyRequiresWriterPermissionRestriction");
    }


    bool get_can_change_copy_requires_writer_permission_restriction() const {
      const Json::Value& storage = Storage("canChangeCopyRequiresWriterPermissionRestriction");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_copy_requires_writer_permission_restriction(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeCopyRequiresWriterPermissionRestriction"));
    }

    bool has_can_change_domain_users_only_restriction() const {
      return Storage().isMember("canChangeDomainUsersOnlyRestriction");
    }

    void clear_can_change_domain_users_only_restriction() {
      MutableStorage()->removeMember("canChangeDomainUsersOnlyRestriction");
    }


    bool get_can_change_domain_users_only_restriction() const {
      const Json::Value& storage = Storage("canChangeDomainUsersOnlyRestriction");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_domain_users_only_restriction(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeDomainUsersOnlyRestriction"));
    }

    bool has_can_change_team_drive_background() const {
      return Storage().isMember("canChangeTeamDriveBackground");
    }

    void clear_can_change_team_drive_background() {
      MutableStorage()->removeMember("canChangeTeamDriveBackground");
    }


    bool get_can_change_team_drive_background() const {
      const Json::Value& storage = Storage("canChangeTeamDriveBackground");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_team_drive_background(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeTeamDriveBackground"));
    }

    bool has_can_change_team_members_only_restriction() const {
      return Storage().isMember("canChangeTeamMembersOnlyRestriction");
    }

    void clear_can_change_team_members_only_restriction() {
      MutableStorage()->removeMember("canChangeTeamMembersOnlyRestriction");
    }


    bool get_can_change_team_members_only_restriction() const {
      const Json::Value& storage = Storage("canChangeTeamMembersOnlyRestriction");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_change_team_members_only_restriction(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canChangeTeamMembersOnlyRestriction"));
    }

    bool has_can_comment() const {
      return Storage().isMember("canComment");
    }

    void clear_can_comment() {
      MutableStorage()->removeMember("canComment");
    }


    bool get_can_comment() const {
      const Json::Value& storage = Storage("canComment");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_comment(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canComment"));
    }

    bool has_can_copy() const {
      return Storage().isMember("canCopy");
    }

    void clear_can_copy() {
      MutableStorage()->removeMember("canCopy");
    }


    bool get_can_copy() const {
      const Json::Value& storage = Storage("canCopy");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_copy(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canCopy"));
    }

    bool has_can_delete_children() const {
      return Storage().isMember("canDeleteChildren");
    }

    void clear_can_delete_children() {
      MutableStorage()->removeMember("canDeleteChildren");
    }


    bool get_can_delete_children() const {
      const Json::Value& storage = Storage("canDeleteChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_delete_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDeleteChildren"));
    }

    bool has_can_delete_team_drive() const {
      return Storage().isMember("canDeleteTeamDrive");
    }

    void clear_can_delete_team_drive() {
      MutableStorage()->removeMember("canDeleteTeamDrive");
    }


    bool get_can_delete_team_drive() const {
      const Json::Value& storage = Storage("canDeleteTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_delete_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDeleteTeamDrive"));
    }

    bool has_can_download() const {
      return Storage().isMember("canDownload");
    }

    void clear_can_download() {
      MutableStorage()->removeMember("canDownload");
    }


    bool get_can_download() const {
      const Json::Value& storage = Storage("canDownload");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_download(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canDownload"));
    }

    bool has_can_edit() const {
      return Storage().isMember("canEdit");
    }

    void clear_can_edit() {
      MutableStorage()->removeMember("canEdit");
    }


    bool get_can_edit() const {
      const Json::Value& storage = Storage("canEdit");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_edit(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canEdit"));
    }

    bool has_can_list_children() const {
      return Storage().isMember("canListChildren");
    }

    void clear_can_list_children() {
      MutableStorage()->removeMember("canListChildren");
    }


    bool get_can_list_children() const {
      const Json::Value& storage = Storage("canListChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_list_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canListChildren"));
    }

    bool has_can_manage_members() const {
      return Storage().isMember("canManageMembers");
    }

    void clear_can_manage_members() {
      MutableStorage()->removeMember("canManageMembers");
    }


    bool get_can_manage_members() const {
      const Json::Value& storage = Storage("canManageMembers");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_manage_members(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canManageMembers"));
    }

    bool has_can_read_revisions() const {
      return Storage().isMember("canReadRevisions");
    }

    void clear_can_read_revisions() {
      MutableStorage()->removeMember("canReadRevisions");
    }


    bool get_can_read_revisions() const {
      const Json::Value& storage = Storage("canReadRevisions");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_read_revisions(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canReadRevisions"));
    }

    bool has_can_remove_children() const {
      return Storage().isMember("canRemoveChildren");
    }

    void clear_can_remove_children() {
      MutableStorage()->removeMember("canRemoveChildren");
    }


    bool get_can_remove_children() const {
      const Json::Value& storage = Storage("canRemoveChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_remove_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRemoveChildren"));
    }

    bool has_can_rename() const {
      return Storage().isMember("canRename");
    }

    void clear_can_rename() {
      MutableStorage()->removeMember("canRename");
    }


    bool get_can_rename() const {
      const Json::Value& storage = Storage("canRename");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_rename(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRename"));
    }

    bool has_can_rename_team_drive() const {
      return Storage().isMember("canRenameTeamDrive");
    }

    void clear_can_rename_team_drive() {
      MutableStorage()->removeMember("canRenameTeamDrive");
    }


    bool get_can_rename_team_drive() const {
      const Json::Value& storage = Storage("canRenameTeamDrive");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_rename_team_drive(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canRenameTeamDrive"));
    }

    bool has_can_share() const {
      return Storage().isMember("canShare");
    }

    void clear_can_share() {
      MutableStorage()->removeMember("canShare");
    }


    bool get_can_share() const {
      const Json::Value& storage = Storage("canShare");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_share(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canShare"));
    }

    bool has_can_trash_children() const {
      return Storage().isMember("canTrashChildren");
    }

    void clear_can_trash_children() {
      MutableStorage()->removeMember("canTrashChildren");
    }


    bool get_can_trash_children() const {
      const Json::Value& storage = Storage("canTrashChildren");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_can_trash_children(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("canTrashChildren"));
    }

   private:
    void operator=(const TeamDriveCapabilities&);
  };  // TeamDriveCapabilities
  class TeamDriveRestrictions : public client::JsonCppData {
   public:
    static TeamDriveRestrictions* New();

    explicit TeamDriveRestrictions(const Json::Value& storage);

    explicit TeamDriveRestrictions(Json::Value* storage);

    virtual ~TeamDriveRestrictions();

    const StringPiece GetTypeName() const {
      return StringPiece("google_drive_api::TeamDriveRestrictions");
    }

    bool has_admin_managed_restrictions() const {
      return Storage().isMember("adminManagedRestrictions");
    }

    void clear_admin_managed_restrictions() {
      MutableStorage()->removeMember("adminManagedRestrictions");
    }


    bool get_admin_managed_restrictions() const {
      const Json::Value& storage = Storage("adminManagedRestrictions");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_admin_managed_restrictions(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("adminManagedRestrictions"));
    }

    bool has_copy_requires_writer_permission() const {
      return Storage().isMember("copyRequiresWriterPermission");
    }

    void clear_copy_requires_writer_permission() {
      MutableStorage()->removeMember("copyRequiresWriterPermission");
    }


    bool get_copy_requires_writer_permission() const {
      const Json::Value& storage = Storage("copyRequiresWriterPermission");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_copy_requires_writer_permission(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("copyRequiresWriterPermission"));
    }

    bool has_domain_users_only() const {
      return Storage().isMember("domainUsersOnly");
    }

    void clear_domain_users_only() {
      MutableStorage()->removeMember("domainUsersOnly");
    }


    bool get_domain_users_only() const {
      const Json::Value& storage = Storage("domainUsersOnly");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_domain_users_only(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("domainUsersOnly"));
    }

    bool has_team_members_only() const {
      return Storage().isMember("teamMembersOnly");
    }

    void clear_team_members_only() {
      MutableStorage()->removeMember("teamMembersOnly");
    }


    bool get_team_members_only() const {
      const Json::Value& storage = Storage("teamMembersOnly");
      return client::JsonValueToCppValueHelper<bool >(storage);
    }

    void set_team_members_only(bool value) {
      client::SetJsonValueFromCppValueHelper<bool >(
        value, MutableStorage("teamMembersOnly"));
    }

   private:
    void operator=(const TeamDriveRestrictions&);
  };  // TeamDriveRestrictions
  static TeamDrive* New();

  explicit TeamDrive(const Json::Value& storage);

  explicit TeamDrive(Json::Value* storage);

  virtual ~TeamDrive();

  const StringPiece GetTypeName() const {
    return StringPiece("google_drive_api::TeamDrive");
  }

  bool has_background_image_file() const {
    return Storage().isMember("backgroundImageFile");
  }

  void clear_background_image_file() {
    MutableStorage()->removeMember("backgroundImageFile");
  }


  const TeamDriveBackgroundImageFile get_background_image_file() const {
     const Json::Value& storage = Storage("backgroundImageFile");
    return client::JsonValueToCppValueHelper<TeamDriveBackgroundImageFile >(storage);
  }

  TeamDriveBackgroundImageFile mutable_backgroundImageFile() {
    Json::Value* storage = MutableStorage("backgroundImageFile");
    return client::JsonValueToMutableCppValueHelper<TeamDriveBackgroundImageFile >(storage);
  }

  bool has_background_image_link() const {
    return Storage().isMember("backgroundImageLink");
  }

  void clear_background_image_link() {
    MutableStorage()->removeMember("backgroundImageLink");
  }


  const StringPiece get_background_image_link() const {
    const Json::Value& v = Storage("backgroundImageLink");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_background_image_link(const StringPiece& value) {
    *MutableStorage("backgroundImageLink") = value.data();
  }

  bool has_capabilities() const {
    return Storage().isMember("capabilities");
  }

  void clear_capabilities() {
    MutableStorage()->removeMember("capabilities");
  }


  const TeamDriveCapabilities get_capabilities() const {
     const Json::Value& storage = Storage("capabilities");
    return client::JsonValueToCppValueHelper<TeamDriveCapabilities >(storage);
  }

  TeamDriveCapabilities mutable_capabilities() {
    Json::Value* storage = MutableStorage("capabilities");
    return client::JsonValueToMutableCppValueHelper<TeamDriveCapabilities >(storage);
  }

  bool has_color_rgb() const {
    return Storage().isMember("colorRgb");
  }

  void clear_color_rgb() {
    MutableStorage()->removeMember("colorRgb");
  }


  const StringPiece get_color_rgb() const {
    const Json::Value& v = Storage("colorRgb");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_color_rgb(const StringPiece& value) {
    *MutableStorage("colorRgb") = value.data();
  }

  bool has_created_date() const {
    return Storage().isMember("createdDate");
  }

  void clear_created_date() {
    MutableStorage()->removeMember("createdDate");
  }


  client::DateTime get_created_date() const {
    const Json::Value& storage = Storage("createdDate");
    return client::JsonValueToCppValueHelper<client::DateTime >(storage);
  }

  void set_created_date(client::DateTime value) {
    client::SetJsonValueFromCppValueHelper<client::DateTime >(
      value, MutableStorage("createdDate"));
  }

  bool has_id() const {
    return Storage().isMember("id");
  }

  void clear_id() {
    MutableStorage()->removeMember("id");
  }


  const StringPiece get_id() const {
    const Json::Value& v = Storage("id");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_id(const StringPiece& value) {
    *MutableStorage("id") = value.data();
  }

  bool has_kind() const {
    return Storage().isMember("kind");
  }

  void clear_kind() {
    MutableStorage()->removeMember("kind");
  }


  const StringPiece get_kind() const {
    const Json::Value& v = Storage("kind");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_kind(const StringPiece& value) {
    *MutableStorage("kind") = value.data();
  }

  bool has_name() const {
    return Storage().isMember("name");
  }

  void clear_name() {
    MutableStorage()->removeMember("name");
  }


  const StringPiece get_name() const {
    const Json::Value& v = Storage("name");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_name(const StringPiece& value) {
    *MutableStorage("name") = value.data();
  }

  bool has_restrictions() const {
    return Storage().isMember("restrictions");
  }

  void clear_restrictions() {
    MutableStorage()->removeMember("restrictions");
  }


  const TeamDriveRestrictions get_restrictions() const {
     const Json::Value& storage = Storage("restrictions");
    return client::JsonValueToCppValueHelper<TeamDriveRestrictions >(storage);
  }

  TeamDriveRestrictions mutable_restrictions() {
    Json::Value* storage = MutableStorage("restrictions");
    return client::JsonValueToMutableCppValueHelper<TeamDriveRestrictions >(storage);
  }

  bool has_theme_id() const {
    return Storage().isMember("themeId");
  }

  void clear_theme_id() {
    MutableStorage()->removeMember("themeId");
  }


  const StringPiece get_theme_id() const {
    const Json::Value& v = Storage("themeId");
    if (v == Json::Value::null) return StringPiece("");
    return StringPiece(v.asCString());
  }

  void set_theme_id(const StringPiece& value) {
    *MutableStorage("themeId") = value.data();
  }

 private:
  void operator=(const TeamDrive&);
};  // TeamDrive
}  // namespace google_drive_api
#endif  // GOOGLE_DRIVE_API_TEAM_DRIVE_H_