knotkit/lib/ullmanmap.h
2011-12-09 15:50:25 -05:00

129 lines
3.7 KiB
C++

template<class V, unsigned B> class ullmanmap_iter;
template<class V, unsigned B> class ullmanmap_const_iter;
template<class V, unsigned B>
class ullmanmap
{
private:
friend class ullmanmap_iter<V, B>;
friend class ullmanmap_const_iter<V, B>;
ullmanset<B> present;
basedvector<V, B> values;
public:
typedef ullmanmap_iter<V, B> iter;
typedef ullmanmap_const_iter<V, B> const_iter;
public:
ullmanmap () { }
ullmanmap (unsigned size) : present(size), values(size) { }
ullmanmap (unsigned size, const map<unsigned, V> &m); // common
ullmanmap (const ullmanmap &m) : present(m.present), values(m.values) { }
ullmanmap (copy, const ullmanmap &m) : present(COPY, m.present), values(COPY, m.values) { }
ullmanmap (reader &r);
~ullmanmap () { }
ullmanmap &operator = (const ullmanmap &m) { present = m.present; values = m.values; return *this; }
ullmanmap &operator = (const map<unsigned, V> &m); // common
unsigned size () const { return present.size (); }
pair<unsigned, V> head ();
void clear () { present.clear (); }
unsigned card () { return present.card (); }
void operator -= (unsigned k) { present -= k; }
void push (unsigned k, const V &v) { present.push (k); values[k] = v; }
void set (unsigned k, const V &v) { present += k; values[k] = v; }
V &operator [] (unsigned k) { if (! (present % k)) { present.push (k); values[k] = V (); } return values[k]; }
const V &operator [] (unsigned k) const { assert (present % k); return values[k]; }
const V &operator () (unsigned k) const { assert (present % k); return operator [] (k); }
const V &operator () (unsigned k, const V &d) const { if (present % k) return values[k]; else return d; }
pair<V &, bool> find (unsigned k)
{
bool p = present % k;
return pair<V &, bool> (operator [] (k), p);
}
bool operator % (unsigned k) const { return present % k; }
unsigned nth (unsigned p) const { return present.nth (p); }
unsigned position (unsigned k) const { return present.position (k); }
void write_self (writer &w) const;
};
template<class V, unsigned B>
ullmanmap<V, B>::ullmanmap (unsigned size, const map<unsigned, V> &m)
: present(size), values(size)
{
for (typename map<unsigned, V>::const_iter i = m; i; i ++)
push (i.key (), i.val ());
}
template<class V, unsigned B>
ullmanmap<V, B>::ullmanmap (reader &r)
: present(r),
values(r)
{
}
template<class V, unsigned B> ullmanmap<V, B> &
ullmanmap<V, B>::operator = (const map<unsigned, V> &m)
{
/* assume the ullman map is already allocated */
clear ();
for (typename map<unsigned, V>::const_iter i = m; i; i ++)
push (i.key (), i.val ());
return *this;
}
template<class V, unsigned B> void
ullmanmap<V, B>::write_self (writer &w) const
{
write (w, present);
write (w, values);
}
template<class V, unsigned B>
class ullmanmap_iter
{
private:
ullmanset_iter<B> i;
basedvector<V, B> &values;
public:
ullmanmap_iter (ullmanmap<V, B> &m) : i(m.present), values(m.values) { }
~ullmanmap_iter () { }
void del () { i.del (); }
unsigned key () const { return i.val (); }
V &val () { return values[i.val ()]; }
const V &val () const { return values[i.val ()]; }
operator bool () const { return (bool)i; }
void operator ++ () { i ++; }
void operator ++ (int) { i ++; }
};
template<class V, unsigned B>
class ullmanmap_const_iter
{
private:
ullmanset_const_iter<B> i;
const basedvector<V, B> &values;
public:
ullmanmap_const_iter (const ullmanmap<V, B> &m) : i(m.present), values(m.values) { }
~ullmanmap_const_iter () { }
unsigned key () const { return i.val (); }
const V &val () const { return values[i.val ()]; }
operator bool () const { return (bool)i; }
void operator ++ () { i ++; }
void operator ++ (int) { i ++; }
};