GeoTessMetaData.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 GEOTESSMETADATA_OBJECT_H
#define GEOTESSMETADATA_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <set>
#include <list>
#include <sstream>
#include <map>
 
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "CPPUtils.h"
#include "GeoTessUtils.h"
#include "GeoTessDataType.h"
#include "GeoTessException.h"
#include "IFStreamBinary.h"
#include "IFStreamAscii.h"
#include "EarthShape.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess
{
 
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP GeoTessMetaData
{
private:
 
    EarthShape earthShape;
 
    int modelFileFormat;
 
    string description;
 
    int nLayers;
 
    int nVertices;
 
    string* layerNames;
 
    int* layerTessIds;
 
    const GeoTessDataType* dataType;
 
    int nAttributes;
 
    string* attributeNames;
 
    string* attributeUnits;
 
    bool boolAttributeFilter;
 
    vector<int> attributeFilter;
 
    vector<int> inputFilter;
 
    string attributeFilterString;
 
    string inputModelFile;
 
    string inputGridFile;
 
    double loadTimeModel;
 
    string outputModelFile;
 
    string outputGridFile;
 
    double writeTimeModel;
 
    int refCount;
 
    bool reuseGrids;
 
    string modelSoftwareVersion;
 
    string modelGenerationDate;
 
    map<string, string> properties;
 
public:
 
    GeoTessMetaData()
            : earthShape(), description(""), nLayers(0), nVertices(0), layerNames(NULL), layerTessIds(
                    NULL), dataType(&GeoTessDataType::NONE), nAttributes(-1), attributeNames(
                    NULL), attributeUnits(NULL), boolAttributeFilter(false),
                    inputModelFile("none"), inputGridFile("none"), loadTimeModel(-1.0),
                    outputModelFile("none"), outputGridFile("none"), writeTimeModel(-1.0),
                    refCount(0), reuseGrids(true), modelSoftwareVersion(""), modelGenerationDate("")
    { }
 
    GeoTessMetaData(const string &fileName);
 
    GeoTessMetaData(const GeoTessMetaData& md);
 
    GeoTessMetaData& operator=(const GeoTessMetaData& other);
 
    bool operator==(const GeoTessMetaData& other);
 
    bool operator!=(const GeoTessMetaData& other)
    {
        return !(*this == other);
    }
 
    static  string class_name() { return "GeoTessMetaData"; }
 
    virtual ~GeoTessMetaData();
 
    LONG_INT getMemory()
    {
        LONG_INT memory = (LONG_INT) sizeof(GeoTessMetaData);
 
        // EarthShape earthShape;
        memory += (LONG_INT) sizeof(EarthShape);
 
        memory += (LONG_INT) (description.length() + attributeFilterString.length()
                + inputModelFile.length() + inputGridFile.length() + outputModelFile.length()
                + outputGridFile.length() + modelSoftwareVersion.length() + modelGenerationDate.length());
 
        // string* layerNames;
        memory += nLayers * (LONG_INT) sizeof(string);
        for (int i=0; i<nLayers; ++i)
            memory += (LONG_INT) layerNames[i].length();
 
        // int* layerTessIds;
        memory += nLayers * (LONG_INT)sizeof(int);
 
        // GeoTessDataType* dataType;
        memory += nLayers * (int)sizeof(GeoTessDataType);
 
        // string* attributeNames;
        // string* attributeUnits;
        if (nAttributes > 0)
        {
            memory += 2 * nAttributes * (LONG_INT) sizeof(string);
            for (int i=0; i<nAttributes; ++i)
            {
                memory += (LONG_INT) attributeNames[i].length();
                memory += (LONG_INT) attributeUnits[i].length();
            }
        }
 
        // vector<int> attributeFilter;
        memory += (LONG_INT) (attributeFilter.capacity() * sizeof(int));
 
        // vector<int> inputFilter;
        memory += (LONG_INT) (inputFilter.capacity() * sizeof(int));
 
        return memory;
    }
 
    GeoTessMetaData* copy()
    {
        GeoTessMetaData* cpy = new GeoTessMetaData(*this);
        return cpy;
    }
 
    bool isGridReuseOn()
    {
        return reuseGrids;
    }
 
    void setReuseGrids(bool rg)
    {
        reuseGrids = rg;
    }
 
    EarthShape& getEarthShape() { return earthShape; }
 
    void setEarthShape(const string& earthShapeName) { earthShape.setEarthShape(earthShapeName); }
 
    const string& getInputModelFile() const
    {
        return inputModelFile;
    }
 
    const string& getInputGridFile() const
    {
        return inputGridFile;
    }
 
    double getLoadTimeModel() const
    {
        return loadTimeModel;
    }
 
    const string& getOutputModelFile() const
    {
        return outputModelFile;
    }
    ;
 
    const string& getOutputGridFile() const
    {
        return outputGridFile;
    }
    ;
 
    double getWriteTimeModel() const
    {
        return writeTimeModel;
    }
    ;
 
    const string& getDescription() const
    {
        return description;
    }
    ;
 
    void setDescription(const string& dscr)
    {
        description = dscr;
        description = CPPUtils::stringReplaceAll("\r\n", "\n", description);
        description = CPPUtils::stringReplaceAll("\r", "\n", description);
        //description = CPPUtils::stringReplaceAll("\n", CPPUtils::NEWLINE, description);
 
        // make sure that description ends with a newline by removing
        // newline from the end if it exists and then adding it on.
        CPPUtils::removeEOL(description);
        description += CPPUtils::NEWLINE;
    }
 
    void setLayerNames(const string& lyrNms)
    {
        vector<string> layrNames;
        CPPUtils::tokenizeString(lyrNms, ";", layrNames);
        setLayerNames(layrNames);
    }
 
    void setLayerNames(vector<string>& layrNms);
 
    int getNVertices() const
    {
        return nVertices;
    }
 
    int getNLayers() const
    {
        return nLayers;
    }
 
    int getLayerIndex(const string& layerName) const;
 
    void getLayerNames(vector<string>& layers)
    {
        layers.clear();
        for (int i=0; i<nLayers; ++i)
            layers.push_back(layerNames[i]);
    }
 
    const string* const getLayerNames()
    {
        return layerNames;
    }
 
    string getLayerName(const int& layerIndex)
    {
        if (layerIndex < 0 || layerIndex >= nLayers)
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessMetaData::getLayerName(int layerIndex)" << endl
                    << "attributeIndex (" << layerIndex << ") is out of range (0-" << nLayers-1 << ")"
                    << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6001);
        }
 
        return layerNames[layerIndex];
    }
 
    string getLayerNamesString();
 
    void setLayerTessIds(int layrTsIds[])
    {
        if (nLayers <= 0)
        {
            ostringstream os;
            os   << "Cannot call GeoTessMetaData::setLayerTessIds() "
                << "before calling GeoTessMetaData::setLayerNames()" << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6002);
        }
 
        if (layerTessIds != NULL)
            delete[] layerTessIds;
        layerTessIds = new int[nLayers];
        for (int i=0; i<nLayers; ++i)
            layerTessIds[i] = layrTsIds[i];
    }
 
    void setLayerTessIds(vector<int>& layrTsIds);
 
    const int* getLayerTessIds() const
    {
        return layerTessIds;
    }
    ;
 
    int getTessellation(int layer) const
    {
        return layerTessIds[layer];
    }
 
    void getLayers(const int& tessId, vector<int>& layers)
    {
        layers.clear();
        for (int i=0; i<nLayers; ++i)
            if (layerTessIds[i] == tessId)
                layers.push_back(i);
    }
 
    int getFirstLayer(const int& tessId)
    {
        for (int i=0; i<nLayers; ++i)
            if (layerTessIds[i] == tessId)
                return i;
        return -1;
    }
 
    int getLastLayer(const int& tessId)
    {
        for (int i=nLayers-1; i >= 0; --i)
            if (layerTessIds[i] == tessId)
                return i;
        return -1;
    }
 
    const GeoTessDataType& getDataType() const
    {
        return *dataType;
    }
 
    void setDataType(const GeoTessDataType& dt);
 
    void setDataType(const string& dt);
 
    void getAttributeNames(vector<string>& attributes)
    {
        attributes.clear();
        for (int i = 0; i < nAttributes; ++i)
            attributes.push_back(attributeNames[i]);
    }
 
    void getAttributeUnits(vector<string>& units)
    {
        units.clear();
        for (int i = 0; i < nAttributes; ++i)
            units.push_back(attributeUnits[i]);
    }
 
    const string* const getAttributeNames()
    {
        return attributeNames;
    }
 
    const string* const getAttributeUnits()
    {
        return attributeUnits;
    }
 
    void setAttributes(const string& nms, const string& unts)
    {
        vector<string> names, units;
        CPPUtils::tokenizeString(nms, ";", names);
        CPPUtils::tokenizeString(unts, ";", units);
        if (names.size() != units.size())
        {
            ostringstream os;
            os   << "Error in GeoTessMetaData::setAttributes(const string& nms, const string& unts)" << endl
                    << "Attribute names size (" << names.size()
                    << ") is not equal to units size (" << units.size() << ")" << endl;
            names.clear(); units.clear();
            throw GeoTessException(os, __FILE__, __LINE__, 6009);
        }
        setAttributes(names, units);
 
        properties["attributeNames"] = nms;
        properties["attributeUnits"] = unts;
    }
 
    void setAttributes(const vector<string>& names, const vector<string>& units);
 
    int getNAttributes() const
    {
        return nAttributes;
    }
 
    const string& getAttributeName(int attributeIndex) const
    {
        if (attributeIndex < 0 || attributeIndex >= nAttributes)
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessMetaData::getAttributeName(int attributeIndex)" << endl
                    << "attributeIndex (" << attributeIndex << ") is out of range (0-" << nAttributes-1 << ")"
                    << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6003);
        }
 
        return attributeNames[attributeIndex];
    }
 
    int getAttributeIndex(string name);
 
    string getAttributeNamesString() const;
 
    string getAttributeUnitsString() const;
 
    const string& getAttributeUnit(int attributeIndex) const
    {
        if (attributeIndex < 0 || attributeIndex >= nAttributes)
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessMetaData::getAttributeUnit(int attributeIndex)" << endl
                    << "attributeIndex (" << attributeIndex << ") is out of range (0-" << nAttributes-1 << ")"
                    << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6004);
        }
        return attributeUnits[attributeIndex];
    }
 
    string getAttributeString(int attributeIndex) const
    {
        if (attributeIndex < 0 || attributeIndex >= nAttributes)
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessMetaData::getAttributeUnit(int attributeIndex)" << endl
                    << "attributeIndex (" << attributeIndex << ") is out of range (0-" << nAttributes-1 << ")"
                    << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6004);
        }
        return attributeNames[attributeIndex] + " (" + attributeUnits[attributeIndex]+")";
    }
 
    string toString(const string& className, LONG_INT memory) const;
 
    string toString() const;
 
    const string& getModelSoftwareVersion() { return modelSoftwareVersion; }
 
    const string& getModelGenerationDate()
    { return modelGenerationDate; }
 
    void setModelSoftwareVersion(const string& swVersion)
    { modelSoftwareVersion = swVersion; }
 
    void setModelGenerationDate(const string& genDate)
    { modelGenerationDate = genDate; }
 
    // All methods below this point are public but are not documented in the doxygen documentation.
    // These are methods that typical applications will never need to call.  They have to be
    // public because other classes in the GeoTess namespace need to access them.
    //
 
    bool applyAttributeFilter() { return boolAttributeFilter; }
 
    vector<int>& getAttributeFilter() { return attributeFilter; }
 
    void setAttributeFilter(vector<int>& filter) { inputFilter = filter; }
 
    void checkComplete();
 
    void loadMetaData(IFStreamBinary& input);
 
    void loadMetaData(IFStreamAscii& input);
 
    void writeMetaData(IFStreamAscii& output, const string& modelClassName,
            int nVertices);
 
    void writeMetaData(IFStreamBinary& output, const string& modelClassName,
            int nVertices);
 
    int getRefCount() { return refCount; }
 
    void addReference() { ++refCount; }
 
    void removeReference()
    {
        if (isNotReferenced())
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessMetaData::removeReference" << endl
                    << "Reference count (" << refCount << ") is already zero."
                    << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 6005);
        }
 
        --refCount;
    }
 
    bool isNotReferenced() { return (refCount == 0) ? true : false; }
 
    const map<string, string>& getProperties() { return properties; }
 
    void setNVertices(const int& nvert) { nVertices = nvert; }
 
    void setInputModelFile(const string& imf) { inputModelFile = imf; }
 
    void setInputGridFile(const string& igf) { inputGridFile = igf; }
 
    void setLoadTimeModel(double ltm) { loadTimeModel = ltm; }
 
    void setOutputModelFile(const string& omf) { outputModelFile = omf; }
 
    void setOutputGridFile(const string& ogf) { outputGridFile = ogf; }
 
    void setWriteTimeModel(double wtm) { writeTimeModel = wtm; }
 
    int getModelFileFormat() { return modelFileFormat; }
 
    void setModelFileFormat(int version) { modelFileFormat = version; }
 
 
};
// end class GeoTessMetaData
 
}// end namespace geotess
 
#endif  // GEOTESSMETADATA_OBJECT_H