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_DRIVE_H_
#define  GOOGLE_DRIVE_API_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 Drive : public client::JsonCppData {
 public:
  class DriveBackgroundImageFile : public client::JsonCppData {
   public:
    static DriveBackgroundImageFile* New();

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

    explicit DriveBackgroundImageFile(Json::Value* storage);

    virtual ~DriveBackgroundImageFile();

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

    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 DriveBackgroundImageFile&);
  };  // DriveBackgroundImageFile
  class DriveCapabilities : public client::JsonCppData {
   public:
    static DriveCapabilities* New();

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

    explicit DriveCapabilities(Json::Value* storage);

    virtual ~DriveCapabilities();

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

    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_drive_background() const {
      return Storage().isMember("canChangeDriveBackground");
    }

    void clear_can_change_drive_background() {
      MutableStorage()->removeMember("canChangeDriveBackground");
    }


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

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

    bool has_can_change_drive_members_only_restriction() const {
      return Storage().isMember("canChangeDriveMembersOnlyRestriction");
    }

    void clear_can_change_drive_members_only_restriction() {
      MutableStorage()->removeMember("canChangeDriveMembersOnlyRestriction");
    }


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

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

    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_drive() const {
      return Storage().isMember("canDeleteDrive");
    }

    void clear_can_delete_drive() {
      MutableStorage()->removeMember("canDeleteDrive");
    }


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

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

    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_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_drive() const {
      return Storage().isMember("canRenameDrive");
    }

    void clear_can_rename_drive() {
      MutableStorage()->removeMember("canRenameDrive");
    }


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

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

    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 DriveCapabilities&);
  };  // DriveCapabilities
  class DriveRestrictions : public client::JsonCppData {
   public:
    static DriveRestrictions* New();

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

    explicit DriveRestrictions(Json::Value* storage);

    virtual ~DriveRestrictions();

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

    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_drive_members_only() const {
      return Storage().isMember("driveMembersOnly");
    }

    void clear_drive_members_only() {
      MutableStorage()->removeMember("driveMembersOnly");
    }


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

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

   private:
    void operator=(const DriveRestrictions&);
  };  // DriveRestrictions
  static Drive* New();

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

  explicit Drive(Json::Value* storage);

  virtual ~Drive();

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

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

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


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

  DriveBackgroundImageFile mutable_backgroundImageFile() {
    Json::Value* storage = MutableStorage("backgroundImageFile");
    return client::JsonValueToMutableCppValueHelper<DriveBackgroundImageFile >(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 DriveCapabilities get_capabilities() const {
     const Json::Value& storage = Storage("capabilities");
    return client::JsonValueToCppValueHelper<DriveCapabilities >(storage);
  }

  DriveCapabilities mutable_capabilities() {
    Json::Value* storage = MutableStorage("capabilities");
    return client::JsonValueToMutableCppValueHelper<DriveCapabilities >(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_hidden() const {
    return Storage().isMember("hidden");
  }

  void clear_hidden() {
    MutableStorage()->removeMember("hidden");
  }


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

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

  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 DriveRestrictions get_restrictions() const {
     const Json::Value& storage = Storage("restrictions");
    return client::JsonValueToCppValueHelper<DriveRestrictions >(storage);
  }

  DriveRestrictions mutable_restrictions() {
    Json::Value* storage = MutableStorage("restrictions");
    return client::JsonValueToMutableCppValueHelper<DriveRestrictions >(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 Drive&);
};  // Drive
}  // namespace google_drive_api
#endif  // GOOGLE_DRIVE_API_DRIVE_H_