idef.h

#pragma once
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <vector>
 
template <typename T>
const T &ibound(const T &min,const T &val,const T &max) {
    if (val<min) return min;
    if (val>max) return max;
    return val;
}
 
inline int iround(const double &in) { return static_cast<int>(std::round(in)); }
 
template <typename T> class QVector;
 
template <typename T>
class IVector : public std::vector<T> {
  public:
    using std::vector<T>::vector;
    using base = std::vector<T>;
 
    operator QVector<T>();
 
    int size() const { return to<int>(base::size()); }
    void replace(int i,const T &value) { assert(i<size()); this->operator[](i) = value; }
    void remove(int i) { this->erase(this->begin()+i); }
    T value(int index,T def={}) const { if (index<0 or index>=size()) return def;  return this->at(index); }
    void insert(int index,const T &val) { this->base::insert(this->begin()+index,val); }
    bool contains(const T &val) const { auto i = std::find(this->begin(),this->end(),val);  return i!=this->end(); }
    bool isEmpty() const { return size()==0; }
    int indexOf(const T &val) const { auto i = std::find(this->begin(),this->end(),val);  if (i==this->end()) return -1;  return to<int>(i-this->begin()); }
    bool removeOne(const T &val) { auto i = std::find(this->begin(),this->end(),val);  if (i==this->end()) return false;  this->erase(i);  return true; }
    void removeAt(int i) { auto it = this->begin() + i;  this->erase(it); }
    void removeAll(const T &t) { auto iend = std::remove(this->begin(),this->end(),t);  this->erase(iend,this->end()); }
    void pop_front() { this->erase(this->begin()); }
    void append(const T &t) { this->push_back(t); }
    void append(const IVector<T> &v) { for (auto &v2 : v) append(v2); }
    const T &last() const { return this->back(); }
    void push_front(const T &t) { this->base::insert(this->begin(),t); }
    T &first() { return this->front(); }
    const T &first() const{ return this->front(); }
};
 
template <typename T> class QList;
 
template <typename T>
class IList : public std::vector<T> {
  public:
    using std::vector<T>::vector;
    //using iterator = typename std::vector<T>::iterator;
 
    operator QList<T>();
 
    //iterator begin() { return std::vector<T>::begin(); }
    int size() const { return to<int>(std::vector<T>::size()); }
    void removeAt(int i) { assert(i>=0); assert(i<size()); this->erase(this->begin()+i); }
    void removeAll(const T &t) { auto iend = std::remove(this->begin(),this->end(),t);  this->erase(iend,this->end()); }
    bool removeOne(const T &t) { auto i = std::find(this->begin(),this->end(),t);  if (i==this->end()) return false; this->erase(i); return true; }
    void operator+=(const T &t) { this->push_back(t); }
    void operator+=(const IList<T> &t) { for (auto &v : t) this->push_back(v); }
    T value(int index,const T &def={}) const { if (index<0 or index>=this->size()) return def;  return this->at(index); }
    bool contains(const T &val) const { return std::find(this->begin(),this->end(),val)!=this->end(); }
    void append(const T &val) { this->push_back(val); }
    void prepend(const T &val) { push_front(val); }
    bool isEmpty() const { return size()==0; }
    void pop_front() { this->erase(this->begin()); }
    void push_front(const T &t) { this->insert(this->begin(),t); }
    const T &last() const { return this->back(); }
    T &last() { return this->back(); }
    int indexOf(const T &t,int from=0) const { auto s = this->begin()+from; auto f = std::find(s,this->end(),t); if (f==this->end()) return -1;  return to<int>(f-this->begin()); }
    IVector<T> toVector() const { IVector<T> out; for (auto &v : *this) out.push_back(v);  return out; }
    T takeFirst() { auto i=this->begin(); T val = *i;  this->erase(i);  return val; }
    IList<T> &operator<<(const T &t) { append(t);  return *this; }
    void replace(int i,const T &val) { if (i<0 or i>=size()) return;  this->operator[](i) = val; }
    T &first() { return this->front(); }
    const T &first() const { return this->front(); }
};
 
template <typename Key,typename Value>
class IMap : public std::map<Key,Value> {
public:
    using std::map<Key,Value>::map;
    using base = std::map<Key,Value>;
    class iterator : public base::iterator {
      public:
        //using base::iterator::iterator;
        iterator(const typename base::iterator &in) : base::iterator(in) { }
        const Key &key() const { return this->base::iterator::operator*().first; }
        Value &value() { return this->base::iterator::operator*().second; }
        Value &operator*() { return value(); }
        Value *operator->() { return &value(); }
    };
    class const_iterator : public base::const_iterator {
      public:
        //using base::const_iterator::const_iterator;
        const_iterator(const typename base::const_iterator &in) : base::const_iterator(in) { }
        const Key &key() const { return this->base::const_iterator::operator*().first; }
        const Value &value() const { return this->base::const_iterator::operator*().second; }
        const Value &operator*() const { return value(); }
        const Value *operator->() { return &value(); }
    };
 
