torc/generic/om/Value.cpp

// Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
// $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/generic/om/Value.cpp $
// $Id: Value.cpp 10 2011-10-12 18:40:16Z nsteiner $

// This program is free software: you can redistribute it and/or modify it under the terms of the 
// GNU General Public License as published by the Free Software Foundation, either version 3 of the 
// License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
// the GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License along with this program.  If 
// not, see <http://www.gnu.org/licenses/>.

#include "torc/generic/om/DumpRestoreConfig.hpp"

#ifndef HAVE_CONFIG_H
#include "torc/generic/config.h"
#endif

#ifdef GENOM_SERIALIZATION
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/variant.hpp>
#endif //GENOM_SERIALIZATION
#include <cmath>

#include "torc/generic/om/Value.hpp"

namespace torc {

namespace generic {

Value::MiNoMax::MiNoMax()
    :mMin(),
    mMinUndefined(true),
    mNominal(),
    mMax(),
    mMaxUndefined(true) {
}

Value::MiNoMax::MiNoMax(Value::Number inMin,
                Value::Number inNominal, Value::Number inMax)
    :mMin(inMin),
    mMinUndefined(false),
    mNominal(inNominal),
    mMax(inMax),
    mMaxUndefined(false) {
}

Value::MiNoMax::~MiNoMax() throw() {
}

Value::MiNoMax::MiNoMax(const Value::MiNoMax & inSource) throw()
    : mMin( inSource.mMin ),
    mMinUndefined( inSource.mMinUndefined ),
    mNominal( inSource.mNominal ),
    mMax( inSource.mMax ),
    mMaxUndefined( inSource.mMaxUndefined ) {
}

Value::MiNoMax & Value::MiNoMax::operator=(
                const Value::MiNoMax & inSource) throw() {
    if( this != &inSource )
    {
        mMin = inSource.mMin;
        mMinUndefined = inSource.mMinUndefined;
        mNominal = inSource.mNominal;
        mMax = inSource.mMax;
        mMaxUndefined = inSource.mMaxUndefined;
    }
    return *this;
}

bool
Value::MiNoMax::operator <(
            const Value::MiNoMax & inRhs) const throw() {
    return mNominal.eval() < inRhs.mNominal.eval();
}

bool
Value::MiNoMax::operator ==(
            const Value::MiNoMax & inRhs) const throw() {
    return mNominal.eval() == inRhs.mNominal.eval();
}

bool
Value::MiNoMax::operator >(
            const Value::MiNoMax & inRhs) const throw() {
    return mNominal.eval() > inRhs.mNominal.eval();
}

bool
Value::MiNoMax::operator >=(
            const Value::MiNoMax & inRhs) const throw() {
    return mNominal.eval() >= inRhs.mNominal.eval();
}

bool
Value::MiNoMax::operator <=(
            const Value::MiNoMax & inRhs) const throw() {
    return mNominal.eval() <= inRhs.mNominal.eval();
}

bool
Value::MiNoMax::operator !=(
            const Value::MiNoMax & inRhs) const throw() {
    return !operator ==( inRhs );
}

void
Value::MiNoMax::setMax(const Value::Number & inSource) throw() {
  mMax = inSource;
  mMaxUndefined = false;  
}

void
Value::MiNoMax::setMin(const Value::Number & inSource) throw() {
  mMin = inSource;
  mMinUndefined = false; 
}

void
Value::MiNoMax::setNominal(const Value::Number & inSource) throw() {
  mNominal = inSource;
}

Value::Number::Number()
    :mMantissa(0),
    mExponent(0) {
}

Value::Number::Number(int32_t inMantissa, int32_t inExponent)
    :mMantissa(inMantissa),
    mExponent(inExponent) {
}

Value::Number::~Number() throw() {
}

Value::Number::Number(const Value::Number & inSource) throw()
    :mMantissa( inSource.mMantissa ),
    mExponent( inSource.mExponent ) {
}

Value::Number &
Value::Number::operator=(
            const Value::Number & inSource) throw() {
    if( this != &inSource )
    {
        mMantissa = inSource.mMantissa;
        mExponent = inSource.mExponent;
    }
    return *this;
}

bool
Value::Number::operator <(
        const Value::Number & inRhs) const throw() {
    return eval() < inRhs.eval();
}

bool
Value::Number::operator ==(
        const Value::Number & inRhs) const throw() {
    return eval() == inRhs.eval();
}

bool
Value::Number::operator >(
        const Value::Number & inRhs) const throw() {
    return eval() > inRhs.eval();
}

bool
Value::Number::operator >=(
        const Value::Number & inRhs) const throw() {
    return eval() >= inRhs.eval();
}

bool
Value::Number::operator <=(
        const Value::Number & inRhs) const throw() {
    return eval() <= inRhs.eval();
}

bool
Value::Number::operator !=(
        const Value::Number & inRhs) const throw() {
    return !operator ==(inRhs);
}

void
Value::Number::setMantissa( const int32_t & inSource) throw() {
  mMantissa = inSource;
}

void
Value::Number::setExponent(const int32_t & inSource) throw() {
  mExponent = inSource;
}

double
Value::Number::eval() const throw() {
    return static_cast<double>(mMantissa)
            * exp( static_cast<double>(mExponent) );
}

Value::Point::Point()
    :mX(0),
    mY(0) {
}

Value::Point::Point(int32_t inX, int32_t inY)
    :mX(inX),
    mY(inY) {
}

Value::Point::~Point() throw() {
}

Value::Point::Point(const Value::Point & inSource )
    :mX( inSource.mX ),
    mY( inSource.mY ) {
}

Value::Point &
Value::Point::operator=(const Value::Point & inSource) throw() {
    if( this != &inSource )
    {
        mX = inSource.mX;
        mY = inSource.mY;
    }
    return *this;
}

bool
Value::Point::operator <(
        const Value::Point & inRhs) const throw() {
    return mX < inRhs.mY
            || (mX == inRhs.mX && mY < inRhs.mY );
}

bool
Value::Point::operator ==(
        const Value::Point & inRhs) const throw() {
    return mX == inRhs.mY && mY == inRhs.mY;
}

bool
Value::Point::operator >(
        const Value::Point & inRhs) const throw() {
    return mX > inRhs.mY
            || (mX == inRhs.mX && mY > inRhs.mY );
}

bool
Value::Point::operator >=(
        const Value::Point & inRhs) const throw() {
    return mX >= inRhs.mY && mY >= inRhs.mY;
}

bool
Value::Point::operator <=(
        const Value::Point & inRhs) const throw() {
    return mX <= inRhs.mY && mY <= inRhs.mY;
}

bool
Value::Point::operator !=(
        const Value::Point & inRhs) const throw() {
    return !operator ==(inRhs);
}

void
Value::Point::setX(const int32_t & inSource) throw() {
  mX = inSource;
}

void
Value::Point::setY(const int32_t & inSource) throw() {
  mX = inSource;
}

Value::Value()
    :mType( eValueTypeUndefined ),
    mValue(),
    mIsSet( false ) {
}

Value::Value(Value::Type type)
    :mType( type ),
    mValue(),
    mIsSet( false ) {
}

Value::~Value() throw() {
}

Value::Value(const Value & inSource)
    :mType( inSource.mType ),
    mValue( inSource.mValue ),
    mIsSet( inSource.mIsSet ) {
}

Value &
Value::operator=(const Value & inSource) throw() {
    if( this != &inSource )
    {
        mType = inSource.mType;
        mValue = inSource.mValue;
        mIsSet = inSource.mIsSet;
    }
    return *this;
}

/**
 * Get the type of inSource stored in this object.
 *
 * @return The type of object
 */
void
Value::setType(const Value::Type & inSource) throw() {
  mType = inSource;
}

/**
 false* Set whether this object is defined with a inSource, or is undefined.
 *
 * @param[in] inSource True if initialized.
 */
void
Value::setIsSet(const bool & inSource) throw() {
  mIsSet = inSource;
}

#ifdef GENOM_SERIALIZATION
template<class Archive> void
Value::serialize( Archive &ar, unsigned int ) {
    ar & mType;
    ar & mValue;
    ar & mIsSet;
}

//TO SATISFY THE LINKER
template void
Value::serialize<boost::archive::binary_iarchive>(
        boost::archive::binary_iarchive & ar, const unsigned int);

template void
Value::serialize<boost::archive::binary_oarchive>(
        boost::archive::binary_oarchive & ar, const unsigned int);

#endif //GENOM_SERIALIZATION

} // namespace torc::generic

} // namespace torc

---