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 IVector<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