src/LocARNA/sparse_vector.hh

#ifndef SPARSE_VECTOR_HH
#define SPARSE_VECTOR_HH

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iosfwd>

#include "aux.hh"

namespace LocARNA {

    template <typename T>
    class SparseVector {
    public:
        typedef T value_t; 

        typedef size_t size_type; 

        typedef size_type key_t; 

    protected:
        typedef
            typename unordered_map<key_t, value_t>::type map_t; 
        map_t the_map_; 
        value_t def_;   

    public:
        typedef typename map_t::const_iterator const_iterator;

        class element {
        private:
            SparseVector<T> *m_;
            key_t k_;

        public:
            element(SparseVector<T> *m, key_t k) : m_(m), k_(k) {}

            operator value_t() {
                typename map_t::const_iterator it = m_->the_map_.find(k_);
                if (it == m_->the_map_.end())
                    return m_->def_;
                else
                    return it->second;
            }

            element
            operator+=(const value_t &x) {
                const_iterator it = m_->the_map_.find(k_);
                if (it == m_->the_map_.end())
                    m_->the_map_[k_] = m_->def_ + x;
                else
                    m_->the_map_[k_] += x;

                return *this;
            }

            element &
            operator=(const value_t &x) {
                if (x == m_->def_) {
                    m_->the_map_.erase(k_);
                } else {
                    // the following replaces m_->the_map_[k_] = x;
                    // but never calls the default constructor for value_t

                    typename map_t::iterator it = m_->the_map_.find(k_);
                    if (it != m_->the_map_.end()) {
                        it->second = x;
                    } else {
                        m_->the_map_.insert(typename map_t::value_type(k_, x));
                    }
                }
                return *this;
            }
        };

        explicit SparseVector(const value_t &def) : the_map_(), def_(def) {}

        element operator[](size_type i) { return element(this, key_t(i)); }

        const value_t &operator[](size_type i) const {
            const_iterator it = the_map_.find(key_t(i));
            if (it == the_map_.end())
                return def_;
            else
                return it->second;
        }

        void
        set(size_type i, const value_t &val) {
            typename map_t::iterator it = the_map_.find(key_t(i));
            if (it != the_map_.end()) {
                it->second = val;
            } else {
                the_map_.insert(typename map_t::value_type(key_t(i), val));
            }
        }

        void
        reset(size_type i) {
            typename map_t::iterator it = the_map_.find(key_t(i));
            if (it != the_map_.end()) {
                the_map_.erase(key_t(i));
            }
        }

        size_type
        size() const {
            return the_map_.size();
        }

        bool
        empty() const {
            return the_map_.empty();
        }

        void
        clear() {
            the_map_.clear();
        }

        const_iterator
        begin() const {
            return the_map_.begin();
        }

        const_iterator
        end() const {
            return the_map_.end();
        }
    };

    template <class T>
    inline std::ostream &
    operator<<(std::ostream &out, const SparseVector<T> &v) {
        for (typename SparseVector<T>::const_iterator it = v.begin();
             v.end() != it; ++it) {
            out << it->first << ":" << it->second << " ";
        }
        out << std::endl;
        return out;
    }

} // end namespace LocARNA

#endif // SPARSE_VECTOR_HH