mitkDataStorageBridge.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkDataStorageBridge_h
#define mitkDataStorageBridge_h
 
#include <mitkDataStorage.h>
#include <mitkWeakPointer.h>
#include <mitkBaseData.h>
#include <mitkNodePredicateBase.h>
#include <mitkStorageThreadDispatcherBase.h>
#include <mitkNodeUidMapper.h>
#include <mitkNodeQueryParams.h>
 
#include <nlohmann/json.hpp>
 
#include <mutex>
#include <optional>
#include <string>
#include <memory>
#include <vector>
 
#include <MitkRESTAPIExports.h>
 
namespace mitk
{
  class MITKRESTAPI_EXPORT DataStorageBridge
  {
  public:
    using Json = nlohmann::json;
 
    static constexpr const char* INTERNAL_PROPERTY_PREFIX = "restapi.";
 
    static constexpr const char* MODIFIED_PROPERTY_KEY = "restapi.modified";
 
    static constexpr const char* LAST_MODIFICATION_PROPERTY_KEY = "restapi.lastmodification";
 
    DataStorageBridge();
    ~DataStorageBridge();
 
    // Non-copyable, non-movable
    DataStorageBridge(const DataStorageBridge&) = delete;
    DataStorageBridge& operator=(const DataStorageBridge&) = delete;
    DataStorageBridge(DataStorageBridge&&) = delete;
    DataStorageBridge& operator=(DataStorageBridge&&) = delete;
 
    void SetDispatcher(StorageThreadDispatcherBase* dispatcher);
 
    void SetDataStorage(DataStorage* dataStorage);
 
    DataStorage::Pointer GetDataStorage() const;
 
    enum class OperationStatus
    {
      Success,
      NodeNotFound,       
      PropertyNotFound,   
      InvalidInput,       
      InternalError       
    };
 
    bool HasDataStorage() const;
 
    std::string GetNodeUid (DataNode* node) const;
 
    // Node operations
 
    struct NodeQueryResult
    {
      Json nodes;       
      int totalCount;   
      int limit;        
      int offset;       
    };
 
    NodeQueryResult GetNodes(const NodeQueryParams& params) const;
 
    std::optional<Json> GetNode(const std::string& uid) const;
 
    struct CreateNodeResult
    {
      bool success;                               
      std::string uid;                            
      std::vector<std::string> failedProperties;  
    };
 
    CreateNodeResult CreateNode(const Json& nodeData, const std::optional<std::string>& parentUid = std::nullopt);
 
    bool UpdateNode(const std::string& uid, const Json& updates);
 
    struct DeleteResult
    {
      bool success;                         
      std::string deletedUid;               
      std::vector<std::string> deletedChildren;  
      int childrenCount;                    
    };
 
    DeleteResult DeleteNode(const std::string& uid, bool recursive = false);
 
    // Data operations
 
    struct GetNodeDataResult
    {
      bool nodeFound;         
      BaseData::Pointer data; 
    };
 
    GetNodeDataResult GetNodeData(const std::string& uid) const;
 
    DataNode::ConstPointer FindDataNode(const std::string& uid) const;
 
    OperationStatus SetNodeData(const std::string& uid, BaseData* data);
 
    // Property operations
 
    std::optional<Json> GetNodeProperties(const std::string& uid, const PropertyQueryParams& params = {}) const;
 
    std::optional<Json> GetNodeProperty(
      const std::string& uid,
      const std::string& key,
      const PropertyQueryParams& params = {}) const;
 
    OperationStatus SetNodeProperty(
      const std::string& uid,
      const std::string& key,
      const Json& value,
      const PropertyQueryParams& params);
 
    OperationStatus DeleteNodeProperty(
      const std::string& uid,
      const std::string& key,
      const PropertyQueryParams& params);
 
    struct ReplacePropertiesResult
    {
      OperationStatus status = OperationStatus::InternalError;
      Json result = {};  
    };
 
    ReplacePropertiesResult ReplaceNodeProperties(
      const std::string& uid,
      const Json& properties,
      const PropertyQueryParams& params);
 
    std::optional<Json> GetNodeAvailableContexts(const std::string& uid) const;
 
  private:
    NodePredicateBase::Pointer BuildNodePredicate(const NodeQueryParams& params) const;
 
    Json NodeToJson(DataNode* node) const;
    std::string BuildNodePath(const DataNode* node) const;
    int GetChildrenCount(const DataNode* node) const;
 
    void DispatchTask(std::function<void()> task) const;
 
    template <typename R>
    R DispatchTask(std::function<R()> task) const;
 
    WeakPointer<DataStorage> m_DataStorage;
    WeakPointer<StorageThreadDispatcherBase> m_Dispatcher;
    std::unique_ptr<NodeUidMapper> m_UidMapper;
 
    mutable std::mutex m_Mutex;
  };
}
 
#endif