types_nodes_map.h

Go to the documentation of this file.

// NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
// software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
// derivative works of the software or any portion of the software, and you may copy and distribute such modifications
// or works. Modified works should carry a notice stating that you changed the software and should note the date and
// nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
// source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
// WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
// CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
// THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
// are solely responsible for determining the appropriateness of using and distributing the software and you assume
// all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
// with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of
// operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
// damage to property. The software developed by NIST employees is not subject to copyright protection within the
// United States.
 
#ifndef HEDGEHOG_CX_TYPES_NODES_MAP_H_
#define HEDGEHOG_CX_TYPES_NODES_MAP_H_
 
#ifdef HH_ENABLE_HH_CX
 
#include <vector>
#include <algorithm>
#include "../behavior/abstract_node.h"
 
namespace hh_cx {
 
namespace tool {
 
class TypesNodesMap {
 private:
  std::vector<std::string> types_{}; 
  std::vector<std::vector<behavior::AbstractNode const *>> nodes_{}; 
  std::vector<std::vector<std::string>> nodesName_{}; 
 
 public:
  constexpr TypesNodesMap() = default;
  constexpr ~TypesNodesMap() = default;
 
  [[nodiscard]] constexpr size_t nbTypes() const { return types_.size(); }
 
  [[nodiscard]] constexpr std::vector<std::string> const &types() const { return types_; }
 
  [[nodiscard]] constexpr std::vector<std::vector<behavior::AbstractNode const *>> const &nodes() const {
    return nodes_;
  }
 
  [[nodiscard]] constexpr std::vector<std::vector<std::string>> const &nodesName() const { return nodesName_; }
 
  [[nodiscard]] constexpr std::vector<behavior::AbstractNode const *> nodes(std::string const &type) const {
    auto posIt = std::find(types_.cbegin(), types_.cend(), type);
    if (posIt != types_.cend()) { return nodes_.at(static_cast<unsigned long>(std::distance(types_.cbegin(), posIt))); }
    else { return {}; }
  }
 
  constexpr void clear() {
    types_.clear();
    for (auto &nodes : nodes_) { nodes.clear(); }
    for (auto &nodesName : nodesName_) { nodesName.clear(); }
  }
 
  constexpr void insert(std::string const &type, hh_cx::behavior::AbstractNode const *node) {
    auto posIt = std::find(types_.cbegin(), types_.cend(), type);
    if (posIt != types_.cend()) {
      nodes_.at(static_cast<unsigned long>(std::distance(types_.cbegin(), posIt))).push_back(node);
      nodesName_.at(static_cast<unsigned long>(std::distance(types_.cbegin(), posIt))).push_back(node->name());
    } else {
      types_.push_back(type);
      nodes_.push_back(std::vector<behavior::AbstractNode const *>{node});
      nodesName_.push_back(std::vector<std::string>{node->name()});
    }
  }
 
  [[nodiscard]] constexpr bool contains(std::string const &type) const {
    return std::find(types_.cbegin(), types_.cend(), type) != types_.cend();
  }
 
  [[nodiscard]] constexpr bool contains(std::string const &type, hh_cx::behavior::AbstractNode const *node) const {
    if (contains(type)) {
      auto nodes = this->nodes(type);
      if (std::find(nodes.cbegin(), nodes.cend(), node) == nodes.cend()) { return false; }
      else { return true; }
    } else { return false; }
  }
 
  [[nodiscard]] constexpr size_t maxTypeSize() const {
    if(types_.empty()) { return 0; }
    return std::max_element(
        types_.cbegin(), types_.cend(),
        [](auto const &lhs, auto const &rhs) { return lhs.size() < rhs.size(); }
    )->size();
  }
 
  [[nodiscard]] constexpr size_t maxNumberNodes() const {
    if(nodes_.empty()) {
      return 0;
    }
    return std::max_element(
        nodes_.cbegin(), nodes_.cend(),
        [](auto const &lhs, auto const &rhs) { return lhs.size() < rhs.size(); }
    )->size();
  }
 
  [[nodiscard]] constexpr size_t maxSizeName() const {
    size_t ret = 0;
    for (auto const &type : nodesName_) {
      for (auto const &nodeName : type) {
        if (nodeName.size() > ret) { ret = nodeName.size(); }
      }
    }
    return ret;
  }
};
}
}
 
#endif //HH_ENABLE_HH_CX
#endif //HEDGEHOG_CX_TYPES_NODES_MAP_H_