VcstLutInputItem.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * NAME: VcstLutInputItem.h
 *
 * DESCRIPTION: Base class for all Geolocation and Calibration LUT Input Item
 * object classes.  Provides basic functionality to read binary files and manage
 * data associated with characteristics of the files.
 *
 * Based on various IDPS object classes published by Raytheon Company that support
 * similar functionality.
 *
 *******************************************************************************/
 
#ifndef VcstLutInputItem_h
#define VcstLutInputItem_h
 
#include <string>
 
class VcstLutInputItem {
public:
 
    VcstLutInputItem(const std::string& groupName, size_t size);
 
    virtual ~VcstLutInputItem();
 
    static VcstLutInputItem* getInstance() {
        return new VcstLutInputItem;
    }
 
    virtual int getData();
 
    inline void* getDataPtr() const {
        return dataPtr_;
    }
 
    inline bool dataPtrUnknown() const {
        return !dataPtrEstablished();
    }
 
    const std::string getShortName() const;
 
    void setShortName(const std::string& shortName);
 
    const std::string getFilePath() const;
 
    void setFilePath(const std::string& filePath);
 
    const std::string getFileName() const;
 
    inline void setDataPtr(void* ptr) {
        dataPtr_ = ptr;
    }
 
protected:
 
    static const std::size_t MAX_IO_SIZE = 1073741824;
 
    virtual bool isItemOkForIO();
 
    inline const std::string getGroupName() const {
        return groupName_;
    }
 
    inline const size_t getDataSize() const {
        return dataSize_;
    }
 
    inline const bool dataPtrEstablished() const {
        return (dataPtr_ != 0);
    }
 
    inline void setGroupName(std::string strName) {
        groupName_ = strName;
    }
 
    inline void setDataSize(size_t size) {
        dataSize_ = size;
    }
 
    inline void setIsAllocated(bool bVal) {
        isAllocated_ = bVal;
    }
 
    size_t determineFileSize(const std::string& fileName);
 
    int allocateMemory(size_t size);
 
    void releaseMemory();
 
    virtual int convertEndianness();
 
    template<typename T>
    static void byteSwap(T& aValue);
 
    std::string groupName_;
 
private:
 
    VcstLutInputItem();
 
    VcstLutInputItem(const VcstLutInputItem& right);
 
    VcstLutInputItem& operator=(const VcstLutInputItem& right);
 
    int readMetadata(std::string filepath);
 
    void* dataPtr_;
 
    size_t dataSize_;
 
    bool isAllocated_;
 
    bool bLittleEndian_;
 
    std::string shortName_;
 
    std::string filePath_;
 
};
 
//---------------------------------------------------------------------------
// Converts the endianness of the parameter by performing the appropriate
// byte swapping.
//---------------------------------------------------------------------------
 
template<typename T>
void VcstLutInputItem::byteSwap(T& aValue) {
    T tempValue = aValue; // a temporary copy of the value
 
    // Pointers to the first byte of both variables
    unsigned char* aValuePtr = reinterpret_cast<unsigned char*> (&aValue);
    unsigned char* tempValuePtr = reinterpret_cast<unsigned char*> (&tempValue);
 
    // Swap the byte order
    for (unsigned int byte = 0; byte < sizeof (aValue); ++byte) {
        aValuePtr[byte] = tempValuePtr[(sizeof (aValue) - 1) - byte];
    }
}
 
#endif