orthanc: OrthancServer/Sources/main.cpp comparison

comparison OrthancServer/Sources/main.cpp @ 4237:f39d162ba7e9

sharing more code

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 09 Oct 2020 10:06:20 +0200
parents	5639ffda467b
children	c007fb7c8395

comparison

equal deleted inserted replaced

-:5639ffda467b
+:f39d162ba7e9
 const UriComponents& path) = 0;
 };
-class InstancesNode : public INode
+class InstancesOfSeries : public INode
 {
 private:
 ServerContext&  context_;
 std::string     parentSeries_;
 public:
-InstancesNode(ServerContext& context,
+InstancesOfSeries(ServerContext& context,
 const std::string& parentSeries) :
 context_(context),
 parentSeries_(parentSeries)
 {
 }
 return child->second;
 }
 }
 protected:
+void RemoveSubfolder(const std::string& path)
+{
+Children::iterator child = children_.find(path);
+if (child != children_.end())
+{
+assert(child->second != NULL);
+delete child->second;
+children_.erase(child);
+}
+}
 virtual void Refresh() = 0;
-virtual bool ListContent(IWebDavBucket::Collection& target) = 0;
+virtual bool ListSubfolders(IWebDavBucket::Collection& target) = 0;
 virtual INode* CreateChild(const std::string& path) = 0;
 public:
 virtual ~InternalNode()
 {
 Refresh();
 if (path.empty())
 {
-return ListContent(target);
+return ListSubfolders(target);
 }
 else
 {
 // Recursivity
 INode* child = GetChild(path[0]);
 const UriComponents& path)
 ORTHANC_OVERRIDE ORTHANC_FINAL
 {
 if (path.empty())
 {
-return false;
+return false;  // An internal node doesn't correspond to a file
 }
 else
 {
 // Recursivity
 Refresh();
 }
 }
 };
