element_type_registry.h

Go to the documentation of this file.

#pragma once
 
#include <util/irep/type.h>
 
#include <array>
#include <cassert>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
class type_handler;

enum class type_slot
{
  elements,
  dict_value_types,
  dict_value_list_elems,
  slot_count,
};

class element_type_registry
{
public:
  using entry = std::pair<std::string, typet>;
  using entries = std::vector<entry>;
 
  void record(
    const std::string &id,
    const std::string &elem_id,
    const typet &elem_type,
    type_slot slot = type_slot::elements);

  void set_element_type(
    const std::string &id,
    size_t index,
    const typet &elem_type,
    type_slot slot = type_slot::elements);

  void assign(
    const std::string &id,
    const typet &elem_type,
    type_slot slot = type_slot::elements);

  void assign_from(
    const std::string &from,
    const std::string &to,
    type_slot slot = type_slot::elements);

  void append_from(
    const std::string &from,
    const std::string &to,
    size_t times = 1,
    type_slot slot = type_slot::elements);

  void pop_last(const std::string &id, type_slot slot = type_slot::elements);

  void reverse(const std::string &id, type_slot slot = type_slot::elements);

  void replace(
    const std::string &id,
    size_t index,
    const std::string &elem_id,
    const typet &elem_type,
    type_slot slot = type_slot::elements);
 
  size_t
  size(const std::string &id, type_slot slot = type_slot::elements) const;

  const entries *
  find(const std::string &id, type_slot slot = type_slot::elements) const;

  typet element_type(
    const std::string &id,
    size_t index = 0,
    type_slot slot = type_slot::elements) const;

  typet last_element_type(
    const std::string &id,
    type_slot slot = type_slot::elements) const;

  std::string element_id(
    const std::string &id,
    size_t index,
    type_slot slot = type_slot::elements) const;

  bool has_mixed_numeric(
    const std::string &id,
    type_slot slot = type_slot::elements) const;

  bool mixes_str_and_number(
    const std::string &id,
    type_slot slot = type_slot::elements) const;

  typet uniform_element_type(
    const std::string &id,
    type_slot slot = type_slot::elements) const;

  typet numeric_element_type(
    const std::string &id,
    type_slot slot = type_slot::elements) const;

  typet homogeneous_element_type(
    const std::string &id,
    const std::string &func_name,
    type_slot slot = type_slot::elements) const;

  typet memoized_pop_type(const std::string &site) const;
 
  void memoize_pop_type(const std::string &site, const typet &elem_type);

  void type_flags(
    const std::string &id,
    const type_handler &th,
    int &type_flag,
    size_t &float_type_id,
    type_slot slot = type_slot::elements) const;
 
private:
  using slot_map = std::unordered_map<std::string, entries>;
 
  slot_map &map_for(type_slot slot)
  {
    assert(slot < type_slot::slot_count);
    return maps_[static_cast<size_t>(slot)];
  }
 
  const slot_map &map_for(type_slot slot) const
  {
    assert(slot < type_slot::slot_count);
    return maps_[static_cast<size_t>(slot)];
  }
 
  std::array<slot_map, static_cast<size_t>(type_slot::slot_count)> maps_;

  std::unordered_map<std::string, typet> pop_memo_;
};