Object.h

/*
     Copyright © CloudBackend AB 2020-2023.
*/
 
#ifndef INCLUDE_CBE_OBJECT_H_
#define INCLUDE_CBE_OBJECT_H_
 
#include "cbe/Item.h"
#include "cbe/Stream.h"
#include "cbe/Types.h"
 
#include "cbe/delegate/AclDelegate.h"
#include "cbe/delegate/DownloadBinaryDelegate.h"
#include "cbe/delegate/DownloadDelegate.h"
#include "cbe/delegate/GetStreamsDelegate.h"
#include "cbe/delegate/object/MoveDelegate.h"
#include "cbe/delegate/object/RemoveDelegate.h"
#include "cbe/delegate/object/RenameDelegate.h"
#include "cbe/delegate/PublishDelegate.h"
#include "cbe/delegate/ShareDelegate.h"
#include "cbe/delegate/UnPublishDelegate.h"
#include "cbe/delegate/UnShareDelegate.h"
#include "cbe/delegate/UnSubscribeDelegate.h"
#include "cbe/delegate/UpdateKeyValuesDelegate.h"
#include "cbe/delegate/UploadDelegate.h"
 
#ifndef CBE_NO_SYNC
#include "cbe/delegate/ProgressEventFn.h"
#endif
 
#include "cbe/delegate/Error.h"
#include "cbe/util/ErrorInfo.h"
#include "cbe/util/Exception.h"
#include "cbe/util/Optional.h"
 
#include <string>
#include <vector>
 
namespace CBI {
class Object;
using ObjectPtr = std::shared_ptr<CBI::Object>;
class ItemEventProtocol;
using ItemDelegatePtr = std::shared_ptr<ItemEventProtocol>;
class TransferDownloadEventProtocol;
using TransferDownloadDelegatePtr =
                                std::shared_ptr<TransferDownloadEventProtocol>;
class TransferUploadEventProtocol;
using TransferUploadDelegatePtr = std::shared_ptr<TransferUploadEventProtocol>;
} // namespace CBI
 
namespace cbe
{
 
class Object : public cbe::Item
{
public:
  using MoveDelegatePtr = delegate::object::MoveDelegatePtr;
  void move(
            cbe::ContainerId      dstId,
            MoveDelegatePtr       delegate);
#ifndef CBE_NO_SYNC
  using MoveException = delegate::object::MoveDelegate::Exception;
  cbe::Object move(
                   cbe::ContainerId  dstId);
 
