--- a/OrthancServer/Sources/ServerIndex.h	Tue Mar 09 18:24:59 2021 +0100
+++ b/OrthancServer/Sources/ServerIndex.h	Wed Mar 10 15:59:03 2021 +0100
@@ -33,47 +33,32 @@
 
 #pragma once
 
+#include "Database/StatelessDatabaseOperations.h"
 #include "../../OrthancFramework/Sources/Cache/LeastRecentlyUsedIndex.h"
-#include "../../OrthancFramework/Sources/DicomFormat/DicomMap.h"
-
-#include "Database/IDatabaseWrapper.h"
-#include "DicomInstanceOrigin.h"
 
 #include <boost/thread.hpp>
-#include <boost/noncopyable.hpp>
 
 namespace Orthanc
 {
-  class DatabaseLookup;
-  class ParsedDicomFile;
   class ServerContext;
-
-  class ServerIndex : public boost::noncopyable
+  
+  class ServerIndex : public StatelessDatabaseOperations
   {
-  public:
-    typedef std::list<FileInfo> Attachments;
-    typedef std::map<std::pair<ResourceType, MetadataType>, std::string>  MetadataMap;
-
   private:
     class TransactionContextFactory;
     class Listener;
-    class Transaction;
     class UnstableResourcePayload;
-    class MainDicomTagsRegistry;
 
     bool done_;
     boost::mutex monitoringMutex_;
-    boost::mutex databaseMutex_;  // TODO - REMOVE
     boost::thread flushThread_;
     boost::thread unstableResourcesMonitorThread_;
 
     std::unique_ptr<Listener> listener_;
-    IDatabaseWrapper& db_;
     LeastRecentlyUsedIndex<int64_t, UnstableResourcePayload>  unstableResources_;
 
     uint64_t     maximumStorageSize_;
     unsigned int maximumPatients_;
-    std::unique_ptr<MainDicomTagsRegistry>  mainDicomTagsRegistry_;
 
     static void FlushThread(ServerIndex* that,
                             unsigned int threadSleep);
@@ -81,17 +66,10 @@
     static void UnstableResourcesMonitorThread(ServerIndex* that,
                                                unsigned int threadSleep);
 
-    void StandaloneRecycling(uint64_t maximumStorageSize,
-                             unsigned int maximumPatientCount);
-
     void MarkAsUnstable(int64_t id,
                         Orthanc::ResourceType type,
                         const std::string& publicId);
 
-    void NormalizeLookup(std::vector<DatabaseConstraint>& target,
-                         const DatabaseLookup& source,
-                         ResourceType level) const;
-
     bool IsUnstableResource(int64_t id);
 
   public:
@@ -109,516 +87,6 @@
     // "count == 0" means no limit on the number of patients
     void SetMaximumPatientCount(unsigned int count);
 
-    // It is assumed that "GetDatabaseVersion()" can run out of a
-    // database transaction
-    unsigned int GetDatabaseVersion()
-    {
-      return db_.GetDatabaseVersion();
-    }
-
-
-    
-    /***
-     ** PROTOTYPING FOR DB REFACTORING BELOW
-     ***/
-    
-  public:
-    class ITransactionContext : public boost::noncopyable
-    {
-    public:
-      virtual ~ITransactionContext()
-      {
-      }
-
-      virtual bool IsUnstableResource(int64_t id) = 0;
-
-      virtual bool LookupRemainingLevel(std::string& remainingPublicId /* out */,
-                                        ResourceType& remainingLevel   /* out */) = 0;
-
-      virtual void MarkAsUnstable(int64_t id,
-                                  Orthanc::ResourceType type,
-                                  const std::string& publicId) = 0;
-
-      virtual void SignalAttachmentsAdded(uint64_t compressedSize) = 0;
-
-      virtual void SignalChange(const ServerIndexChange& change) = 0;
-    };
-
-    
-    class ITransactionContextFactory : public boost::noncopyable
-    {
-    public:
-      virtual ~ITransactionContextFactory()
-      {
-      }
-
-      virtual ITransactionContext* Create() = 0;
-    };
-
-
-    class ReadOnlyTransaction : public boost::noncopyable
-    {
-    private:
-      ITransactionContext&  context_;
-      
-    protected:
-      IDatabaseWrapper&  db_;
-      
-    public:
-      explicit ReadOnlyTransaction(IDatabaseWrapper& db,
-                                   ITransactionContext& context) :
-        context_(context),
-        db_(db)
-      {
-      }
-
-      ITransactionContext& GetTransactionContext()
-      {
-        return context_;
-      }
-
-      /**
-       * Higher-level constructions
-       **/
-
-      SeriesStatus GetSeriesStatus(int64_t id,
-                                   int64_t expectedNumberOfInstances);
-
-      void MainDicomTagsToJson(Json::Value& result,
-                               int64_t resourceId,
-                               ResourceType resourceType);
-
-      /**
-       * Read-only methods from "IDatabaseWrapper"
-       **/
-
-      void ApplyLookupResources(std::list<std::string>& resourcesId,
-                                std::list<std::string>* instancesId, // Can be NULL if not needed
-                                const std::vector<DatabaseConstraint>& lookup,
-                                ResourceType queryLevel,
-                                size_t limit)
-      {
-        return db_.ApplyLookupResources(resourcesId, instancesId, lookup, queryLevel, limit);
-      }
-
-      void GetAllMetadata(std::map<MetadataType, std::string>& target,
-                          int64_t id)
-      {
-        db_.GetAllMetadata(target, id);
-      }
-
-      void GetAllPublicIds(std::list<std::string>& target,
-                           ResourceType resourceType)
-      {
-        return db_.GetAllPublicIds(target, resourceType);
-      }
-
-      void GetAllPublicIds(std::list<std::string>& target,
-                           ResourceType resourceType,
-                           size_t since,
-                           size_t limit)
-      {
-        return db_.GetAllPublicIds(target, resourceType, since, limit);
-      }  
-
-      void GetChanges(std::list<ServerIndexChange>& target /*out*/,
-                      bool& done /*out*/,
-                      int64_t since,
-                      uint32_t maxResults)
-      {
-        db_.GetChanges(target, done, since, maxResults);
-      }
-
-      void GetChildrenInternalId(std::list<int64_t>& target,
-                                 int64_t id)
-      {
-        db_.GetChildrenInternalId(target, id);
-      }
-
-      void GetChildrenPublicId(std::list<std::string>& target,
-                               int64_t id)
-      {
-        db_.GetChildrenPublicId(target, id);
-      }
-
-      void GetExportedResources(std::list<ExportedResource>& target /*out*/,
-                                bool& done /*out*/,
-                                int64_t since,
-                                uint32_t maxResults)
-      {
-        return db_.GetExportedResources(target, done, since, maxResults);
-      }
-
-      void GetLastChange(std::list<ServerIndexChange>& target /*out*/)
-      {
-        db_.GetLastChange(target);
-      }
-
-      void GetLastExportedResource(std::list<ExportedResource>& target /*out*/)
-      {
-        return db_.GetLastExportedResource(target);
-      }
-
-      int64_t GetLastChangeIndex()
-      {
-        return db_.GetLastChangeIndex();
-      }
-
-      void GetMainDicomTags(DicomMap& map,
-                            int64_t id)
-      {
-        db_.GetMainDicomTags(map, id);
-      }
-
-      std::string GetPublicId(int64_t resourceId)
-      {
-        return db_.GetPublicId(resourceId);
-      }
-      
-      uint64_t GetResourceCount(ResourceType resourceType)
-      {
-        return db_.GetResourceCount(resourceType);
-      }
-      
-      ResourceType GetResourceType(int64_t resourceId)
-      {
-        return db_.GetResourceType(resourceId);
-      }
-
-      uint64_t GetTotalCompressedSize()
-      {
-        return db_.GetTotalCompressedSize();
-      }
-    
-      uint64_t GetTotalUncompressedSize()
-      {
-        return db_.GetTotalUncompressedSize();
-      }
-      
-      bool IsProtectedPatient(int64_t internalId)
-      {
-        return db_.IsProtectedPatient(internalId);
-      }
-
-      void ListAvailableAttachments(std::set<FileContentType>& target,
-                                    int64_t id)
-      {
-        db_.ListAvailableAttachments(target, id);
-      }
-
-      bool LookupAttachment(FileInfo& attachment,
-                            int64_t id,
-                            FileContentType contentType)
-      {
-        return db_.LookupAttachment(attachment, id, contentType);
-      }
-      
-      bool LookupGlobalProperty(std::string& target,
-                                GlobalProperty property)
-      {
-        return db_.LookupGlobalProperty(target, property);
-      }
-
-      bool LookupMetadata(std::string& target,
-                          int64_t id,
-                          MetadataType type)
-      {
-        return db_.LookupMetadata(target, id, type);
-      }
-
-      bool LookupParent(int64_t& parentId,
-                        int64_t resourceId)
-      {
-        return db_.LookupParent(parentId, resourceId);
-      }
-        
-      bool LookupResource(int64_t& id,
-                          ResourceType& type,
-                          const std::string& publicId)
-      {
-        return db_.LookupResource(id, type, publicId);
-      }
-      
-      bool LookupResourceAndParent(int64_t& id,
-                                   ResourceType& type,
-                                   std::string& parentPublicId,
-                                   const std::string& publicId)
-      {
-        return db_.LookupResourceAndParent(id, type, parentPublicId, publicId);
-      }
-    };
-
-
-    class ReadWriteTransaction : public ReadOnlyTransaction
-    {
-    public:
-      ReadWriteTransaction(IDatabaseWrapper& db,
-                           ITransactionContext& context) :
-        ReadOnlyTransaction(db, context)
-      {
-      }
-
-      void AddAttachment(int64_t id,
-                         const FileInfo& attachment)
-      {
-        db_.AddAttachment(id, attachment);
-      }
-      
-      void ClearChanges()
-      {
-        db_.ClearChanges();
-      }
-
-      void ClearExportedResources()
-      {
-        db_.ClearExportedResources();
-      }
-
-      void ClearMainDicomTags(int64_t id)
-      {
-        return db_.ClearMainDicomTags(id);
-      }
-
-      bool CreateInstance(IDatabaseWrapper::CreateInstanceResult& result, /* out */
-                          int64_t& instanceId,          /* out */
-                          const std::string& patient,
-                          const std::string& study,
-                          const std::string& series,
-                          const std::string& instance)
-      {
-        return db_.CreateInstance(result, instanceId, patient, study, series, instance);
-      }
-
-      void DeleteAttachment(int64_t id,
-                            FileContentType attachment)
-      {
-        return db_.DeleteAttachment(id, attachment);
-      }
-      
-      void DeleteMetadata(int64_t id,
-                          MetadataType type)
-      {
-        db_.DeleteMetadata(id, type);
-      }
-
-      void DeleteResource(int64_t id)
-      {
-        db_.DeleteResource(id);
-      }
-
-      void LogChange(int64_t internalId,
-                     ChangeType changeType,
-                     ResourceType resourceType,
-                     const std::string& publicId);
-
-      void LogExportedResource(const ExportedResource& resource)
-      {
-        db_.LogExportedResource(resource);
-      }
-
-      void SetGlobalProperty(GlobalProperty property,
-                             const std::string& value)
-      {
-        db_.SetGlobalProperty(property, value);
-      }
-
-      void SetMetadata(int64_t id,
-                       MetadataType type,
-                       const std::string& value)
-      {
-        return db_.SetMetadata(id, type, value);
-      }
-
-      void SetProtectedPatient(int64_t internalId, 
-                               bool isProtected)
-      {
-        db_.SetProtectedPatient(internalId, isProtected);
-      }
-
-      void SetResourcesContent(const ResourcesContent& content)
-      {
-        db_.SetResourcesContent(content);
-      }
-
-      void Recycle(uint64_t maximumStorageSize,
-                   unsigned int maximumPatients,
-                   uint64_t addedInstanceSize,
-                   const std::string& newPatientId);
-    };
-
-
-    class IReadOnlyOperations : public boost::noncopyable
-    {
-    public:
-      virtual ~IReadOnlyOperations()
-      {
-      }
-
-      virtual void Apply(ReadOnlyTransaction& transaction) = 0;
-    };
-
-
-    class IReadWriteOperations : public boost::noncopyable
-    {
-    public:
-      virtual ~IReadWriteOperations()
-      {
-      }
-
-      virtual void Apply(ReadWriteTransaction& transaction) = 0;
-    };
-    
-  private:
-    void ApplyInternal(IReadOnlyOperations* readOperations,
-                       IReadWriteOperations* writeOperations);
-
-    std::unique_ptr<ITransactionContextFactory>  factory_;
-    unsigned int maxRetries_;
-
-  public:
-    void SetTransactionContextFactory(ITransactionContextFactory* factory /* takes ownership */);
-    
-    void Apply(IReadOnlyOperations& operations);
-  
-    void Apply(IReadWriteOperations& operations);
-
-    bool ExpandResource(Json::Value& target,
-                        const std::string& publicId,
-                        ResourceType level);
-
-    void GetAllMetadata(std::map<MetadataType, std::string>& target,
-                        const std::string& publicId,
-                        ResourceType level);
-
-    void GetAllUuids(std::list<std::string>& target,
-                     ResourceType resourceType);
-
-    void GetAllUuids(std::list<std::string>& target,
-                     ResourceType resourceType,
-                     size_t since,
-                     size_t limit);
-
-    void GetGlobalStatistics(/* out */ uint64_t& diskSize,
-                             /* out */ uint64_t& uncompressedSize,
-                             /* out */ uint64_t& countPatients, 
-                             /* out */ uint64_t& countStudies, 
-                             /* out */ uint64_t& countSeries, 
-                             /* out */ uint64_t& countInstances);
-
-    bool LookupAttachment(FileInfo& attachment,
-                          const std::string& instancePublicId,
-                          FileContentType contentType);
-
-    void GetChanges(Json::Value& target,
-                    int64_t since,
-                    unsigned int maxResults);
-
-    void GetLastChange(Json::Value& target);
-
-    void GetExportedResources(Json::Value& target,
-                              int64_t since,
-                              unsigned int maxResults);
-
-    void GetLastExportedResource(Json::Value& target);
-
-    bool IsProtectedPatient(const std::string& publicId);
-
-    void GetChildren(std::list<std::string>& result,
-                     const std::string& publicId);
-
-    void GetChildInstances(std::list<std::string>& result,
-                           const std::string& publicId);
-
-    bool LookupMetadata(std::string& target,
-                        const std::string& publicId,
-                        ResourceType expectedType,
-                        MetadataType type);
-
-    void ListAvailableAttachments(std::set<FileContentType>& target,
-                                  const std::string& publicId,
-                                  ResourceType expectedType);
-
-    bool LookupParent(std::string& target,
-                      const std::string& publicId);
-
-    void GetResourceStatistics(/* out */ ResourceType& type,
-                               /* out */ uint64_t& diskSize, 
-                               /* out */ uint64_t& uncompressedSize, 
-                               /* out */ unsigned int& countStudies, 
-                               /* out */ unsigned int& countSeries, 
-                               /* out */ unsigned int& countInstances, 
-                               /* out */ uint64_t& dicomDiskSize, 
-                               /* out */ uint64_t& dicomUncompressedSize, 
-                               const std::string& publicId);
-
-    void LookupIdentifierExact(std::vector<std::string>& result,
-                               ResourceType level,
-                               const DicomTag& tag,
-                               const std::string& value);
-
-    bool LookupGlobalProperty(std::string& value,
-                              GlobalProperty property);
-
-    std::string GetGlobalProperty(GlobalProperty property,
-                                  const std::string& defaultValue);
-
-    bool GetMainDicomTags(DicomMap& result,
-                          const std::string& publicId,
-                          ResourceType expectedType,
-                          ResourceType levelOfInterest);
-
-    // Only applicable at the instance level
-    bool GetAllMainDicomTags(DicomMap& result,
-                             const std::string& instancePublicId);
-
-    bool LookupResourceType(ResourceType& type,
-                            const std::string& publicId);
-
-    bool LookupParent(std::string& target,
-                      const std::string& publicId,
-                      ResourceType parentType);
-
-    void ApplyLookupResources(std::vector<std::string>& resourcesId,
-                              std::vector<std::string>* instancesId,  // Can be NULL if not needed
-                              const DatabaseLookup& lookup,
-                              ResourceType queryLevel,
-                              size_t limit);
-
-    bool DeleteResource(Json::Value& target /* out */,
-                        const std::string& uuid,
-                        ResourceType expectedType);
-
-    void LogExportedResource(const std::string& publicId,
-                             const std::string& remoteModality);
-
-    void SetProtectedPatient(const std::string& publicId,
-                             bool isProtected);
-
-    void SetMetadata(const std::string& publicId,
-                     MetadataType type,
-                     const std::string& value);
-
-    void DeleteMetadata(const std::string& publicId,
-                        MetadataType type);
-
-    uint64_t IncrementGlobalSequence(GlobalProperty sequence);
-
-    void DeleteChanges();
-
-    void DeleteExportedResources();
-
-    void SetGlobalProperty(GlobalProperty property,
-                           const std::string& value);
-
-    void DeleteAttachment(const std::string& publicId,
-                          FileContentType type);
-
-    void LogChange(ChangeType changeType,
-                   const std::string& publicId,
-                   ResourceType level);
-
-    void ReconstructInstance(const ParsedDicomFile& dicom);
-
     StoreStatus Store(std::map<MetadataType, std::string>& instanceMetadata,
                       const DicomMap& dicomSummary,
                       const Attachments& attachments,