Properties.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_Properties_h
#define smtk_resource_Properties_h
 
#include "smtk/CoreExports.h"
#include "smtk/common/TypeMap.h"
#include "smtk/common/UUID.h"
#include "smtk/string/Token.h"
 
#include "smtk/common/json/jsonUUID.h"
#include "smtk/string/json/jsonToken.h"
 
#include "smtk/resource/json/jsonPropertyCoordinateFrame.h"
#include "smtk/resource/properties/CoordinateFrame.h"
 
#include <algorithm>
 
namespace smtk
{
namespace resource
{
namespace detail
{
 
class SMTKCORE_EXPORT PropertiesBase
{
public:
  virtual ~PropertiesBase() = default;
 
  virtual std::size_t eraseId(const smtk::common::UUID&) = 0;
};
 
template<typename Type>
class PropertiesOfType;
 
template<typename Type>
class PropertiesOfType<std::unordered_map<smtk::common::UUID, Type>>
  : public smtk::common::TypeMapEntry<std::string, std::unordered_map<smtk::common::UUID, Type>>
  , public PropertiesBase
{
  friend class Properties;
  PropertiesOfType()
    : smtk::common::TypeMapEntry<std::string, std::unordered_map<smtk::common::UUID, Type>>()
    , PropertiesBase()
  {
  }
 
public:
  std::size_t eraseId(const smtk::common::UUID& id) override
  {
    std::size_t count = 0;
    for (auto& pair : this->data())
    {
      count += pair.second.erase(id);
    }
    return count;
  }
};
 
class SMTKCORE_EXPORT Properties : public smtk::common::TypeMapBase<std::string>
{
public:
  // MSVC sees `= default` as a duplicate of the template version.
  // NOLINTNEXTLINE(modernize-use-equals-default)
  Properties() {}
 
  template<typename List>
  Properties()
  {
    insertPropertyTypes<List>();
  }
 
  template<typename List>
  Properties(identity<List>)
  {
    insertPropertyTypes<List>();
  }
 
  std::size_t eraseId(const smtk::common::UUID& id)
  {
    std::size_t count = 0;
    auto& map = this->data();
    for (auto& pair : map)
    {
      count += dynamic_cast<PropertiesBase*>(pair.second)->eraseId(id);
    }
    return count;
  }
 
  template<typename Type>
  std::size_t eraseIdForType(const smtk::common::UUID& id)
  {
    return dynamic_cast<PropertiesBase&>(this->get<Type>()).eraseId(id);
  }
 
  // TODO: Putting the following two methods in the public API breaks RAII.
  // There needs to be a way for a derived resource to augment its types of
  // properties, though.
  template<typename Type>
  void insertPropertyType()
  {
    std::string key = smtk::common::typeName<Type>();
    auto it = data().find(key);
    if (it == data().end())
    {
      it = data().emplace(std::make_pair(key, new detail::PropertiesOfType<Type>)).first;
    }
  }
 
  template<typename Tuple>
  void insertPropertyTypes()
  {
    Properties::insertPropertyTypes<0, Tuple>();
  }
 
private:
  template<std::size_t I, typename Tuple>
  inline typename std::enable_if<I != std::tuple_size<Tuple>::value>::type insertPropertyTypes()
  {
    this->insertPropertyType<typename std::tuple_element<I, Tuple>::type>();
    Properties::insertPropertyTypes<I + 1, Tuple>();
  }
 
  template<std::size_t I, typename Tuple>
  inline typename std::enable_if<I == std::tuple_size<Tuple>::value>::type insertPropertyTypes()
  {
  }
};
} // namespace detail
 
class Component;
class Resource;
class Properties;
 
template<typename Type>
class ConstPropertiesOfType
{
  using IndexedType = std::unordered_map<smtk::common::UUID, Type>;
 
  friend class Properties;
  ConstPropertiesOfType(
    const smtk::common::UUID& id,
    const detail::PropertiesOfType<IndexedType>& properties)
    : m_id(id)
    , m_properties(properties)
  {
  }
 
public:
  bool contains(const std::string& key) const
  {
    if (!m_properties.contains(key))
    {
      return false;
    }
    const std::unordered_map<smtk::common::UUID, Type>& data = get(key);
    return (data.find(m_id) != data.end());
  }
 
  const Type& at(const std::string& key) const { return get(key).at(m_id); }
 
  bool empty() const
  {
    using PropertyDataMap =
      std::unordered_map<std::string, std::unordered_map<smtk::common::UUID, Type>>;
    const PropertyDataMap& data = m_properties.data();
    return std::all_of(
      data.begin(), data.end(), [this](const typename PropertyDataMap::value_type& pair) {
        return pair.second.find(m_id) == pair.second.end();
      });
  }
 
  std::set<std::string> keys() const
  {
    std::set<std::string> keys;
    for (auto& pair : m_properties.data())
    {
      if (pair.second.find(m_id) != pair.second.end())
      {
        keys.insert(pair.first);
      }
    }
    return keys;
  }
 
private:
  const std::unordered_map<smtk::common::UUID, Type>& get(const std::string& key) const
  {
    return m_properties.at(key);
  }
 