-class ResourcesNode : public INode
+class ListOfResources : public InternalNode
 {
 private:
-typedef std::map<std::string, INode*>  Children;
 ServerContext&                   context_;
 const Templates&                 templates_;
 std::unique_ptr<ResourcesIndex>  index_;
 MetadataType                     timeMetadata_;
-Children                         children_;  // Maps paths to subnodes
+protected:
-void Refresh()
+virtual void Refresh() ORTHANC_OVERRIDE ORTHANC_FINAL
 {
 std::list<std::string> resources;
 GetCurrentResources(resources);
 std::set<std::string> removedPaths;
 // Remove the children whose associated resource doesn't exist anymore
 for (std::set<std::string>::const_iterator
 it = removedPaths.begin(); it != removedPaths.end(); ++it)
 {
-Children::iterator child = children_.find(*it);
+RemoveSubfolder(*it);
-if (child != children_.end())
+}
-{
+}
-assert(child->second != NULL);
-delete child->second;
+virtual bool ListSubfolders(IWebDavBucket::Collection& target) ORTHANC_OVERRIDE ORTHANC_FINAL
-children_.erase(child);
+{
-}
-}
-}
-INode* GetChild(const std::string& path)  // Don't free the resulting pointer!
-{
-Children::iterator child = children_.find(path);
-if (child == children_.end())
-{
-INode* child = CreateChild(path);
-if (child == NULL)
-{
-return NULL;
-}
-else
-{
-children_[path] = child;
-return child;
-}
-}
-else
-{
-assert(child->second != NULL);
-return child->second;
-}
-}
-protected:
-ServerContext& GetContext() const
-{
-return context_;
-}
-virtual void GetCurrentResources(std::list<std::string>& resources) = 0;
-virtual INode* CreateChild(const std::string& path)
-{
-ResourcesIndex::Map::const_iterator resource = index_->GetPathToResource().find(path);
-if (resource == index_->GetPathToResource().end())
-{
-return NULL;
-}
-else
-{
-return CreateResourceNode(resource->second);
-}
-}
-virtual INode* CreateResourceNode(const std::string& resource) = 0;
-public:
-ResourcesNode(ServerContext& context,
-ResourceType level,
-const Templates& templates) :
-context_(context),
-templates_(templates)
-{
-Templates::const_iterator t = templates.find(level);
-if (t == templates.end())
-{
-throw OrthancException(ErrorCode_ParameterOutOfRange);
-}
-index_.reset(new ResourcesIndex(context, level, t->second));
-if (level == ResourceType_Instance)
-{
-timeMetadata_ = MetadataType_Instance_ReceptionDate;
-}
-else
-{
-timeMetadata_ = MetadataType_LastUpdate;
-}
-}
-virtual ~ResourcesNode()
-{
-for (Children::iterator it = children_.begin(); it != children_.end(); ++it)
-{
-assert(it->second != NULL);
-delete it->second;
-}
-}
-ResourceType GetLevel() const
-{
-return index_->GetLevel();
-}
-const Templates& GetTemplates() const
-{
-return templates_;
-}
-virtual bool ListCollection(IWebDavBucket::Collection& target,
-const UriComponents& path)
-ORTHANC_OVERRIDE ORTHANC_FINAL
-{
-Refresh();
 if (index_->GetLevel() == ResourceType_Instance)
 {
 // Not a collection, no subfolders
 return false;
 }
-else if (path.empty())
+else
 {
 const ResourcesIndex::Map& paths = index_->GetPathToResource();
 for (ResourcesIndex::Map::const_iterator it = paths.begin(); it != paths.end(); ++it)
 {
 target.AddResource(resource.release());
 }
 return true;
 }
+}
+virtual INode* CreateChild(const std::string& path) ORTHANC_OVERRIDE ORTHANC_FINAL
+{
+ResourcesIndex::Map::const_iterator resource = index_->GetPathToResource().find(path);
+if (resource == index_->GetPathToResource().end())
+{
+return NULL;
+}
 else
 {
-// Recursivity
+return CreateResourceNode(resource->second);
-INode* child = GetChild(path[0]);
+}
-if (child == NULL)
+}
-{
-return false;
+ServerContext& GetContext() const
-}
+{
-else
+return context_;
-{
+}
-UriComponents subpath(path.begin() + 1, path.end());
-return child->ListCollection(target, subpath);
+virtual void GetCurrentResources(std::list<std::string>& resources) = 0;
-}
-}
+virtual INode* CreateResourceNode(const std::string& resource) = 0;
-}
+public:
-virtual bool GetFileContent(MimeType& mime,
+ListOfResources(ServerContext& context,
-std::string& content,
+ResourceType level,
-boost::posix_time::ptime& time,
+const Templates& templates) :
-const UriComponents& path)
+context_(context),
-ORTHANC_OVERRIDE ORTHANC_FINAL
+templates_(templates)
 {
-if (path.empty())
+Templates::const_iterator t = templates.find(level);
-{
+if (t == templates.end())
-return false;
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+index_.reset(new ResourcesIndex(context, level, t->second));
+if (level == ResourceType_Instance)
+{
+timeMetadata_ = MetadataType_Instance_ReceptionDate;
 }
 else
 {
-// Recursivity
+timeMetadata_ = MetadataType_LastUpdate;
-Refresh();
+}
+}
-INode* child = GetChild(path[0]);
-if (child == NULL)
+ResourceType GetLevel() const
 {
-return false;
+return index_->GetLevel();
 }
-else
-{
+const Templates& GetTemplates() const
-UriComponents subpath(path.begin() + 1, path.end());
+{
-return child->GetFileContent(mime, content, time, subpath);
+return templates_;
-}
-}
 }
 };
