TypeContainer.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_common_TypeContainer_h
#define smtk_common_TypeContainer_h
 
#include "smtk/CoreExports.h"
 
#include "smtk/SystemConfig.h"
 
#include "smtk/common/CompilerInformation.h"
#include "smtk/common/TypeName.h"
 
#include "smtk/string/Token.h"
 
#include <memory>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <unordered_map>
 
namespace smtk
{
namespace common
{
class SMTKCORE_EXPORT TypeContainer
{
  struct Wrapper
  {
    virtual ~Wrapper() = default;
    virtual std::unique_ptr<Wrapper> clone() const = 0;
  };
 
  template<typename Type>
  struct WrapperFor : Wrapper
  {
    template<typename... Args>
    WrapperFor(Args&&... v)
      : value(std::forward<Args>(v)...)
    {
    }
 
    std::unique_ptr<Wrapper> clone() const override
    {
#ifdef SMTK_HAVE_CXX_14
      return std::make_unique<WrapperFor<Type>>(std::make_unique<Type>(*value));
#else
      return std::unique_ptr<Wrapper>(new WrapperFor<Type>(new Type(*value)));
#endif
    }
 
    std::unique_ptr<Type> value;
  };
 
public:
  class BadTypeError : public std::out_of_range
  {
  public:
    BadTypeError(const std::string& typeName)
      : std::out_of_range("Type \"" + typeName + "\" not available in this container")
    {
    }
  };
 
  using KeyType = smtk::string::Hash;
 
  TypeContainer() = default;
 
  TypeContainer(const TypeContainer&);
 
  TypeContainer(TypeContainer&&) = default;
 
  TypeContainer& operator=(const TypeContainer&);
 
  TypeContainer& operator=(TypeContainer&&) = default;
 
  template<
    typename Arg,
    typename... Args,
    typename std::enable_if<!std::is_base_of<TypeContainer, Arg>::value, int>::type = 0>
  TypeContainer(const Arg& arg, const Args&... args)
  {
    insertAll(arg, args...);
  }
 
  virtual ~TypeContainer();
 
  template<typename Type>
  KeyType keyId() const
  {
    (void)this; // Prevent clang-tidy from complaining this could be class-static.
    std::string keyName = smtk::common::typeName<Type>();
    KeyType value = smtk::string::Token(keyName).id();
    return value;
  }
 
  template<typename Type>
  bool contains() const
  {
    return (m_container.find(this->keyId<Type>()) != m_container.end());
  }
 
  template<typename Type>
  bool insert(const Type& value)
  {
    return m_container
      .emplace(std::make_pair(
        this->keyId<Type>(),
#ifdef SMTK_HAVE_CXX_14
        std::make_unique<WrapperFor<Type>>(std::make_unique<Type>(value))
#else
        std::unique_ptr<Wrapper>(new WrapperFor<Type>(std::unique_ptr<Type>(new Type((value)))))
#endif
          ))
      .second;
  }
 
  template<typename Type>
  bool insert_or_assign(const Type& value)
  {
    if (this->contains<Type>())
    {
      this->erase<Type>();
    }
    return this->insert<Type>(value);
  }
 
  template<typename Type, typename... Args>
  bool emplace(Args&&... args)
  {
    return m_container
      .emplace(std::make_pair(
        this->keyId<Type>(),
#ifdef SMTK_HAVE_CXX_14
        std::make_unique<WrapperFor<Type>>(std::make_unique<Type>(std::forward<Args>(args)...))
#else
        std::unique_ptr<Wrapper>(
          new WrapperFor<Type>(std::unique_ptr<Type>(new Type(std::forward<Args>(args)...))))
#endif
          ))
      .second;
  }
 
  template<typename Type>
  const Type& get() const
  {
    auto search = m_container.find(this->keyId<Type>());
    if (search == m_container.end())
    {
      throw BadTypeError(smtk::common::typeName<Type>());
    }
 
    return *(static_cast<WrapperFor<Type>*>(search->second.get()))->value;
  }
 
  template<typename Type>
  typename std::enable_if<std::is_default_constructible<Type>::value, Type&>::type get() noexcept
  {
    auto search = m_container.find(this->keyId<Type>());
    if (search == m_container.end())
    {
      search = m_container
                 .emplace(std::make_pair(
                   this->keyId<Type>(),
#ifdef SMTK_HAVE_CXX_14
                   std::make_unique<WrapperFor<Type>>(std::make_unique<Type>())
#else
                   std::unique_ptr<Wrapper>(new WrapperFor<Type>(std::unique_ptr<Type>(new Type)))
#endif
                     ))
                 .first;
    }
 
    return *(static_cast<WrapperFor<Type>*>(search->second.get()))->value;
  }
 
  template<typename Type>
  typename std::enable_if<!std::is_default_constructible<Type>::value, Type&>::type get()
  {
    auto search = m_container.find(this->keyId<Type>());
    if (search == m_container.end())
    {
      throw BadTypeError(smtk::common::typeName<Type>());
    }
 
    return *(static_cast<WrapperFor<Type>*>(search->second.get()))->value;
  }
 
  template<typename Type>
  bool erase()
  {
    return m_container.erase(this->keyId<Type>()) > 0;
  }
 
  bool empty() const noexcept { return m_container.empty(); }
 
  std::size_t size() const noexcept { return m_container.size(); }
 
  void clear() noexcept { m_container.clear(); }
 
  std::set<smtk::string::Token> keys() const
  {
    std::set<smtk::string::Token> result;
    for (const auto& entry : m_container)
    {
      try
      {
        result.insert(smtk::string::Token::fromHash(entry.first));
      }
      catch (std::invalid_argument&)
      {
        // Ignore entries with no matching string.
      }
    }
    return result;
  }
 
private:
  template<typename Arg, typename... Args>
  typename std::enable_if<!std::is_base_of<TypeContainer, Arg>::value, bool>::type insertAll(
    const Arg& arg,
    const Args&... args)
  {
    return insert<Arg>(arg) && insertAll(args...);
  }
  bool insertAll() { return true; }
 
  std::unordered_map<std::size_t, std::unique_ptr<Wrapper>> m_container;
};
} // namespace common
} // namespace smtk
 
#endif