Container.h

/*
     Copyright © CloudBackend AB 2020 - 2023.
*/
 
#ifndef INCLUDE_CBE_CONTAINER_H_
#define INCLUDE_CBE_CONTAINER_H_
 
#include "cbe/Types.h"
#include "cbe/delegate/container/MoveDelegate.h"
#include "cbe/delegate/container/RenameDelegate.h"
#include "cbe/delegate/container/RemoveDelegate.h"
#include "cbe/delegate/AclDelegate.h"
#include "cbe/delegate/CreateContainerDelegate.h"
#include "cbe/delegate/CreateObjectDelegate.h"
#include "cbe/delegate/Error.h"
#include "cbe/delegate/PublishDelegate.h"
#include "cbe/delegate/PublishSuccess.h"
#include "cbe/delegate/ShareDelegate.h"
#include "cbe/delegate/UnPublishDelegate.h"
#include "cbe/delegate/UnShareDelegate.h"
#include "cbe/delegate/UnSubscribeDelegate.h"
#include "cbe/delegate/UploadDelegate.h"
#include "cbe/delegate/QueryDelegate.h"
#include "cbe/delegate/QueryJoinDelegate.h"
 
#ifndef CBE_NO_SYNC
#include "cbe/delegate/ProgressEventFn.h"
#endif
 
#include "cbe/util/Context.h"
#include "cbe/util/ErrorInfo.h"
#include "cbe/util/Exception.h"
#include "cbe/util/Optional.h"
 
#include "cbe/Item.h"
#include "cbe/Object.h"
#include "cbe/Types.h"
 
namespace CBI {
class Container;
using ContainerPtr = std::shared_ptr<CBI::Container>;
class ItemEventProtocol;
using ItemDelegatePtr = std::shared_ptr<ItemEventProtocol>;
} // namespace CBI
 