    iterator begin() { return base::begin(); }
    iterator end() { return base::end(); }
    const_iterator begin() const { return base::begin(); }
    const_iterator end() const { return base::end(); }
    const_iterator constBegin() const { return base::begin(); }
    const_iterator constEnd() const { return base::end(); }
    iterator lowerBound(const Key &key) { return this->lower_bound(key); }
    iterator upperBound(const Key &key) { return this->upper_bound(key); }
    Value value(const Key &k,Value def={}) const { auto it=this->find(k); if (it==this->end()) return def;  return it.value(); }
    Value &operator[](const Key &key) { return this->base::operator[](key); }
    Value operator[](const Key &key) const { auto i = this->base::find(key);  if (i==this->end()) return Value{};  return i->second; }
 
    bool contains(const Key &k) const { return base::count(k)>0; }
    bool isEmpty() const { return this->size()==0; }
    IList<Key> keys() const { IList<Key> out; for (auto &[k,v] : (base &)*this) out.push_back(k);  return out; }
    IList<Value> values() const { IList<Value> out; for (auto &[k,v] : (base &)*this) out.push_back(v);  return out; }
    Key key(const Value &value,Key def={}) const;
    Key firstKey() const { return this->base::begin()->first; }
    Key lastKey() const { auto i = base::end(); --i;  return i->first; }
 
    iterator find(const Key &k) { return base::find(k); }
    const_iterator find(const Key &k) const { return base::find(k); }
    Value take(const Key &k) { auto it = find(k);  if (it==end()) return {}; Value v = *it;  this->erase(it);  return v; }
    iterator insert(const Key &k,const Value &v) { return base::insert({k,v}).first; }
    iterator insertMulti(const Key &k,const Value &v) { return insert(k,v); }
    void remove(const Key &k) { this->erase(k); }
};
 
template <typename Key,typename Value>
class IMultiMap : public std::multimap<Key,Value> {
public:
    using std::multimap<Key,Value>::multimap;
    using base = std::multimap<Key,Value>;
    class iterator : public base::iterator {
      public:
        //using base::iterator::iterator;
        iterator(const typename base::iterator &in) : base::iterator(in) { }
        const Key &key() const { return this->base::iterator::operator*().first; }
        Value &value() { return this->base::iterator::operator*().second; }
        Value &operator*() { return value(); }
        Value *operator->() { return &value(); }
    };
    class const_iterator : public base::const_iterator {
      public:
        //using base::const_iterator::const_iterator;
        const_iterator(const typename base::const_iterator &in) : base::const_iterator(in) { }
        const Key &key() const { return this->base::const_iterator::operator*().first; }
        const Value &value() const { return this->base::const_iterator::operator*().second; }
        const Value &operator*() const { return value(); }
        Value *operator->() { return &value(); }
    };
 
    iterator begin() { return base::begin(); }
    iterator end() { return base::end(); }
    const_iterator begin() const { return base::begin(); }
    const_iterator end() const { return base::end(); }
    const_iterator constBegin() const { return base::begin(); }
    const_iterator constEnd() const { return base::end(); }
 
    iterator find(const Key &v) { return this->base::find(v); }
    iterator insert(const Key &k,const Value &v) { return this->base::insert({k,v}); }
    iterator insertMulti(const Key &k,const Value &v) { return this->base::insert({k,v}); }
    iterator lowerBound(const Key &key) { return this->lower_bound(key); }
    iterator upperBound(const Key &key) { return this->upper_bound(key); }
    void remove(const Key &k) { this->erase(k); }
    bool isEmpty() const { return this->size()==0; }
    IList<Key> uniqueKeys() const { std::set<Key> s;  for (auto &[k,v] : (base &)*this) s.insert(k); IList<Key> ret;  for (auto &k : s) ret.push_back(k); return ret; }
};
 
template <typename T>
class ISet : public std::set<T> {
public:
    using std::set<T>::set;
    using base = std::set<T>;
 
    void operator+=(const T &t) { this->insert(t); }
    bool remove(const T &t) { return this->erase(t)>0; }
    bool contains(const T &t) const { return this->find(t)!=this->end(); }
    IList<T> values() const { IList<T> out; for (auto &v : (base &)*this) out.push_back(v);  return out; }
    int size() const { return to<int>(base::size()); }
    ISet<T> &operator<<(const T &t) { this->base::insert(t);  return *this; }
    ISet<T> intersect(const ISet<T> &s) { ISet<T> out; std::set_intersection(this->begin(),this->end(),s.begin(),s.end(),std::inserter(out,out.begin()));  return out; }
    ISet<T> &subtract(const ISet<T> &s) { for (auto &t : s) this->erase(t); return *this; }
};
 
