src/LocARNA/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