scalar.hpp

#ifndef HAVE_TOM__SCALAR_V2_HPP
#define HAVE_TOM__SCALAR_V2_HPP
 
#include <tom-util/observation.hpp>
#include <cstdio>
 
namespace tom {
 
// This will use POD types (and tom::string which is just a std::string)
// and the lower level tom::value_types::scalar<> struct to handle missing
// data, conversions, etc.
template <typename T>
class scalar : public observation, 
         public boost::arithmetic< scalar<T>,
            boost::arithmetic< scalar<T>, T,
            boost::incrementable< scalar<T>, 
            boost::decrementable< scalar<T> > > >
            >
{
public:
 
  typedef   T                 value_type;
  typedef typename tom::value_types::scalar<T>    scalar_type;
  typedef typename tom::value_types::no_data<T>   no_data;
  typedef typename tom::value_types::holiday<T>   holiday;
  typedef typename tom::value_types::non_calc<T>  non_calc;
  
    // Constructors
    scalar();
    scalar( const T & );
    scalar( tom::value_type );
    scalar( const observation & );
    ~scalar();
    
    // Copy Constructors
    template <typename Tp>
    scalar( const scalar<Tp> & );
    scalar( const scalar & );
 
    virtual 
    scalar &
    clone() const;
 
    // Assignment Operators
 
    // inherited from observation...don't forget it!
    virtual
    observation &
    operator=( const observation & );
 
 
    // class assignment ops
    template <typename Tp>
    scalar &operator=( const scalar<Tp> & );
    scalar &operator=( const scalar & );
    scalar &operator=( const T & );
    scalar &operator=( tom::value_type t );
 
    bool is_normal() const;
 
    // now implement the inherited interface
    virtual std::ostream &print( std::ostream & ) const;
    virtual tom::value_type flag() 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 bool operator==( const scalar & rhs ) const { return this->value() == rhs.value(); }
    virtual bool operator!=( const scalar & rhs ) const { return ! ( *this == rhs ); }
 
    // cast operators
    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;
 
    virtual operator bool() const;
    
    scalar & operator+=( const T & );
    scalar & operator+=( const scalar & );
 
    scalar & operator-=( const T & );
    scalar & operator-=( const scalar & );
 
    scalar & operator*=( const T & );
    scalar & operator*=( const scalar & );
 
    scalar & operator/=( const T & );
    scalar & operator/=( const scalar & );
 
    scalar &operator++(){ ++m_value; return *this; }
    scalar &operator--(){ --m_value; return *this; }
 
    static const scalar HAS_NO_DATA;
    static const scalar HOLIDAY;
    static const scalar NON_CALC;
 
    const T &
    value() const { return m_value.value_; }
 
protected:
    scalar_type m_value;  // the value
 
};
 
template <typename T>
std::ostream &
operator<<( std::ostream &os, const scalar<T> & rhs );
 
typedef scalar<float>                       Float;
typedef scalar<double>                      Double;
typedef scalar<tom::value_types::string>    String_;
typedef scalar<unsigned char>               Bool;
typedef scalar<int>                         Int;
typedef scalar<unsigned int>                UInt;
typedef scalar<long>                        Long;
typedef scalar<unsigned long>               ULong;
 
namespace {
 
