Manager.h

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================
 
#ifndef smtk_resource_Manager_h
#define smtk_resource_Manager_h
 
#include "smtk/CoreExports.h"
#include "smtk/PublicPointerDefs.h"
#include "smtk/SharedFromThis.h"
#include "smtk/SystemConfig.h"
 
#include "smtk/common/Processing.h"
#include "smtk/common/TypeName.h"
#include "smtk/common/UUID.h"
 
#include "smtk/resource/Container.h"
#include "smtk/resource/Lock.h"
#include "smtk/resource/Metadata.h"
#include "smtk/resource/MetadataContainer.h"
#include "smtk/resource/Observer.h"
#include "smtk/resource/Resource.h"
 
#include <functional>
#include <string>
#include <typeinfo>
#include <unordered_map>
 
namespace smtk
{
namespace resource
{
class GarbageCollector;
class Manager;
using GarbageCollectorPtr = std::shared_ptr<GarbageCollector>;
 
class SMTKCORE_EXPORT Manager : smtkEnableSharedPtr(Manager)
{
public:
  using ResourceVisitor = std::function<smtk::common::Processing(Resource&)>;
 
  smtkTypedefs(smtk::resource::Manager);
  smtkCreateMacro(Manager);
 
  virtual ~Manager();
 
  template<typename ResourceType>
  bool registerResource(
    const std::function<
      ResourcePtr(const std::string&, const std::shared_ptr<smtk::common::Managers>&)>& read =
      nullptr,
    const std::function<bool(const ResourcePtr&, const std::shared_ptr<smtk::common::Managers>&)>&
      write = nullptr,
    const std::function<
      ResourcePtr(const smtk::common::UUID&, const std::shared_ptr<smtk::common::Managers>&)>&
      create = nullptr);
 
  bool registerResource(Metadata&&);
 
  template<typename ResourceType>
  bool unregisterResource();
 
  bool unregisterResource(const std::string&);
 
  bool unregisterResource(const Resource::Index&);
 
  template<typename ResourceType>
  bool registered() const;
 
  bool registered(const std::string&) const;
 
  bool registered(const Resource::Index&) const;
 
  void clear();
 