template <typename Key,typename Value>
class IHash : public std::unordered_map<Key,Value> {
public:
    using std::unordered_map<Key,Value>::unordered_map;
    using base = std::unordered_map<Key,Value>;
    class iterator : public base::iterator {
      public:
        //using base::iterator::iterator;
        iterator(const typename base::iterator &in) : base::iterator(in) { }
        const Key &key() const { return this->base::iterator::operator*().first; }
        Value &value() const { return this->base::iterator::operator*().second; }
        Value &operator*() { return value(); }
        Value *operator->() { return &value(); }
    };
    class const_iterator : public base::const_iterator {
      public:
        //using base::const_iterator::const_iterator;
        const_iterator(const typename base::const_iterator &in) : base::const_iterator(in) { }
        const Key &key() const { return this->base::const_iterator::operator*().first; }
        const Value &value() const { return this->base::const_iterator::operator*().second; }
        const Value &operator*() const { return value(); }
        const Value *operator->() const { return &value(); }
    };
    iterator begin() { return base::begin(); }
    iterator end() { return base::end(); }
    const_iterator begin() const { return base::begin(); }
    const_iterator end() const { return base::end(); }
    const_iterator constBegin() const { return base::begin(); }
    const_iterator constEnd() const { return base::end(); }
    const_iterator find(const Key &k) const { return base::find(k); }
    iterator find(const Key &k) { return base::find(k); }
    IList<Value> values() const { IList<Value> out; for (auto &[k,v] : (base &)*this) out.push_back(v);  return out; }
    iterator insert(const Key &k,const Value &v) { return this->base::insert({k,v}).first; }
    iterator insertMulti(const Key &k,const Value &v) { return insert(k,v); }
    bool contains(const Key &k) const { auto i = this->find(k);  return i!=this->end(); }
    void remove(const Key &k) { this->erase(k); }
    Value take(const Key &k) { auto i=this->find(k); if (i==this->end()) return Value{};  Value v = i->second;  this->erase(i);  return v; }
    Value value(const Key &k,Value v={}) const { auto i=this->find(k); if (i==this->end()) return v;  return i->second; }
    Value &operator[](const Key &key) { return this->base::operator[](key); }
    Value operator[](const Key &key) const { auto i = this->base::find(key);  if (i==this->end()) return Value{};  return i->second; }
};
 
template <typename Key,typename Value>
class IMultiHash : public std::unordered_multimap<Key,Value> {
  public:
    using std::unordered_multimap<Key,Value>::unordered_multimap;
    using base = std::unordered_multimap<Key,Value>;
    class iterator : public base::iterator {
      public:
        //using base::iterator::iterator;
        iterator(const typename base::iterator &in) : base::iterator(in) { }
        const Key &key() const { return this->base::iterator::operator*().first; }
        Value &value() { return this->base::iterator::operator*().second; }
        Value &operator*() { return value(); }
        Value *operator->() { return &value(); }
    };
    class const_iterator : public base::const_iterator {
      public:
        //using base::const_iterator::const_iterator;
        const_iterator(const typename base::const_iterator &in) : base::const_iterator(in) { }
        const Key &key() const { return this->base::const_iterator::operator*().first; }
        const Value &value() const { return this->base::const_iterator::operator*().second; }
        const Value &operator*() const { return value(); }
    };
    iterator begin() { return base::begin(); }
    iterator end() { return base::end(); }
    const_iterator begin() const { return base::begin(); }
    const_iterator end() const { return base::end(); }
    const_iterator constBegin() const { return base::begin(); }
    const_iterator constEnd() const { return base::end(); }
    IList<Value> values() const { IList<Value> out; for (auto &[k,v] : (base &)*this) out.push_back(v);  return out; }
    void insert(const Key &k,const Value &v) { this->base::insert({k,v}); }
    void insertMulti(const Key &k,const Value &v) { this->base::insert({k,v}); }
    bool contains(const Key &k) const { auto i = this->find(k);  return i!=this->end(); }
    Value take(const Key &k) { auto i=this->find(k); if (i==this->end()) return Value{};  Value v = i->second;  this->erase(i);  return v; }
    Value value(const Key &k,Value v={}) const { auto i=this->find(k); if (i==this->end()) return v;  return i->second; }
    Value &operator[](const Key &key) { return this->base::operator[](key); }
    Value operator[](const Key &key) const { auto i = this->base::find(key);  if (i==this->end()) return Value{};  return i->second; }
};
 
template <typename T>
class IQueue : public std::queue<T> {
  public:
    using std::queue<T>::queue;
    T dequeue() { T val = this->front();  this->pop();  return val; }
    void enqueue(const T &t) { this->emplace(t); }
    T &head() { return this->front(); }
    const T &head() const { return this->front(); }
    bool isEmpty() const { return this->size()==0; }
};
 
//---------------------------------------------------
// Implementations
//---------------------------------------------------
template <typename Key,typename Value>
Key IMap<Key,Value>::key(const Value &value,Key def) const {
    for (auto &[k,v] : (base &)*this) {
        if (v==value) return k;
    }
    return def;
}
 
// EoF