  const smtk::common::UUID& m_id;
  const detail::PropertiesOfType<IndexedType>& m_properties;
};
 
template<typename Type>
class PropertiesOfType
{
  using IndexedType = std::unordered_map<smtk::common::UUID, Type>;
 
  friend class Properties;
  PropertiesOfType(const smtk::common::UUID& id, detail::PropertiesOfType<IndexedType>& properties)
    : m_id(id)
    , m_properties(properties)
  {
  }
 
public:
  bool contains(const std::string& key) const
  {
    if (!m_properties.contains(key))
    {
      return false;
    }
    const std::unordered_map<smtk::common::UUID, Type>& data = get(key);
    return (data.find(m_id) != data.end());
  }
 
  bool insert(const std::string& key, const Type& value)
  {
    return get(key).insert(std::make_pair(m_id, value)).second;
  }
 
  bool emplace(const std::string& key, Type&& value)
  {
    return get(key).emplace(std::make_pair(m_id, std::move(value))).second;
  }
 
  void erase(const std::string& key)
  {
    get(key).erase(m_id);
    if (get(key).empty())
    {
      m_properties.erase(key);
    }
  }
 
  Type& operator[](const std::string& key) { return get(key)[m_id]; }
 
  Type& at(const std::string& key) { return get(key).at(m_id); }
 
  const Type& at(const std::string& key) const { return get(key).at(m_id); }
 
  bool empty() const
  {
    for (auto& pair : m_properties.data())
    {
      if (pair.second.find(m_id) != pair.second.end())
      {
        return false;
      }
    }
    return true;
  }
 
  std::size_t clear()
  {
    std::size_t count = m_properties.eraseId(m_id);
    return count;
  }
 
  std::set<std::string> keys() const
  {
    std::set<std::string> keys;
    for (auto& pair : m_properties.data())
    {
      if (pair.second.find(m_id) != pair.second.end())
      {
        keys.insert(pair.first);
      }
    }
    return keys;
  }
 
private:
  const std::unordered_map<smtk::common::UUID, Type>& get(const std::string& key) const
  {
    return m_properties.at(key);
  }
  std::unordered_map<smtk::common::UUID, Type>& get(const std::string& key)
  {
    if (!m_properties.contains(key))
    {
      m_properties.emplace(key, typename detail::PropertiesOfType<IndexedType>::mapped_type());
    }
    return m_properties.at(key);
  }
 
  const smtk::common::UUID& m_id;
  detail::PropertiesOfType<IndexedType>& m_properties;
};
 
class SMTKCORE_EXPORT Properties
{
public:
  template<typename Type>
  using Indexed = std::unordered_map<smtk::common::UUID, Type>;
 
  template<typename Type>
  bool contains(const std::string& key) const
  {
    return get<Type>().contains(key);
  }
 
  template<typename Type>
  bool insert(const std::string& key, const Type& value)
  {
    return get<Type>().insert(key, value);
  }
 
  template<typename Type>
  bool emplace(const std::string& key, Type&& value)
  {
    return get<Type>().emplace(key, std::forward<Type>(value));
  }
 
  template<typename Type>
  void erase(const std::string& key)
  {
    return get<Type>().erase(key);
  }
 
  template<typename Type>
  Type& at(const std::string& key)
  {
    return get<Type>().at(key);
  }
 
  template<typename Type>
  const Type& at(const std::string& key) const
  {
    return get<Type>().at(key);
  }
 
  template<typename Type>
  PropertiesOfType<Type> get()
  {
    return PropertiesOfType<Type>(
      id(),
      static_cast<detail::PropertiesOfType<Indexed<Type>>&>(properties().get<Indexed<Type>>()));
  }
 
  template<typename Type>
  const ConstPropertiesOfType<Type> get() const
  {
    return ConstPropertiesOfType<Type>(
      id(),
      static_cast<const detail::PropertiesOfType<Indexed<Type>>&>(
        properties().get<Indexed<Type>>()));
  }
 
  virtual std::size_t clear() = 0;
 
private:
  virtual const smtk::common::UUID& id() const = 0;
  virtual smtk::common::TypeMapBase<std::string>& properties() = 0;
  virtual const smtk::common::TypeMapBase<std::string>& properties() const = 0;
 
  struct EraseProperties
  {
    template<typename Data>
    void operator()(Data propertiesOfType, const smtk::common::UUID& uid, std::size_t& count)
    {
      std::cout << "Erase " << uid << " from " << propertiesOfType.keys().size() << "\n";
      count += propertiesOfType.clear();
    }
  };
 
  template<typename Tuple, typename Functor, typename... Args>
  void invoke(Args&&... args) const
  {
    smtk::resource::Properties::invokeFunctors<0, Tuple, Functor>(std::forward<Args>(args)...);
  }
 
