blob.hpp

/*
 * blob.hpp
 *
 *  Created on: Sep 23, 2020
 *      Author: tmccubbin
 */
 
#ifndef SRC_TOM_UTIL_BLOB_HPP_
#define SRC_TOM_UTIL_BLOB_HPP_
 
#include <vector>
#include <tom-util/observation.hpp>
#include <tom-util/scalar.hpp>
 
 
namespace tom {
 
    using cvec = std::vector<std::uint8_t>;
 
    class Blob : public tom::scalar< tom::cvec_adapter >,
                public boost::arithmetic< Blob,
                                boost::arithmetic< Blob, std::vector<std::uint8_t>,
                                boost::incrementable< Blob,
                                boost::decrementable< Blob > > >
                        >
    {
    public:
        typedef tom::cvec_adapter                                   value_type;
        typedef typename tom::Blob::value_type::const_iterator      const_iterator;
        typedef typename tom::Blob::value_type::iterator            iterator;
 
        typedef typename tom::value_types::no_data<value_type>      no_data;
        typedef typename tom::value_types::holiday<value_type>      holiday;
        typedef typename tom::value_types::non_calc<value_type>     non_calc;
 
 
        Blob();
        Blob( const tom::Blob & );
        Blob( tom::Blob & );
        Blob( std::vector<std::uint8_t> );
        Blob( const observation & );
 
        template< typename T >
        Blob( const T begin, const T end ) : m_value( begin, end ){ }
 
        virtual ~Blob();
 
        Blob &
        operator=( const std::vector<std::uint8_t> & );
        Blob &
        operator=( const Blob & );
 
        virtual
        Blob &
        operator=( const observation & );
 
        virtual
        Blob &
        operator=( tom::value_types::value_type );
 
        iterator begin() { return m_value.begin(); }
        const_iterator begin() const { return m_value.begin(); }
        iterator end() { return m_value.end(); }
        const_iterator end() const { return m_value.end(); }
 
        template <typename T>
        void
        assign( const T begin, const T end ){
            m_value.assign(begin,end);
        }
 
        virtual
        tom::value_type
        flag() const;
 
        virtual
        bool
        is_normal() const;
 
        // need to make a copy, call me :)
        // needed by algos, etc, that want to generically
        // use observation refs, w/out knowing what type
        // actually implements the function
        //virtual observation &clone() const;
 
        virtual observation &operator+=( const observation & );
        virtual observation &operator-=( const observation & );
        virtual observation &operator*=( const observation & );
        virtual observation &operator/=( const observation & );
 
        virtual bool operator<( const observation & ) const;
        virtual bool operator<=( const observation & ) const;
        virtual bool operator>( const observation & ) const;
        virtual bool operator>=( const observation & ) const;
 
        virtual bool operator==( const observation & ) const;
        virtual bool operator!=( const observation & ) const;
 
        virtual std::ostream &print( std::ostream & ) const;
 
        virtual operator unsigned char() const;
        virtual operator tom::value_types::string() const;
        virtual operator short int() const;
        virtual operator int() const;
        virtual operator long int() const;
        virtual operator unsigned short int() const;
        virtual operator unsigned int() const;
        virtual operator unsigned long int() const;
        virtual operator float() const;
        virtual operator double() const;
 
        // special case, as there is no real bool!
        // just an unsigned char to hold bool + flags
        virtual operator bool() const;
 
        std::uint8_t
        operator[](size_t i){ return m_value.at(i); }
 
        value_type
        value() const { return m_value; }
 
        size_t
        size() const { return m_value.size(); }
 
    public:
        value_type  m_value;
    };
 
} // end tom namespace
 
#endif /* SRC_TOM_UTIL_BLOB_HPP_ */