UniverseDataBase.h

Go to the documentation of this file.

/*
 * Copyright 2020 IFPEN-CEA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#pragma once
 
#include <list>
#include <utility>
#include <vector>
 
#include <alien/utils/Precomp.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ALIEN_EXPORT UniverseDataBase final
{
 public:
  class IKey
  {
   protected:
    IKey() {}
 
   public:
    virtual ~IKey() {}
 
   private:
    IKey(const IKey&) = delete;
 
    IKey(IKey&&) = delete;
 
    void operator=(const IKey&) = delete;
 
    void operator=(IKey&&) = delete;
  };

  class IObject
  {
   protected:
    IObject() {}
 
   public:
    virtual ~IObject() {}
 
   private:
    IObject(const IObject&) = delete;
 
    IObject(IObject&&) = delete;
 
    void operator=(const IObject&) = delete;
 
    void operator=(IObject&&) = delete;
  };
 
 private:
  template <typename T>
  using key_type =
  typename std::conditional<std::is_copy_constructible<T>::value, T, T&>::type;

  template <typename T>
  struct Key : public IKey
  {
    virtual ~Key() {}

    Key(T&& t)
    : value(std::move(t))
    {}

    T value;
  };

  template <typename T>
  struct Object : public IObject
  {
    virtual ~Object() {}

    Object(std::shared_ptr<T> v)
    : value(v)
    {}

    std::shared_ptr<T> value;
  };
 
 public:
  class ObjectList
  {
   public:
    ObjectList() {}

    template <typename U, typename... T>
    std::pair<std::shared_ptr<U>, bool> findOrCreate(T&... t)
    {
      using object_type = Object<U>;
      for (auto& o : m_objects) {
        auto _o = std::dynamic_pointer_cast<object_type>(o);
        if (_o) {
          return std::make_pair(_o->value, false);
        }
      }
      return std::make_pair(create<U>(t...), true);
    }

    template <typename U, typename... T>
    std::shared_ptr<U> create(T&... t)
    {
      auto u = std::make_shared<U>(t...);
      std::shared_ptr<IObject> o(new Object<U>(u));
      m_objects.push_back(o);
      return u;
    }
 
   private:
    std::list<std::shared_ptr<IObject>> m_objects;
  };
 
 public:
  UniverseDataBase() {}

  template <typename U, typename... T>
  std::pair<std::shared_ptr<U>, bool> findOrCreate(T&... t)
  {
    using type = std::tuple<key_type<T>...>;
    using key_type = Key<type>;
    type v{ t... };
    for (auto i = 0u; i < m_keys.size(); ++i) {
      auto _k = std::dynamic_pointer_cast<key_type>(m_keys[i]);
      if (_k && std::operator==(_k->value, v)) {
        return m_objects[i]->findOrCreate<U>(t...);
      }
    }
    m_keys.push_back(std::shared_ptr<IKey>(new key_type{ std::move(v) }));
    auto objects = std::make_shared<ObjectList>();
    m_objects.push_back(objects);
    return std::make_pair(objects->create<U>(t...), true);
  }
 
 private:
  std::vector<std::shared_ptr<IKey>> m_keys;
  std::vector<std::shared_ptr<ObjectList>> m_objects;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/