  using MoveError = delegate::object::MoveDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Object> move(
                                        cbe::ContainerId  dstId,
                                        MoveError&        error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RenameDelegatePtr = delegate::object::RenameDelegatePtr;
  void rename(
              const std::string& name, RenameDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using RenameException = delegate::object::RenameDelegate::Exception;
  cbe::Object rename(
                     const std::string& name);
 
  using RenameError = delegate::object::RenameDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Object> rename(
                                    const std::string&  name,
                                    RenameError&        error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using RemoveDelegatePtr = delegate::object::RemoveDelegatePtr;
  void remove(
              RemoveDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using RemoveException = delegate::object::RemoveDelegate::Exception;
  delegate::object::RemoveSuccess remove();
 
  using RemoveError = delegate::object::RemoveDelegate::ErrorInfo;
  cbe::util::Optional<delegate::object::RemoveSuccess> remove(
                                                            RemoveError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using DownloadDelegatePtr = delegate::DownloadDelegatePtr;
  void download(
                const std::string&   path,
                DownloadDelegatePtr  delegate);
#ifndef CBE_NO_SYNC
  using DownloadException = delegate::DownloadDelegate::Exception;
  delegate::DownloadSuccess download(
                                const std::string&          path,
                                delegate::ProgressEventFn&& progressEventFn);
  delegate::DownloadSuccess download(
                                const std::string&          path);
  using DownloadError = delegate::DownloadDelegate::ErrorInfo;
  cbe::util::Optional<delegate::DownloadSuccess> download(
                                  const std::string&          path,
                                  delegate::ProgressEventFn&& progressEventFn,
                                  DownloadError&              error);
  cbe::util::Optional<delegate::DownloadSuccess> download(
                                  const std::string&          path,
                                  DownloadError&              error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using DownloadBinaryDelegatePtr = delegate::DownloadBinaryDelegatePtr;
  void download(std::size_t&& sizeLimit,
                DownloadBinaryDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using DownloadBinaryException = delegate::DownloadBinaryDelegate::Exception;
  delegate::DownloadBinarySuccess download(std::size_t&& sizeLimit,
                                  delegate::ProgressEventFn&& progressEventFn);
  delegate::DownloadBinarySuccess download(std::size_t&& sizeLimit);
 
  using DownloadBinaryError = delegate::DownloadBinaryDelegate::ErrorInfo;
  cbe::util::Optional<delegate::DownloadBinarySuccess> download(
                                    std::size_t&& sizeLimit,
                                    delegate::ProgressEventFn&& progressEventFn,
                                    DownloadBinaryError&        error);
  cbe::util::Optional<delegate::DownloadBinarySuccess> download(
                                    std::size_t&& sizeLimit,
                                    DownloadBinaryError&        error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  void downloadStream(
                      const std::string&  path,
                      cbe::Stream         stream,
                      DownloadDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  delegate::DownloadSuccess downloadStream(
                                  const std::string&          path,
                                  cbe::Stream                 stream,
                                  delegate::ProgressEventFn&& progressEventFn);
  delegate::DownloadSuccess downloadStream(
                                  const std::string&          path,
                                  cbe::Stream                 stream);
  cbe::util::Optional<delegate::DownloadSuccess> downloadStream(
                                  const std::string&          path,
                                  cbe::Stream                 stream,
                                  delegate::ProgressEventFn&& progressEventFn,
                                  DownloadError&              error);
  cbe::util::Optional<delegate::DownloadSuccess> downloadStream(
                                  const std::string&          path,
                                  cbe::Stream                 stream,
                                  DownloadError&              error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using UploadDelegatePtr = delegate::UploadDelegatePtr; 
  void uploadStream(
                    const std::string&        filePath,
                    cbe::StreamId             streamId,
                    UploadDelegatePtr         delegate);
#ifndef CBE_NO_SYNC
  using UploadException = delegate::UploadDelegate::Exception;
  cbe::Object uploadStream(
                           const std::string&           filePath,
                           cbe::StreamId                streamId,
                           delegate::ProgressEventFn&&  progressEventFn);
  cbe::Object uploadStream(
                           const std::string&           filePath,
                           cbe::StreamId                streamId);
 
  using UploadError = delegate::UploadDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Object> uploadStream(
                                  const std::string&           filePath,
                                  cbe::StreamId                streamId,
                                  delegate::ProgressEventFn&&  progressEventFn,
                                  UploadError&                 error);
  cbe::util::Optional<cbe::Object> uploadStream(
                                  const std::string&           filePath,
                                  cbe::StreamId                streamId,
                                  UploadError&                 error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
using UpdateKeyValuesDelegatePtr = delegate::UpdateKeyValuesDelegatePtr;
  void updateKeyValues(
                       KeyValues                  keyValues,
                       UpdateKeyValuesDelegatePtr delegate);
 
  void updateKeyValues(
                       UpdateKeyValuesDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using UpdateKeyValuesException = delegate::UpdateKeyValuesDelegate::Exception;
  cbe::Object updateKeyValues(
                              KeyValues keyValues);
  cbe::Object updateKeyValues();
 
  using UpdateKeyValuesError = delegate::UpdateKeyValuesDelegate::ErrorInfo;
  cbe::util::Optional<cbe::Object>  updateKeyValues(
                                              KeyValues             keyValues,
                                              UpdateKeyValuesError& error);
  cbe::util::Optional<cbe::Object> updateKeyValues(
                                                  UpdateKeyValuesError& error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using GetStreamsDelegatePtr = delegate::GetStreamsDelegatePtr;
  void getStreams(
                  GetStreamsDelegatePtr delegate);
  using Streams = cbe::Streams;
#ifndef CBE_NO_SYNC
  using GetStreamsException = delegate::GetStreamsDelegate::Exception;
  Streams getStreams();
 
  using GetStreamsError = delegate::GetStreamsDelegate::ErrorInfo;
  cbe::util::Optional<Streams> getStreams(
                                          GetStreamsError&           error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  std::string getMimeType() const;
 
  uint64_t length() const;
 
  cbe::object_t getObjectType() const;
 
  cbe::KeyValues keyValues();
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  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 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 ShareDelegatePtr = delegate::ShareDelegatePtr;
  void share(
             cbe::UserId       toUserGroup,
             std::string       description,
             ShareDelegatePtr  delegate);
#ifndef CBE_NO_SYNC
  using ShareException = delegate::ShareDelegate::Exception;
  delegate::ShareSuccess share(
                               cbe::UserId       toUserGroup,
                               std::string       description);
  using ShareError = delegate::ShareDelegate::ErrorInfo;
  cbe::util::Optional<delegate::ShareSuccess> share(
                                                    cbe::UserId  toUserGroup,
                                                    std::string  description,
                                                    ShareError&  error);
#endif // #ifndef CBE_NO_SYNC
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  using UnShareDelegatePtr = delegate::UnShareDelegatePtr;
  void unShare(
               cbe::ShareId shareId, 
               UnShareDelegatePtr delegate);
#ifndef CBE_NO_SYNC
  using UnShareException = delegate::UnShareDelegate::Exception;
  delegate::UnShareSuccess unShare(
                                   cbe::ShareId shareId);
 
  using UnShareError = delegate::UnShareDelegate::ErrorInfo;
  cbe::util::Optional<delegate::UnShareSuccess> 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
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  std::string url();
  Object(cbe::DefaultCtor);
 
private:
  struct Impl;
  Impl& getImpl() const;
 
  friend class CloudBackend;
  friend class Container;
  Object(CBI::ObjectPtr cbiPeerPtr);
  CBI::Object& getCbiPeer() const;
}; // class Object
 
} // namespace cbe
 
#endif // INCLUDE_CBE_OBJECT_H_