  ResourcePtr create(const std::string&, const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  ResourcePtr create(
    const Resource::Index&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  template<typename ResourceType>
  smtk::shared_ptr<ResourceType> create(const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  ResourcePtr create(
    const std::string&,
    const smtk::common::UUID&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  ResourcePtr create(
    const Resource::Index&,
    const smtk::common::UUID&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  template<typename ResourceType>
  smtk::shared_ptr<ResourceType> create(
    const smtk::common::UUID&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  ResourcePtr get(const smtk::common::UUID& id);
  ConstResourcePtr get(const smtk::common::UUID& id) const;
 
  template<typename ResourceType>
  smtk::shared_ptr<ResourceType> get(const smtk::common::UUID&);
  template<typename ResourceType>
  smtk::shared_ptr<const ResourceType> get(const smtk::common::UUID&) const;
 
  ResourcePtr get(const std::string& url);
  ConstResourcePtr get(const std::string& url) const;
 
  template<typename ResourceType>
  smtk::shared_ptr<ResourceType> get(const std::string& url);
  template<typename ResourceType>
  smtk::shared_ptr<const ResourceType> get(const std::string& url) const;
 
  std::set<ResourcePtr> find(const std::string& typeName);
 
  std::set<ResourcePtr> find(const Resource::Index& typeIndex, bool strict = false);
 
  template<typename ResourceType>
  std::set<smtk::shared_ptr<ResourceType>> find();
 
  ResourcePtr read(
    const std::string&,
    const std::string&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  ResourcePtr read(
    const Resource::Index&,
    const std::string&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  template<typename ResourceType>
  smtk::shared_ptr<ResourceType> read(
    const std::string&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  bool write(const ResourcePtr&, const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  bool write(
    const ResourcePtr&,
    const std::string&,
    const std::shared_ptr<smtk::common::Managers>& = nullptr);
 
  bool add(const Resource::Index&, const ResourcePtr&);
 
  template<typename ResourceType>
  bool add(const smtk::shared_ptr<ResourceType>&);
 
  bool add(const ResourcePtr&);
 
  bool remove(const ResourcePtr&);
 
  bool addLegacyReader(const std::string&, const std::function<ResourcePtr(const std::string&)>&);
 
  void reviseId(const Resource::SetId& source, const Resource::SetId& destination);
 
  void reviseLocation(
    const smtk::common::UUID& uid,
    const Resource::SetLocation& source,
    const Resource::SetLocation& destination);
 
  smtk::common::Termination visit(const ResourceVisitor& visitor) const;
 
  bool empty() const
  {
    ScopedLockGuard guard(m_lock, LockType::Read);
    return m_resources.empty();
  }
 
  std::size_t size() const
  {
    ScopedLockGuard guard(m_lock, LockType::Read);
    return m_resources.size();
  }
 
  PersistentObjectPtr search(const smtk::common::UUID& uid) const;
 
  MetadataContainer& metadata() { return m_metadata; }
 
  Observers& observers() { return m_observers; }
  const Observers& observers() const { return m_observers; }
 
  Metadata::Observers& metadataObservers() { return m_metadataObservers; }
  const Metadata::Observers& metadataObservers() const { return m_metadataObservers; }
 
  GarbageCollectorPtr garbageCollector() { return m_garbageCollector; }
 
private:
  Manager();
 
  Container m_resources;
 
  MetadataContainer m_metadata;
 
  Observers m_observers;
 
  Metadata::Observers m_metadataObservers;
 
  std::map<std::string, std::function<ResourcePtr(const std::string&)>> m_legacyReaders;
 
  GarbageCollectorPtr m_garbageCollector;
 
  mutable Lock m_lock;
};
 
template<typename ResourceType>
bool Manager::unregisterResource()
{
  return this->unregisterResource(std::type_index(typeid(ResourceType)).hash_code());
}
 
template<typename ResourceType>
bool Manager::registered() const
{
  return this->registered(std::type_index(typeid(ResourceType)).hash_code());
}
 
template<typename ResourceType>
smtk::shared_ptr<ResourceType> Manager::create(
  const std::shared_ptr<smtk::common::Managers>& managers)
{
  return smtk::static_pointer_cast<ResourceType>(
    this->create(std::type_index(typeid(ResourceType)).hash_code(), managers));
}
 
template<typename ResourceType>
smtk::shared_ptr<ResourceType> Manager::create(
  const smtk::common::UUID& id,
  const std::shared_ptr<smtk::common::Managers>& managers)
{
  return smtk::static_pointer_cast<ResourceType>(
    this->create(std::type_index(typeid(ResourceType)).hash_code(), id, managers));
}
 
template<typename ResourceType>
smtk::shared_ptr<ResourceType> Manager::get(const smtk::common::UUID& id)
{
  return smtk::static_pointer_cast<ResourceType>(this->get(id));
}
 
template<typename ResourceType>
smtk::shared_ptr<const ResourceType> Manager::get(const smtk::common::UUID& id) const
{
  return smtk::static_pointer_cast<const ResourceType>(this->get(id));
}
 
template<typename ResourceType>
smtk::shared_ptr<ResourceType> Manager::get(const std::string& url)
{
  return smtk::static_pointer_cast<ResourceType>(this->get(url));
}
 
template<typename ResourceType>
smtk::shared_ptr<const ResourceType> Manager::get(const std::string& url) const
{
  return smtk::static_pointer_cast<const ResourceType>(this->get(url));
}
 
template<typename ResourceType>
std::set<smtk::shared_ptr<ResourceType>> Manager::find()
{
  Resource::Index index(typeid(ResourceType).hash_code());
  std::set<Resource::Index> validIndices;
  for (const auto& metadatum : m_metadata)
  {
    if (metadatum.m_parentIndices.find(index) != metadatum.m_parentIndices.end())
    {
      validIndices.insert(metadatum.index());
    }
  }
 
  std::set<smtk::shared_ptr<ResourceType>> values;
 
  {
    ScopedLockGuard guard(m_lock, LockType::Read);
    typedef Container::index<IndexTag>::type ResourcesByIndex;
    ResourcesByIndex& resources = m_resources.get<IndexTag>();
    for (const auto& idx : validIndices)
    {
      auto resourceItRange = resources.equal_range(idx);
      for (auto& it = resourceItRange.first; it != resourceItRange.second; ++it)
      {
        values.insert(smtk::static_pointer_cast<ResourceType>(*it));
      }
    }
  }
 
  return values;
}
 
template<typename ResourceType>
smtk::shared_ptr<ResourceType> Manager::read(
  const std::string& url,
  const std::shared_ptr<smtk::common::Managers>& managers)
{
  return smtk::static_pointer_cast<ResourceType>(
    this->read(std::type_index(typeid(ResourceType)).hash_code(), url, managers));
}
 
template<typename ResourceType>
bool Manager::add(const smtk::shared_ptr<ResourceType>& resource)
{
  return this->add(std::type_index(typeid(ResourceType)).hash_code(), resource);
}
 
namespace detail
{
// For Resources that are derived from other Resources, we need a means to
// extract the Indices for both the Resource and its parent Resources. This
// information is subsequently used for retrieving derived Resources from
// queries made for parent Resources. We accomplish this by requiring that
// derived Resources define a ParentResource that relates to its parent
// resource. The chain of derived Resources is then recursively iterated, and
// each parent Resource::Index is added to the Resource Metadata's associated
// indices.
 
// A compile-time test to check whether or not a class has a ParentResource
// defined.
template<typename T>
class is_derived_resource
{
  class No
  {
  };
  class Yes
  {
    No no[2];
  };
 
  template<typename C>
  static Yes Test(typename C::ParentResource*);
  template<typename C>
  static No Test(...);
 
public:
  enum
  {
    value = sizeof(Test<T>(nullptr)) == sizeof(Yes)
  };
};
 
// The signature for our index generator has two template parameters.
template<typename ResourceType, bool derived_resource>
struct resource_index_set_generator;
 
// This partial template specialization deals with the case where
// <ResourceType> is not derived from another Resource. In this case, only the
// indices for the Resource and smtk::resource::Resource are added to the set of
// associated indices.
template<typename ResourceType>
struct resource_index_set_generator<ResourceType, false>
{
  static std::set<Resource::Index> indices()
  {
    std::set<Resource::Index> indices;
    indices.insert(typeid(ResourceType).hash_code());
    indices.insert(smtk::resource::Resource::type_index);
 
    return indices;
  }
};
 
// This partial template specialization deals with the case where
// <ResourceType> is derived from another Resource. In this case, we
// recursively add the parent Resource's associated indices to the returned
// set.
template<typename ResourceType>
struct resource_index_set_generator<ResourceType, true>
{
  static std::set<Resource::Index> indices()
  {
    std::set<Resource::Index> indices;
    indices.insert(std::type_index(typeid(ResourceType)).hash_code());
 
    std::set<Resource::Index> parentIndices = resource_index_set_generator<
      typename ResourceType::ParentResource,
      is_derived_resource<typename ResourceType::ParentResource>::value>::indices();
    indices.insert(parentIndices.begin(), parentIndices.end());
 
    return indices;
  }
};
} // namespace detail
 
template<typename ResourceType>
bool Manager::registerResource(
  const std::function<
    ResourcePtr(const std::string&, const std::shared_ptr<smtk::common::Managers>&)>& read,
  const std::function<bool(const ResourcePtr&, const std::shared_ptr<smtk::common::Managers>&)>&
    write,
  const std::function<
    ResourcePtr(const smtk::common::UUID&, const std::shared_ptr<smtk::common::Managers>&)>& create)
{
  // For standard Resources, the metadata is comprised of the following:
  // Type Name: either the "type_name" field or (if the former does not exist)
  //            the typeName() value
  // Index: the hash of the type_index
  // Parent Indices: a set of indices constructed by traversing parent resources
  //                 (defined using the typedef "ParentResource")
  // Create Functor: either a user-defined functor or the default
  //                 ResourceType::create method
  // Read Functor:   either a user-defined functor or the nullptr
  // Write Functor:   either a user-defined functor or the nullptr
 
  return Manager::registerResource(Metadata(
    smtk::common::typeName<ResourceType>(), std::type_index(typeid(ResourceType)).hash_code(),
    (detail::resource_index_set_generator<ResourceType,
      detail::is_derived_resource<ResourceType>::value>::indices()),
    (create ? create : [](const smtk::common::UUID& id, const std::shared_ptr<smtk::common::Managers>&) {
      Resource::Ptr resource = ResourceType::create();
      resource->setId(id);
      return resource;
    }),
    (read ? read : [](const std::string&, const std::shared_ptr<smtk::common::Managers>&){ return ResourcePtr(); }),
    (write ? write : [](const ResourcePtr&, const std::shared_ptr<smtk::common::Managers>&){ return false; })));
}
} // namespace resource
} // namespace smtk
 
#endif // smtk_resource_Manager_h