pool.h

// Copyright 2018-2019 Delft University of Technology
//
// 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.
 
#pragma once
 
#include <string>
#include <vector>
#include <memory>
#include <utility>
#include <optional>
 
#include "cerata/logging.h"
#include "cerata/node.h"
#include "cerata/literal.h"
 
namespace cerata {
 
// Forward decl.
class Type;
class Component;
 
template<typename T>
class Pool {
 public:
  void Add(const std::shared_ptr<T> &object) {
    for (const auto &existing_object : objects_) {
      if (existing_object->name() == object->name()) {
        CERATA_LOG(FATAL, "Object " + PoolTypeToString(*existing_object) + " already exists in pool.");
      }
    }
    objects_.push_back(object);
  }
 
  std::optional<T *> Get(const std::string &name) {
    // Check for potential duplicate
    for (const auto &existing_object : objects_) {
      if (existing_object->name() == name) {
        return existing_object.get();
      }
    }
    return std::nullopt;
  }
 
  void Clear() {
    objects_.clear();
  }
 
 protected:
  std::vector<std::shared_ptr<T>> objects_;
 
 private:
  std::string PoolTypeToString(const T &object) {
    return object.ToString();
  }
};
 
class TypePool : public Pool<Type> {};
 
class ComponentPool : public Pool<Component> {};
 
inline TypePool *default_type_pool() {
  static TypePool pool;
  return &pool;
}
 
inline ComponentPool *default_component_pool() {
  static ComponentPool pool;
  return &pool;
}
 
class NodePool : public Pool<Node> {
 public:
  template<typename LitType>
  std::shared_ptr<Literal> GetLiteral(LitType value) {
    // Attempt to find and return an already existing literal
    for (const auto &node : objects_) {
      if (node->IsLiteral()) {
        auto lit_node = std::dynamic_pointer_cast<Literal>(node);
        if (lit_node->storage_type() == StorageTypeOf<LitType>()) {
          auto raw_value = RawValueOf<LitType>(*lit_node);
          if (raw_value == value) {
            return lit_node;
          }
        }
      }
    }
    // No literal found, make a new one.
    std::shared_ptr<Literal> ret = Literal::Make(value);
    Add(ret);
    return ret;
  }
};
 
inline NodePool *default_node_pool() {
  static NodePool pool;
  return &pool;
}
 
// Convenience functions for fast access to literals in the default node pool.
 
inline Literal *rintl(int64_t i) {
  return default_node_pool()->GetLiteral(i).get();
}
inline std::shared_ptr<Literal> intl(int64_t i) {
  return default_node_pool()->GetLiteral(i);
}
 
inline Literal *rstrl(std::string str) { return default_node_pool()->GetLiteral<std::string>(std::move(str)).get(); }
inline std::shared_ptr<Literal> strl(std::string str) {
  return default_node_pool()->GetLiteral<std::string>(std::move(str));
}
 
inline std::shared_ptr<Literal> booll(bool value) {
  return default_node_pool()->GetLiteral<bool>(value);
}
 
}  // namespace cerata