    // helper functions
    template <typename T>
    T
    cast_observation_( const observation &v )
    {
        // this works due to the class operators
        return static_cast<T>( v );
    }
    
} // end anonymous namespace 
 
// Constructors scalar();
 
template <typename T>
scalar<T>::scalar(  ){ }
 
template <typename T>
scalar<T>::scalar( const T &t )
{
    m_value = t;
}
template <typename T>
scalar<T>::scalar( tom::value_type vt) : m_value( vt ) {  }
 
template <typename T>
scalar<T>::~scalar(){ }
    
 
// Copy Constructors
template <typename T>
template <typename Tp>
scalar<T>::scalar( const scalar<Tp> &rhs )
{
    m_value = cast_observation_<T> ( rhs );
}
template <typename T>
scalar<T>::scalar( const scalar &rhs )
{
    m_value = rhs.m_value;
}
template <typename T>
scalar<T>::scalar( const observation & rhs )
{
    m_value = cast_observation_<T>( rhs );
}
 
template <typename T>
scalar<T> &
scalar<T>::clone() const
{
    return *new scalar<T>( *this );
}
 
// Assignment Operators
 
// inherited from observation...don't forget it!
template <typename T>
observation &
scalar<T>::operator=( const observation & rhs )
{
    m_value = cast_observation_<T>( rhs );
    return *this;
}
 
 
// class assignment ops
template <typename T>
template <typename Tp>
scalar<T> &
scalar<T>::operator=( const scalar<Tp> & rhs )
{
    m_value = cast_observation_<T>( rhs );
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator=( const scalar & rhs )
{
    m_value = rhs.m_value;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator=( const T &v )
{
    m_value = v;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator=( tom::value_type vt )
{
    m_value = vt;
    return *this;
}
 
template <typename T>
bool 
scalar<T>::is_normal() const
{
    return m_value.is_normal();
}
 
template <typename T>
std::ostream &
scalar<T>::print( std::ostream & os ) const
{
    return os << m_value;
}
 
template <typename T>
tom::value_type 
scalar<T>::flag() const
{
    return m_value.get_value_type();
}
 
template <typename T>
observation &
scalar<T>::operator+=( const observation & rhs )
{
    m_value += cast_observation_<T>( rhs );
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator+=( const scalar & rhs )
{
    m_value += rhs.m_value;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator+=( const T &rhs )
{
    m_value += rhs;
    return *this;
}
template <typename T>
observation &
scalar<T>::operator-=( const observation & rhs )
{
    m_value -= cast_observation_<T>( rhs );
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator-=( const scalar & rhs )
{
    m_value -= rhs.m_value;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator-=( const T & rhs )
{
    m_value -= rhs;
    return *this;
}
template <typename T>
observation &
scalar<T>::operator*=( const observation & rhs )
{
    m_value *= cast_observation_<T>( rhs );
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator*=( const scalar & rhs )
{
    m_value *= rhs.m_value;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator*=( const T & rhs )
{
    m_value *= rhs;
    return *this;
}
template <typename T>
observation &
scalar<T>::operator/=( const observation & rhs )
{
    m_value /= cast_observation_<T>( rhs );
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator/=( const scalar & rhs )
{
    m_value /= rhs.m_value;
    return *this;
}
template <typename T>
scalar<T> &
scalar<T>::operator/=( const T & rhs )
{
    m_value /= rhs;
    return *this;
}
 
 
template <typename T>
bool
scalar<T>::operator<( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value < tmp;
}
template <typename T>
bool
scalar<T>::operator<=( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value <= tmp;
}
template <typename T>
bool
scalar<T>::operator>( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value > tmp;
}
template <typename T>
bool
scalar<T>::operator>=( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value >= tmp;
}
 
template <typename T>
bool
scalar<T>::operator==( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value == tmp;
}
template <typename T>
bool
scalar<T>::operator!=( const observation & rhs ) const
{
    scalar_type tmp = cast_observation_<T>( rhs );
    return m_value != tmp;
}
 
 
// cast operators
template <typename T>
scalar<T>::operator unsigned char() const
{
    tom::value_types::scalar<unsigned char> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator tom::value_types::string() const
{
    tom::value_types::scalar<tom::value_types::string> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator short int() const
{
    tom::value_types::scalar<short int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator int() const
{
    tom::value_types::scalar<int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator long int() const
{
    tom::value_types::scalar<long int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator unsigned short int() const
{
    tom::value_types::scalar<unsigned short int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator unsigned int() const
{
    tom::value_types::scalar<unsigned int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator unsigned long int() const
{
    tom::value_types::scalar<unsigned long int> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator float() const
{
    tom::value_types::scalar<float> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator double() const
{
    tom::value_types::scalar<double> tmp( m_value );
    return tmp.value_;
}
template <typename T>
scalar<T>::operator bool() const
{
    tom::value_types::scalar<unsigned char> tmp( m_value );
    if ( tmp.is_normal() )
        return tmp.value_;
    else
        return false;
}
 
template <typename T>
std::ostream &
operator<<( std::ostream &os, const scalar<T> & rhs )
{
    return rhs.print(os);
}
 
template <typename T>
const scalar<T> scalar<T>::HAS_NO_DATA( tom::value_types::resolve_nd<T>::get_value_of_nd() );
 
template <typename T>
const scalar<T> scalar<T>::HOLIDAY( tom::value_types::resolve_nd<T>::get_value_of_na() );
 
template <typename T>
const scalar<T> scalar<T>::NON_CALC( tom::value_types::resolve_nd<T>::get_value_of_nc() );
 
 
// okay!  How about some mixed scalar<> math
template<typename T, typename Tp>
scalar<T>
operator+( const scalar<T> &a, const scalar<Tp> &b )
{
    scalar<T> result( a );
    result += b;
    return result;  
}
 
} // end namespace tom
 
 
#include <tom-util/string.hpp>
#include <tom-util/dates.hpp>
 
#endif