namespace cbe
{
class QueryChainExt;
class QueryChainSync;
 
namespace delegate {
  class AclDelegate;
  class ShareDelegate;
  class UnShareDelegate;
}
 
class Filter;
 
class Container : public cbe::Item
{
public:
  using CreateContainerDelegatePtr = delegate::CreateContainerDelegatePtr;
  cbe::Container createContainer(const std::string&         name, 
                                 CreateContainerDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using CreateContainerException = delegate::CreateContainerDelegate::Exception;
  cbe::Container createContainer(const std::string& name);
 
  using CreateContainerError = delegate::CreateContainerDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Container> createContainer(
                                              const std::string&    name,
                                              CreateContainerError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using MoveDelegatePtr = delegate::container::MoveDelegatePtr;
  void move(cbe::ContainerId dstId, MoveDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using MoveException = delegate::container::MoveDelegate::Exception;
  cbe::Container move(cbe::ContainerId dstId);
 
  using MoveError = delegate::container::MoveDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Container> move(
                                              cbe::ContainerId     dstId,
                                              MoveError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RenameDelegatePtr = delegate::container::RenameDelegatePtr;
  void rename(const std::string& name, RenameDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using RenameException = delegate::container::RenameDelegate::Exception;
  cbe::Container rename(const std::string& name);
 
  using RenameError = delegate::container::RenameDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Container> rename(const std::string&     name,
                                             RenameError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RemoveDelegatePtr = delegate::container::RemoveDelegatePtr;
  void remove(RemoveDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using RemoveException = delegate::container::RemoveDelegate::Exception;
  delegate::container::RemoveSuccess remove();
 
  using RemoveError = delegate::container::RemoveDelegate::ErrorInfo;
  cbe::util::Optional<delegate::container::RemoveSuccess> remove(
                                                            RemoveError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using CreateObjectDelegatePtr = delegate::CreateObjectDelegatePtr;
  cbe::Object createObject(std::string              name,
                           cbe::KeyValues           keyValues,
                           CreateObjectDelegatePtr  delegate);
  cbe::Object createObject(std::string              name,
                           CreateObjectDelegatePtr  delegate);
 
#ifndef CBE_NO_SYNC
  using CreateObjectException = delegate::CreateObjectDelegate::Exception;
  cbe::Object createObject(std::string              name,
                           cbe::KeyValues           keyValues);
 
  using CreateObjectError = delegate::CreateObjectDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Object> createObject(
                                              std::string              name,
                                              cbe::KeyValues           keyValues,
                                              CreateObjectError&       error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using UploadDelegatePtr = delegate::UploadDelegatePtr;
  cbe::Object upload(const std::string& filePath,
                     UploadDelegatePtr  delegate);
 
  cbe::Object upload(const std::string& name,
                     const std::string& path,
                     UploadDelegatePtr  delegate);
 
  cbe::Object upload(const std::string& name,
                     std::uint64_t      length,
                     const char*        byteData,
                     UploadDelegatePtr  delegate);
#ifndef CBE_NO_SYNC
  using UploadException = delegate::UploadDelegate::Exception;
  cbe::Object upload(
                    const std::string&          filePath,
                    delegate::ProgressEventFn&& progressEventFn);
 
  cbe::Object upload(
                    const std::string& filePath);
 
  cbe::Object upload(
                    const std::string&          name,
                    const std::string&          path,
                    delegate::ProgressEventFn&& progressEventFn);
  cbe::Object upload(
                    const std::string&          name,
                    const std::string&          path);
 
  cbe::Object upload(
                    const std::string&          name,
                    std::uint64_t               length,
                    const char*                 byteData,
                    delegate::ProgressEventFn&& progressEventFn);
  cbe::Object upload(
                    const std::string&          name,
                    std::uint64_t               length,
                    const char*                 byteData);
  using UploadError = delegate::UploadDelegate::ErrorInfo;
 
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          filePath,
                                    delegate::ProgressEventFn&& progressEventFn,
                                    UploadError&                error);
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          filePath,
                                    UploadError&                error);
 
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          name,
                                    const std::string&          path,
                                    delegate::ProgressEventFn&& progressEventFn,
                                    UploadError&                error);
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          name,
                                    const std::string&          path,
                                    UploadError&                error);
 
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          name,
                                    std::uint64_t               length,
                                    const char*                 byteData,
                                    delegate::ProgressEventFn&& progressEventFn,
                                    UploadError&                error);
  cbe::util::Optional<cbe::Object> upload(
                                    const std::string&          name,
                                    std::uint64_t               length,
                                    const char*                 byteData,
                                    UploadError&                error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using QueryDelegatePtr = delegate::QueryDelegatePtr;
  cbe::QueryChain query(QueryDelegatePtr  queryDelegate);
  cbe::QueryChain query(Filter           filter,
                   QueryDelegatePtr delegate);
                   
  using QueryJoinDelegatePtr = std::shared_ptr<delegate::QueryJoinDelegate>;
  cbe::QueryChainExt query(delegate::QueryJoinDelegatePtr delegate);
  cbe::QueryChainExt query(Filter                          filter,
                      delegate::QueryJoinDelegatePtr  delegate);
 
#ifndef CBE_NO_SYNC
  using QueryException = delegate::QueryDelegate::Exception;
  cbe::QueryChainSync query();
  cbe::QueryChainSync query(Filter filter);
 
  using QueryJoinError = delegate::QueryJoinDelegate::ErrorInfo;
 
  cbe::QueryChainSync query(QueryJoinError&  error);
  cbe::QueryChainSync query(Filter           filter,
                       QueryJoinError&  error);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using QueryError = delegate::QueryDelegate::ErrorInfo;
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  cbe::QueryChain queryWithPath(std::string       relativePath,
                                QueryDelegatePtr  delegate);
#ifndef CBE_NO_SYNC
  using queryWithPathException = delegate::QueryDelegate::Exception;
  cbe::QueryResult queryWithPath(std::string relativePath);
 
  using queryWithPathError = delegate::QueryDelegate::ErrorInfo;
  cbe::util::Optional<cbe::QueryResult> queryWithPath(
                                              std::string         relativePath,
                                              queryWithPathError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  cbe::QueryResult search(std::string tags, QueryDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using SearchException = delegate::QueryDelegate::Exception;
  cbe::QueryResult search(std::string tags);
 
  using SearchError = delegate::QueryDelegate::ErrorInfo;
  cbe::util::Optional<cbe::QueryResult> search(std::string  tags,
                                               SearchError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  cbe::QueryResult search(cbe::Filter filter, QueryDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  cbe::QueryResult search(cbe::Filter);
  
  cbe::util::Optional<cbe::QueryResult> search(cbe::Filter  filter,
                                               SearchError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using SetAclDelegatePtr = delegate::AclDelegatePtr;
  void setAcl(cbe::AclMap       aclMap,
              SetAclDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using SetAclException = delegate::AclDelegate::Exception;
  cbe::AclMap setAcl(cbe::AclMap aclMap);
 
  using SetAclError = delegate::AclDelegate::ErrorInfo;
  cbe::util::Optional<cbe::AclMap> setAcl( 
                                                            cbe::AclMap  aclMap,
                                                            SetAclError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using GetAclDelegatePtr = delegate::AclDelegatePtr;
  void getAcl(GetAclDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using GetAclException = delegate::AclDelegate::Exception;
  cbe::AclMap getAcl();
 
  using GetAclError = delegate::AclDelegate::ErrorInfo;
  cbe::util::Optional<cbe::AclMap> getAcl(GetAclError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using ShareDelegatePtr = delegate::ShareDelegatePtr;
  void share(cbe::UserId      toUserGroup,
             std::string      description,
             ShareDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using ShareException = delegate::ShareDelegate::Exception;
  delegate::ShareDelegate::Success share(cbe::UserId      toUserGroup,
                                         std::string      description);
 
  using ShareError = delegate::ShareDelegate::ErrorInfo;
  cbe::util::Optional<delegate::ShareDelegate::Success> share(
                                                    cbe::UserId    toUserGroup,
                                                    std::string    description,
                                                    ShareError&    error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using UnShareDelegatePtr = std::shared_ptr<delegate::UnShareDelegate>;
  void unShare(cbe::ShareId shareId, UnShareDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using UnShareException = delegate::UnShareDelegate::Exception;
  delegate::UnShareDelegate::Success unShare(cbe::ShareId shareId);
 
  using UnShareError = delegate::UnShareDelegate::ErrorInfo;
  cbe::util::Optional<delegate::UnShareDelegate::Success> unShare(
                                                        cbe::ShareId  shareId, 
                                                        UnShareError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using PublishDelegatePtr = delegate::PublishDelegatePtr;
  void publish(cbe::PublishAccess      security,
               cbe::PublishVisibility  privacy,
               std::string             description,
               std::string             password,
               PublishDelegatePtr      delegate);
 
#ifndef CBE_NO_SYNC
  using PublishException = delegate::PublishDelegate::Exception;
  delegate::PublishSuccess publish(cbe::PublishAccess      security,
                                   cbe::PublishVisibility  privacy,
                                   std::string             description,
                                   std::string             password);
 
  using PublishError = delegate::PublishDelegate::ErrorInfo;
  cbe::util::Optional<delegate::PublishSuccess> publish(
                                            cbe::PublishAccess      security,
                                            cbe::PublishVisibility  privacy,
                                            std::string             description,
                                            std::string             password,
                                            PublishError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  using UnPublishDelegatePtr = delegate::UnPublishDelegatePtr;
  void unPublish(UnPublishDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using UnPublishException = delegate::UnPublishDelegate::Exception;
  delegate::UnPublishSuccess unPublish();
 
  using UnPublishError = delegate::UnPublishDelegate::ErrorInfo;
  cbe::util::Optional<delegate::UnPublishSuccess> unPublish(
                                                         UnPublishError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using UnSubscribeDelegatePtr = delegate::UnSubscribeDelegatePtr;
  void unSubscribe(UnSubscribeDelegatePtr delegate);
 
#ifndef CBE_NO_SYNC
  using UnSubscribeException = delegate::UnSubscribeDelegate::Exception;
  delegate::UnSubscribeSuccess unSubscribe();
 
  using UnSubscribeError = delegate::UnSubscribeDelegate::ErrorInfo;
  cbe::util::Optional<delegate::UnSubscribeSuccess> unSubscribe(
                                                        UnSubscribeError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  Container(cbe::DefaultCtor);
private:
  struct Impl;
  Impl& getImpl() const;
 
  friend class Account;
  friend class CloudBackend;
  friend class Database;
  friend class Filter;
  friend class Group;
  friend class QueryChain;
 
  Container(CBI::ContainerPtr cbiPeerPtr);
 // CBI::Container&   getCbiPeer() const;
  CBI::ContainerPtr getCbiPeerPtr() const;
}; // class Container
 
} // namespace cbe
 
#endif // INCLUDE_CBE_CONTAINER_H_