  template<typename Tuple, typename Functor, typename... Args>
  void invoke(Args&&... args)
  {
    smtk::resource::Properties::invokeFunctors<0, Tuple, Functor>(std::forward<Args>(args)...);
  }
 
  // const version
  template<typename Entry, typename Functor, typename... Args>
  void invokeFunctor(Args&&... args) const
  {
    Functor f;
    f(std::forward<Args>(args)...);
  }
 
  // non-const version
  template<typename Entry, typename Functor, typename... Args>
  void invokeFunctor(Args&&... args)
  {
    Functor f;
    f(std::forward<Args>(args)...);
  }
 
  // const versions
  template<std::size_t I, typename Tuple, typename Functor, typename... Args>
  inline typename std::enable_if<I != std::tuple_size<Tuple>::value>::type invokeFunctors(
    Args&&... args) const
  {
    this->invokeFunctor<typename std::tuple_element<I, Tuple>::type, Functor>(
      // First argument is always PropertiesOfType<tuple_element<I, Tuple>>:
      this->template get<typename std::tuple_element<I, Tuple>::type>(),
      // Subsequent arguments are whatever is passed in:
      std::forward<Args>(args)...);
    smtk::resource::Properties::invokeFunctors<I + 1, Tuple, Functor>(std::forward<Args>(args)...);
  }
 
  // non-const version
  template<std::size_t I, typename Tuple, typename Functor, typename... Args>
  inline typename std::enable_if<I != std::tuple_size<Tuple>::value>::type invokeFunctors(
    Args&&... args)
  {
    this->invokeFunctor<typename std::tuple_element<I, Tuple>::type, Functor>(
      // First argument is always PropertiesOfType<tuple_element<I, Tuple>>:
      this->template get<typename std::tuple_element<I, Tuple>::type>(),
      // Subsequent arguments are whatever is passed in:
      std::forward<Args>(args)...);
    smtk::resource::Properties::invokeFunctors<I + 1, Tuple, Functor>(std::forward<Args>(args)...);
  }
 
  // This only needs a const version.
  template<std::size_t I, typename Tuple, typename Functor, typename... Args>
  inline typename std::enable_if<I == std::tuple_size<Tuple>::value>::type invokeFunctors(
    Args&&...) const
  {
  }
 
protected:
  template<typename PropertyTypeTuple>
  std::size_t clearInternal(const smtk::common::UUID& uid)
  {
    std::size_t count = 0;
    // auto& propertiesByTypeThenId = this->properties();
    this->invoke<PropertyTypeTuple, EraseProperties>(uid, count);
    return count;
  }
};
 
namespace detail
{
class SMTKCORE_EXPORT ResourceProperties : public smtk::resource::Properties
{
  friend Resource;
 
  typedef detail::Properties ResourcePropertiesData;
 
public:
  typedef std::tuple<
    Indexed<bool>,
    Indexed<int>,
    Indexed<long>,
    Indexed<double>,
    Indexed<std::string>,
    Indexed<smtk::string::Token>,
    Indexed<std::set<smtk::string::Token>>,
    Indexed<std::set<int>>,
    Indexed<std::vector<bool>>,
    Indexed<std::vector<int>>,
    Indexed<std::vector<long>>,
    Indexed<std::vector<double>>,
    Indexed<std::vector<std::string>>,
    Indexed<smtk::resource::properties::CoordinateFrame>,
    Indexed<std::map<std::string, smtk::resource::properties::CoordinateFrame>>>
    PropertyTypes;
 
  ResourcePropertiesData& data() { return m_data; }
  const ResourcePropertiesData& data() const { return m_data; }
 
  // TODO: Putting the following method in the public API breaks RAII. There
  // needs to be a way for a derived resource to augment its types of
  // properties, though.
  template<typename Type>
  void insertPropertyType()
  {
    m_data.insertPropertyType<Indexed<Type>>();
  }
 
  // Remove all properties on the resource
  std::size_t clear() override
  {
    std::size_t count = this->clearInternal<PropertyTypes>(this->id());
    return count;
  }
 
private:
  ResourceProperties(Resource* resource);
 
  const smtk::common::UUID& id() const override;
  smtk::common::TypeMapBase<std::string>& properties() override { return m_data; }
  const smtk::common::TypeMapBase<std::string>& properties() const override { return m_data; }
 
  Resource* m_resource;
  ResourcePropertiesData m_data;
};
 
class SMTKCORE_EXPORT ComponentProperties : public smtk::resource::Properties
{
public:
  // Remove all properties on the resource
  std::size_t clear() override
  {
    std::size_t count = this->clearInternal<ResourceProperties::PropertyTypes>(this->id());
    return count;
  }
 
protected:
  friend Component;
 
  ComponentProperties(const Component* component);
  ~ComponentProperties();
 
  const smtk::common::UUID& id() const override;
  smtk::common::TypeMapBase<std::string>& properties() override;
  const smtk::common::TypeMapBase<std::string>& properties() const override;
 
  const Component* m_component;
};
} // namespace detail
} // namespace resource
} // namespace smtk
 
#endif