GeoTessDataValue.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
//- retains certain rights in this software.
//- 
//- BSD Open Source License.
//- All rights reserved.
//- 
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-    * Neither the name of Sandia National Laboratories nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//- 
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef DATAVALUE_OBJECT_H
#define DATAVALUE_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <fstream>
#include <string>
#include <climits>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "GeoTessDataType.h"
#include "GeoTessData.h"
#include "IFStreamAscii.h"
#include "IFStreamBinary.h"
#include "GeoTessUtils.h"
#include "GeoTessDataArray.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ *********************************************
 
namespace geotess {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
 
template<typename T>
class GEOTESS_EXP_IMP GeoTessDataValue : public GeoTessData
{
private:
 
    T                                               value;
 
public:
 
    GeoTessDataValue(T v) : GeoTessData(), value(v) {};
 
    GeoTessDataValue() : GeoTessData(), value(0) {};
 
 
    GeoTessDataValue(IFStreamBinary& ifs) : GeoTessData(), value(0)
    { ifs.readType(value); };
 
    GeoTessDataValue(IFStreamAscii& ifs) : GeoTessData(), value(0)
    { ifs.readType(value); };
 
    GeoTessDataValue(IFStreamBinary& ifs, vector<int>& filter) : GeoTessData(), value(0)
    {
        T val;
        for (int i=0; i<(int)filter.size(); ++i)
        {
            ifs.readType(val);
            if (filter[i] == 0)
                value = val;
        }
    }
 
    GeoTessDataValue(IFStreamAscii& ifs, vector<int>& filter) : GeoTessData(), value(0)
    {
        T val;
        for (int i=0; i<(int)filter.size(); ++i)
        {
            ifs.readType(val);
            if (filter[i] == 0)
                value = val;
        }
    }
 
    virtual                                 ~GeoTessDataValue() {};
 
    virtual LONG_INT getMemory() { return (LONG_INT)sizeof(GeoTessDataValue<T>); }
 
    virtual void                        write(IFStreamAscii& ofs)
    { ofs.writeString(" "); ofs.writeType(value); };
 
    virtual void                        write(IFStreamBinary& ofs) { ofs.writeType(value); };
 
 
    /*
     * Return DataType.
     */
    virtual const GeoTessDataType&  getDataType() const { return GeoTessDataType::NONE; };
 
    virtual int                         size() const { return 1; };
 
    bool operator == (const GeoTessDataValue<T>& d) const
    { return (GeoTessData::operator==(d) && ((value == d.value) || (isNaN(0) && d.isNaN(0)))); }
 
    virtual bool operator == (const GeoTessData& d) const { return operator==(*((const GeoTessDataValue<T>*) &d)); }
 
    virtual double                  getDouble(int attributeIndex) const
    { return attributeIndex == 0 ? (double) value : NaN_DOUBLE; }
 
    virtual float                       getFloat(int attributeIndex) const
    { return attributeIndex == 0 ? (float) value : NaN_FLOAT; };
 
    virtual LONG_INT                        getLong(int attributeIndex) const
    { return attributeIndex == 0 ? (LONG_INT) value : LONG_MIN; };
 
    virtual int                         getInt(int attributeIndex) const
    { return attributeIndex == 0 ? (int) value : INT_MIN; };
 
    virtual short                       getShort(int attributeIndex) const
    { return attributeIndex == 0 ? (short) value : SHRT_MIN; };
 
    virtual byte                        getByte(int attributeIndex) const
    { return attributeIndex == 0 ? (byte) value : SCHAR_MIN; };
 
 
    virtual void            getValue(int attributeIndex, double& val) const
    { val = attributeIndex == 0 ? (double) value : NaN_DOUBLE; };
 
    virtual void            getValue(int attributeIndex, float& val) const
    { val = attributeIndex == 0 ? (float) value : NaN_FLOAT; };
 
    virtual void            getValue(int attributeIndex, LONG_INT& val) const
    { val = attributeIndex == 0 ? (LONG_INT) value : LONG_MIN; };
 
    virtual void            getValue(int attributeIndex, int& val) const
    { val = attributeIndex == 0 ? (int) value : INT_MIN; };
 
    virtual void            getValue(int attributeIndex, short& val) const
    { val = attributeIndex == 0 ? (short) value : SHRT_MIN; };
 
    virtual void            getValue(int attributeIndex, byte& val) const
    { val = attributeIndex == 0 ? (byte) value : SCHAR_MIN; };
 
    virtual void            getValues(double values[], const int& n) { values[0] = (double) value; }
 
    virtual void            getValues(float values[], const int& n) { values[0] = (float) value; }
 
    virtual void            getValues(LONG_INT values[], const int& n) { values[0] = (LONG_INT) value; }
 
    virtual void            getValues(int values[], const int& n) { values[0] = (int) value; }
 
    virtual void            getValues(short values[], const int& n) { values[0] = (short) value; }
 
    virtual void            getValues(byte values[], const int& n) { values[0] = (byte) value; }
 
    virtual GeoTessData&                        setValue(int attributeIndex, double v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual GeoTessData&                        setValue(int attributeIndex, float v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual GeoTessData&                        setValue(int attributeIndex, LONG_INT v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual GeoTessData&                        setValue(int attributeIndex, int v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual GeoTessData&                        setValue(int attributeIndex, short v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual GeoTessData&                        setValue(int attributeIndex, byte v)
    { if (attributeIndex == 0) value = (T) v; return *this; };
 
    virtual bool            isNaN(int attributeIndex) const {return false;};
 
    virtual GeoTessData*           copy()
    {
        return new GeoTessDataValue<T>(value);
    }
 
}; // end class DataValue
 
 
template<>
inline bool GeoTessDataValue<double>::isNaN(int attributeIndex) const
{
    return (std::isnan(value));
}
 
template<>
inline bool GeoTessDataValue<float>::isNaN(int attributeIndex) const
{
    double v = (double) value;
    return (std::isnan(v));
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<double>::getDataType() const
{
    return GeoTessDataType::DOUBLE;
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<float>::getDataType() const
{
    return GeoTessDataType::FLOAT;
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<LONG_INT>::getDataType() const
{
    return GeoTessDataType::LONG;
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<int>::getDataType() const
{
    return GeoTessDataType::INT;
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<short>::getDataType() const
{
    return GeoTessDataType::SHORT;
}
 
template<>
inline const GeoTessDataType&   GeoTessDataValue<byte>::getDataType() const
{
    return GeoTessDataType::BYTE;
}
 
 
} // end namespace geotess
 
#endif  // DATAVALUE_OBJECT_H