-class ResourceChildrenNode : public ResourcesNode
+class ResourceChildrenNode : public ListOfResources
 {
 private:
 std::string  parentId_;
 protected:
 {
 return NULL;
 }
 else if (GetLevel() == ResourceType_Series)
 {
-return new InstancesNode(GetContext(), resource);
+return new InstancesOfSeries(GetContext(), resource);
 }
 else
 {
 ResourceType l = GetChildResourceType(GetLevel());
 return new ResourceChildrenNode(GetContext(), l, resource, GetTemplates());
 public:
 ResourceChildrenNode(ServerContext& context,
 ResourceType level,
 const std::string& parentId,
 const Templates& templates) :
-ResourcesNode(context, level, templates),
+ListOfResources(context, level, templates),
 parentId_(parentId)
 {
 }
 };
-class RootNode : public ResourcesNode
+class RootNode : public ListOfResources
 {
 protected:
 virtual void GetCurrentResources(std::list<std::string>& resources) ORTHANC_OVERRIDE
 {
 GetContext().GetIndex().GetAllUuids(resources, GetLevel());
 virtual INode* CreateResourceNode(const std::string& resource) ORTHANC_OVERRIDE
 {
 if (GetLevel() == ResourceType_Series)
 {
-return new InstancesNode(GetContext(), resource);
+return new InstancesOfSeries(GetContext(), resource);
 }
 else
 {
 ResourceType l = GetChildResourceType(GetLevel());
 return new ResourceChildrenNode(GetContext(), l, resource, GetTemplates());
 public:
 RootNode(ServerContext& context,
 ResourceType level,
 const Templates& templates) :
-ResourcesNode(context, level, templates)
+ListOfResources(context, level, templates)
 {
 }
 };
-class StudyMonthsNode : public InternalNode
+class ListOfStudiesByMonth : public InternalNode
 {
 private:
 ServerContext&    context_;
 std::string       year_;
 const Templates&  templates_;
 protected:
 virtual void Refresh() ORTHANC_OVERRIDE
 {
 }
-virtual bool ListContent(IWebDavBucket::Collection& target) ORTHANC_OVERRIDE
+virtual bool ListSubfolders(IWebDavBucket::Collection& target) ORTHANC_OVERRIDE
 {
 DatabaseLookup query;
 query.AddRestConstraint(DICOM_TAG_STUDY_DATE, year_ + "0101-" + year_ + "1231",
 true /* case sensitive */, true /* mandatory tag */);
 {
 return NULL;
 }
 public:
-StudyMonthsNode(ServerContext& context,
+ListOfStudiesByMonth(ServerContext& context,
 const std::string& year,
 const Templates& templates) :
 context_(context),
 year_(year),
 templates_(templates)
 {
 }
 };
-class StudyYearsNode : public InternalNode
+class ListOfStudiesByYear : public InternalNode
 {
 private:
 ServerContext&    context_;
 const Templates&  templates_;
 protected:
 virtual void Refresh() ORTHANC_OVERRIDE
 {
 }
-virtual bool ListContent(IWebDavBucket::Collection& target) ORTHANC_OVERRIDE
+virtual bool ListSubfolders(IWebDavBucket::Collection& target) ORTHANC_OVERRIDE
 {
 std::list<std::string> resources;
 context_.GetIndex().GetAllUuids(resources, ResourceType_Study);
 std::set<std::string> years;
 return true;
 }
 virtual INode* CreateChild(const std::string& path) ORTHANC_OVERRIDE
 {
-return new StudyMonthsNode(context_, path, templates_);
+return new ListOfStudiesByMonth(context_, path, templates_);
 }
 public:
-StudyYearsNode(ServerContext& context,
+ListOfStudiesByYear(ServerContext& context,
 const Templates& templates) :
 context_(context),
 templates_(templates)
 {
 }
 };
 studiesTemplates_[ResourceType_Study] = "{{PatientID}} - {{PatientName}} - {{StudyDescription}}";
 studiesTemplates_[ResourceType_Series] = patientsTemplates_[ResourceType_Series];
 patients_.reset(new RootNode(context, ResourceType_Patient, patientsTemplates_));
 studies_.reset(new RootNode(context, ResourceType_Study, studiesTemplates_));
-dates_.reset(new StudyYearsNode(context, studiesTemplates_));
+dates_.reset(new ListOfStudiesByYear(context, studiesTemplates_));
 }
 virtual bool IsExistingFolder(const UriComponents& path) ORTHANC_OVERRIDE
 {
 if (path.empty())

Mercurial > hg > orthanc

comparison OrthancServer/Sources/main.cpp @ 4237:f39d162ba7e9