Types.h

/*
  SDK type definitions.
  Copyright © CloudBackend AB 2020 - 2025.
*/
#ifndef INCLUDE_CBE_TYPES_H_
#define INCLUDE_CBE_TYPES_H_
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace cbe {
 
  class Account;
  class CloudBackend;
  class Container;
  class Database;
  class Filter;
  class Group;
  class GroupFilter;
  class GroupManager;
  class GroupQueryResult;
  class Item;
  class Member;
  class Object;
  class Publish;
  class PublishManager;
  class QueryChain;
  class QueryChainSync;
  class QueryResult;
  class Role;
  class ShareManager;
  class Stream;
  class Subscribe;
  class SubscribeManager;
 
  // Type definitions for ids, enums, settings and failure codes
 
  using AclGroupId  = std::uint64_t;
  using ContainerId = std::uint64_t;
  using DatabaseId  = std::uint64_t;
  using Date        = std::uint64_t;
  using GroupId     = std::uint64_t;
  using ItemId      = std::uint64_t;
  using MemberId    = std::uint64_t;
  using ListenerHandle = std::uint64_t;
  using ObjectId    = std::uint64_t;
  using PublishId   = std::uint64_t;
  using RoleId      = std::uint64_t;
  using ShareId     = std::uint64_t;
  using StreamId    = std::uint64_t;
  using SubscribeId = std::uint64_t;
  using UserId      = std::uint64_t;
 
  using account_status_t      = std::uint32_t;
  using failed_status_t       = std::uint32_t;
  using http_t                = std::uint32_t;
  using publish_access_t      = std::uint32_t;
  using publish_visibility_t  = std::uint32_t;
  using sync_direction_t      = std::uint32_t;
  using sync_status_t         = std::uint32_t;
  using transfer_t            = std::uint32_t;
  using ErrorCode             = std::uint32_t;
 
  using application_t         = int;
  using item_t                = int;
  using object_t              = int;
  using permission_status_t   = int;
  using stream_t              = int;
  using visibility            = int;
 
 
  enum class AccountStatus : cbe::account_status_t {
    NotLoggedIn = 1,
    LoggedIn    = 2,
    Failed      = 3
  };
 
  enum class AclScope : uint64_t {
    User = 1,
    Group = 2,
    Role = 3,
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  enum class ApplicationType : application_t {
    Open   = 1,
    Invite = 2,
    Review = 3,
    Closed = 4
  };
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
  enum DefaultCtor {};
 
  enum class FilterOrder : uint32_t {
    Title     = 1,
    Relevance = 2,    //Note* group Searches does not use Relevance as order.
    Published = 3,
    Updated   = 4,
    Length    = 5,
    S1        = 6,
    S2        = 7,
    S3        = 8,
    S4        = 9
  };
 
  enum class ItemType : cbe::item_t  {
    Unapplicable =  1,
    Unknown      =  2,
    Object       =  4,
    Container    =  8,
    Tag          = 16,
    Group        = 32
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  enum class HttpType : http_t {
    GET    = 1,
    POST   = 2,
    PUT    = 3,
    DELETE = 4,
    HEAD   = 5
  };
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
  enum class ObjectType : object_t {
    Other        = 1,
    GroupInvites = 2,
    ShareInvite  = 3
  };
 
  enum class Permissions : permission_status_t
  {
    Read                 = 1,
    Write                = 2,
    ReadWrite            = 3,
    Delete               = 4,
    ReadDelete           = 5,
    WriteDelete          = 6,
    ReadWriteDelete      = 7,
    ChangeACL            = 8,
    ReadChangeACL        = 9,
    WriteChangeACL       = 10,
    ReadWriteChangeACL   = 11,
    DeleteChangeACL      = 12,
    ReadDeleteChangeACL  = 13,
    WriteDeleteChangeACL = 14,
    AllPermissions       = 15,
    NoPermissions        = 0
  };
 
  enum class PublishAccess : cbe::publish_access_t {
    Read   = 1,
    Update = 2,
    Create = 3
  };
 
  enum class PublishVisibility : cbe::publish_visibility_t {
    Public  = 1,
    Friends = 2,
    Private = 3,
    Invited = 4
  };
 
  enum class Visibility : visibility {
    Public  = 1,
    Private = 2
  }; 
 
 
  using AclMap = std::map<cbe::AclGroupId, std::pair<cbe::Permissions, AclScope>>;
 
  using DataBases = std::map<std::string, cbe::Database>;
 
  using Items = std::vector<cbe::Item>;
 
  using KeyValues = std::map<std::string, std::pair<std::string, bool>>;
 
  using MemberBanInfo = std::map<std::pair<cbe::MemberId, cbe::MemberId>,
                                 std::pair<cbe::Date, std::string>>;
 
  struct ShareData;
  using ShareIds = std::map<cbe::ShareId, std::vector<cbe::ShareData>>;
 
 
 
 
  namespace delegate {
    namespace container {
    } // namespace container
    namespace group {
    } // namespace group
    namespace object {
    } // namespace object
  } // namespace delegate
 
  namespace util {}
 
}// namespace cbe
 
#endif // INCLUDE_CBE_TYPES_H_