airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/group_manager_model_types.h

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

/**
 * Autogenerated by Thrift Compiler (0.10.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef group_manager_model_TYPES_H
#define group_manager_model_TYPES_H

#include <iosfwd>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/TBase.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/transport/TTransport.h>

#include <thrift/cxxfunctional.h>
#include "airavata_commons_types.h"


namespace apache { namespace airavata { namespace model { namespace group {

struct ResourceType {
  enum type {
    PROJECT = 0,
    EXPERIMENT = 1,
    DATA = 2,
    APPLICATION_DEPLOYMENT = 3,
    GROUP_RESOURCE_PROFILE = 4,
    CREDENTIAL_TOKEN = 5,
    OTHER = 6
  };
};

extern const std::map<int, const char*> _ResourceType_VALUES_TO_NAMES;

struct ResourcePermissionType {
  enum type {
    WRITE = 0,
    READ = 1,
    OWNER = 2,
    MANAGE_SHARING = 3
  };
};

extern const std::map<int, const char*> _ResourcePermissionType_VALUES_TO_NAMES;

class GroupModel;

typedef struct _GroupModel__isset {
  _GroupModel__isset() : id(false), name(false), ownerId(false), description(false), members(false), admins(false) {}
  bool id :1;
  bool name :1;
  bool ownerId :1;
  bool description :1;
  bool members :1;
  bool admins :1;
} _GroupModel__isset;

class GroupModel : public virtual ::apache::thrift::TBase {
 public:

  GroupModel(const GroupModel&);
  GroupModel& operator=(const GroupModel&);
  GroupModel() : id(), name(), ownerId(), description() {
  }

  virtual ~GroupModel() throw();
  std::string id;
  std::string name;
  std::string ownerId;
  std::string description;
  std::vector<std::string>  members;
  std::vector<std::string>  admins;

  _GroupModel__isset __isset;

  void __set_id(const std::string& val);

  void __set_name(const std::string& val);

  void __set_ownerId(const std::string& val);

  void __set_description(const std::string& val);

  void __set_members(const std::vector<std::string> & val);

  void __set_admins(const std::vector<std::string> & val);

  bool operator == (const GroupModel & rhs) const
  {
    if (__isset.id != rhs.__isset.id)
      return false;
    else if (__isset.id && !(id == rhs.id))
      return false;
    if (__isset.name != rhs.__isset.name)
      return false;
    else if (__isset.name && !(name == rhs.name))
      return false;
    if (__isset.ownerId != rhs.__isset.ownerId)
      return false;
    else if (__isset.ownerId && !(ownerId == rhs.ownerId))
      return false;
    if (__isset.description != rhs.__isset.description)
      return false;
    else if (__isset.description && !(description == rhs.description))
      return false;
    if (__isset.members != rhs.__isset.members)
      return false;
    else if (__isset.members && !(members == rhs.members))
      return false;
    if (__isset.admins != rhs.__isset.admins)
      return false;
    else if (__isset.admins && !(admins == rhs.admins))
      return false;
    return true;
  }
  bool operator != (const GroupModel &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const GroupModel & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(GroupModel &a, GroupModel &b);

inline std::ostream& operator<<(std::ostream& out, const GroupModel& obj)
{
  obj.printTo(out);
  return out;
}

}}}} // namespace

#endif