container.h

Go to the documentation of this file.

#ifndef ILANG_UTIL_CONTAINER_H__
#define ILANG_UTIL_CONTAINER_H__

#include <map>
#include <memory>
#include <set>
#include <vector>

namespace ilang {

typedef enum { END, FOUND } KeyVecItVal;

template <class Key, class T> class KeyVecIt {
public:
  typedef std::shared_ptr<KeyVecIt> KeyVecItPtr;

  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  KeyVecIt() : result(KeyVecItVal::END), first(), second() {}

  // ------------------------- METHODS -------------------------------------- //
  friend bool operator==(const KeyVecItPtr lhs, const KeyVecItPtr rhs) {
    return lhs->result == rhs->result;
  }
  friend bool operator!=(const KeyVecItPtr lhs, const KeyVecItPtr rhs) {
    return lhs->result != rhs->result;
  }

  // ------------------------- MEMBERS -------------------------------------- //
  KeyVecItVal result;
  Key first;
  T second;

}; // KeyVecIt

template <class Key, class T> class KeyVec {
public:
  typedef std::shared_ptr<KeyVecIt<Key, T>> KeyVecItPtr;

  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  KeyVec() {
    it_ = std::make_shared<KeyVecIt<Key, T>>();
    clear();
  }
  ~KeyVec() { clear(); }

  // ------------------------- METHODS -------------------------------------- //
  bool push_back(const Key& key, const T& data) {
    auto idx = vec_.size();
    auto [it, status] = map_.try_emplace(key, idx);
    if (status) {
      vec_.push_back(data);
    }
    return status;
  }

  T operator[](const size_t& idx) const { return vec_.at(idx); }

  size_t size() const { return vec_.size(); }

  bool empty() const { return size() == 0; }

  void clear() {
    vec_.clear();
    map_.clear();
  }

  KeyVecItPtr find(const Key& key) const {
    auto pos = map_.find(key);
    if (pos == map_.end())
      return end_;
    else {
      auto idx = pos->second;
      T data = vec_[idx];
      it_->result = KeyVecItVal::FOUND;
      it_->first = key;
      it_->second = data;
      return it_;
    }
  }

  KeyVecItPtr end() const { return end_; }

private:
  // ------------------------- MEMBERS -------------------------------------- //
  std::vector<T> vec_;
  std::map<Key, size_t> map_;

  KeyVecItPtr it_;
  static KeyVecItPtr end_;
}; // class KeyVec

template <class Key, class T>
std::shared_ptr<KeyVecIt<Key, T>>
    KeyVec<Key, T>::end_ = std::make_shared<KeyVecIt<Key, T>>();

template <class Key, class T> class MapSet {
public:
  typedef std::set<T> SetT;

  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  MapSet() {}
  ~MapSet() {}

  // ------------------------- METHODS -------------------------------------- //
  void insert(const Key& k, const T& t) { map_[k].insert(t); }

  SetT get(const Key& k) const { return map_.at(k); }

  typename std::map<Key, std::set<T>>::iterator begin() { return map_.begin(); }

  typename std::map<Key, std::set<T>>::iterator end() { return map_.end(); }

private:
  std::map<Key, std::set<T>> map_;

}; // class MapSet

} // namespace ilang

#endif // ILANG_UTIL_CONTAINER_H__