type_wrapper.hh

#ifndef LOCARNA_TYPE_WRAPPER_HH
#define LOCARNA_TYPE_WRAPPER_HH

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

namespace LocARNA {
    template<class T>
    class type_wrapper {
        T val_;
    public:

        type_wrapper(): val_() {}
        
        explicit type_wrapper(const T &i): val_(i) {}   
        
        type_wrapper(const type_wrapper &idx): val_(idx.val()) {}

        const T &val() const {return val_;}

        bool operator ==(const type_wrapper &x) const {return val_ == x.val_;}

        
        bool operator !=(const type_wrapper &x) const {return val_ != x.val_;}

        bool operator <=(const type_wrapper &x) const {return val_ <= x.val_;}

        bool operator  <(const type_wrapper &x) const {return val_ <  x.val_;}

        bool operator >=(const type_wrapper &x) const {return val_ >= x.val_;}

        bool operator  >(const type_wrapper &x) const {return val_ >  x.val_;}
        
        type_wrapper operator +(const type_wrapper &x) const {return type_wrapper(val_ + x.val_);}
        
        type_wrapper operator -(const type_wrapper &x) const {return type_wrapper(val_ - x.val_);}
        
        type_wrapper operator +(const T &x) const {return type_wrapper(val_ + x);}
        
        type_wrapper operator -(const T &x) const {return type_wrapper(val_ - x);}
        
        const type_wrapper &operator ++() {++val_; return *this;}
        
        const type_wrapper &operator --() {--val_; return *this;}

        const type_wrapper &operator ++(int) {type_wrapper<T> tmp(*this); ++val_; return tmp;}
        
        const type_wrapper &operator --(int) {type_wrapper<T> tmp(*this); --val_; return tmp;}

    }; // end class type_wrapper

    template <class T>
    std::ostream & operator << (std::ostream &out,const type_wrapper<T> &x) {
        out<<x.val();
        return out;
    }

} // end namespace LocARNA

#endif // LOCARNA_TYPE_WRAPPER_HH