vpf_data_value.h

Go to the documentation of this file.

/*! \file
  \brief  The VPFDataValue class.

  \par Copyright Information

  Copyright (c) 2017 The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef _VPF_DATA_VALUE_H
#define _VPF_DATA_VALUE_H

#include "vpf_util.h"

namespace disti
{
// forward ref
class VPFFile;

/** encapsulates a data value in a VPF table */
class VPFDataValue
{
public:
    /** Create and load a data type of the given type and quantity from the given file
      * \param dataType desired data type
      * \param numVals number of values in data val (-1 for variable length)
      * \param infile file to read
      * \return new data value( Check IsValid() to ensure value was read
      *         successfully ) else NULL
      */
    static VPFDataValue* CreateDataValue( const VPFUtil::DataType dataType, const int numVals, VPFFile& infile );

    /** Dtor
      */
    ~VPFDataValue();

    /** Determine if the data value was created successfully
      * \return true if created successfully else false
      */
    bool IsValid( void ) const { return ( _isValid ); }

    /** Get the type of the data value
      * \return type of the data value
      */
    VPFUtil::DataType GetDataType( void ) const { return ( _dataType ); }

    /** Determine if this data value contains multiple values
      * \return true if data value contains multiple values or is a text value else false
      */
    bool IsMultipleValues( void ) const { return ( _isArray ); }

    /** Get the number of data values contained ( if IsMultipleValues() )
      * \return number of data values contained if IsMultipleValues() ( can be zero ).
      *         will also return 0u if !IsMultipleValues()
      *  NOTE: This value also represents the string length (not counting terminator) of the contained
      *        text value if _dataType is one of the DATA_TYPE_TEXT_<*> types.  A 0u returned in this
      *        case indicates that GetText() will return a NULL pointer.
      */
    unsigned int GetValueCount( void ) const { return ( _varLen ); }

    /** Get text value.
      * \pre IsValid(), data type is DATA_TYPE_TEXT, DATA_TYPE_TEXT_LATIN, DATA_TYPE_TEXT_FULL_LATIN
      *      or DATA_TYPE_TEXT_MULTILINGUAL
      * \return text value ( NOTE: can be NULL if a zero length variable length string was read )
      */
    const char* GetText( void ) const
    {
        DistiVPFAssert( _isValid && ( ( VPFUtil::DATA_TYPE_TEXT == _dataType ) || ( VPFUtil::DATA_TYPE_TEXT_LATIN == _dataType ) || ( VPFUtil::DATA_TYPE_TEXT_FULL_LATIN == _dataType ) || ( VPFUtil::DATA_TYPE_TEXT_MULTILINGUAL == _dataType ) ) );
        return ( _value.str );
    }

    /** Get the single short float value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_SHORT_FLOAT
      * \return short float value
      */
    VPFUtil::Float32 GetShortFloat( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_SHORT_FLOAT == _dataType ) );
        return ( _value.shortFloat );
    }

    /** Get multiple short float values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_SHORT_FLOAT
      * \return array of short float values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Float32* GetShortFloatValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_SHORT_FLOAT == _dataType ) );
        return ( _value.shortFloatArray );
    }

    /** Get the single long float value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_LONG_FLOAT
      * \return long float value
      */
    VPFUtil::Float64 GetLongFloat( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_LONG_FLOAT == _dataType ) );
        return ( _value.longFloat );
    }

    /** Get multiple long float values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_LONG_FLOAT
      * \return array of long float values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Float64* GetLongFloatValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_LONG_FLOAT == _dataType ) );
        return ( _value.longFloatArray );
    }

    /** Get the single short integer value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_SHORT_INTEGER
      * \return short integer value
      */
    VPFUtil::UInt16 GetShortInteger( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_SHORT_INTEGER == _dataType ) );
        return ( _value.shortInt );
    }

    /** Get multiple short integer values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_SHORT_INTEGER
      * \return array of short integer values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::UInt16* GetShortIntegerValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_SHORT_INTEGER == _dataType ) );
        return ( _value.shortIntArray );
    }

    /** Get the single long integer value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_LONG_INTEGER
      * \return long integer value
      */
    VPFUtil::UInt32 GetLongInteger( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_LONG_INTEGER == _dataType ) );
        return ( _value.longInt );
    }

    /** Get multiple long integer values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_LONG_INTEGER
      * \return array of long integer values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::UInt32* GetLongIntegerValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_LONG_INTEGER == _dataType ) );
        return ( _value.longIntArray );
    }

    /** Get the 2D coordinate short value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_2D_COORD_SHORT
      * \return 2D coordinate short value
      */
    const VPFUtil::Coord2DShort& GetCoord2DShort( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_2D_COORD_SHORT == _dataType ) );
        return ( _value.coord2DShort );
    }

    /** Get multiple 2D coordinate short values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_2D_COORD_SHORT
      * \return array of 2D coordinate short values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Coord2DShort* GetCoord2DShortValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_2D_COORD_SHORT == _dataType ) );
        return ( _value.coord2DShortArray );
    }

    /** Get the 2D coordinate long value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_2D_COORD_LONG
      * \return 2D coordinate long value
      */
    const VPFUtil::Coord2DLong& GetCoord2DLong( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_2D_COORD_LONG == _dataType ) );
        return ( _value.coord2DLong );
    }

    /** Get multiple 2D coordinate long values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_2D_COORD_LONG
      * \return array of 2D coordinate long values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Coord2DLong* GetCoord2DLongValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_2D_COORD_LONG == _dataType ) );
        return ( _value.coord2DLongArray );
    }

    /** Get the 3D coordinate short value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_3D_COORD_SHORT
      * \return 3D coordinate short value
      */
    const VPFUtil::Coord3DShort& GetCoord3DShort( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_3D_COORD_SHORT == _dataType ) );
        return ( _value.coord3DShort );
    }

    /** Get multiple 3D coordinate short values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_3D_COORD_SHORT
      * \return array of 3D coordinate short values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Coord3DShort* GetCoord3DShortValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_3D_COORD_SHORT == _dataType ) );
        return ( _value.coord3DShortArray );
    }

    /** Get the 3D coordinate long value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_3D_COORD_LONG
      * \return 3D coordinate long value
      */
    const VPFUtil::Coord3DLong& GetCoord3DLong( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_3D_COORD_LONG == _dataType ) );
        return ( _value.coord3DLong );
    }

    /** Get multiple 3D coordinate long values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_3D_COORD_LONG
      * \return array of 3D coordinate long values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Coord3DLong* GetCoord3DLongValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_3D_COORD_LONG == _dataType ) );
        return ( _value.coord3DLongArray );
    }

    /** Get the date time value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_DATE_TIME
      * \return date time value
      */
    const VPFUtil::DateTime& GetDateTime( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_DATE_TIME == _dataType ) );
        return ( _value.dateTime );
    }

    /** Get multiple date time values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_DATE_TIME
      * \return array of date time values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::DateTime* GetDateTimeValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_DATE_TIME == _dataType ) );
        return ( _value.dateTimeArray );
    }

    /** Get the VPF triplet value
      * \pre IsValid(), !IsMultipleValues(), data type is DATA_TYPE_TRIPLET
      * \return triplet value
      */
    const VPFUtil::Triplet& GetTriplet( void ) const
    {
        DistiVPFAssert( _isValid && !_isArray && ( VPFUtil::DATA_TYPE_TRIPLET == _dataType ) );
        return ( _value.triplet );
    }

    /** Get multiple triplet values
      * \pre IsValid(), IsMultipleValues(), data type is DATA_TYPE_TRIPLET
      * \return array of triplet values 'GetValueCount()' long, else NULL if a zero
      *         length array was read.
      */
    const VPFUtil::Triplet* GetTripletValues( void ) const
    {
        DistiVPFAssert( _isValid && _isArray && ( VPFUtil::DATA_TYPE_TRIPLET == _dataType ) );
        return ( _value.tripletArray );
    }

protected:
    VPFUtil::WarningBool _isValid;  /**< true if valid data value else false */
    VPFUtil::DataType    _dataType; /**< type of data value */
    bool                 _isArray;  /**< true if array of values else false if single val */
    unsigned int         _varLen;   /**< length of text in bytes if data is a text value ( DATA_TYPE_TEXT_<*> ), 
                                       * else number of elements if multiple vals, 0u if single val */
    union
    {
        char*                  str;               /**< character data if DATA_TYPE_TEXT, DATA_TYPE_TEXT_LATIN,
                                                    * DATA_TYPE_TEXT_FULL_LATIN, DATA_TYPE_TEXT_MULTILINGUAL */
        VPFUtil::Float32       shortFloat;        /**< DATA_TYPE_SHORT_FLOAT single val */
        VPFUtil::Float32*      shortFloatArray;   /**< DATA_TYPE_SHORT_FLOAT multiple vals */
        VPFUtil::Float64       longFloat;         /**< DATA_TYPE_LONG_FLOAT single val */
        VPFUtil::Float64*      longFloatArray;    /**< DATA_TYPE_LONG_FLOAT multiple vals */
        VPFUtil::UInt16        shortInt;          /**< DATA_TYPE_SHORT_INTEGER single val */
        VPFUtil::UInt16*       shortIntArray;     /**< DATA_TYPE_SHORT_INTEGER multiple vals */
        VPFUtil::UInt32        longInt;           /**< DATA_TYPE_LONG_INTEGER single val */
        VPFUtil::UInt32*       longIntArray;      /**< DATA_TYPE_LONG_INTEGER multiple vals */
        VPFUtil::Coord2DShort  coord2DShort;      /**< DATA_TYPE_2D_COORD_SHORT single val */
        VPFUtil::Coord2DShort* coord2DShortArray; /**< DATA_TYPE_2D_COORD_SHORT multiple vals */
        VPFUtil::Coord2DLong   coord2DLong;       /**< DATA_TYPE_2D_COORD_LONG single val */
        VPFUtil::Coord2DLong*  coord2DLongArray;  /**< DATA_TYPE_2D_COORD_LONG multiple vals */
        VPFUtil::Coord3DShort  coord3DShort;      /**< DATA_TYPE_3D_COORD_SHORT single val */
        VPFUtil::Coord3DShort* coord3DShortArray; /**< DATA_TYPE_3D_COORD_SHORT multiple vals */
        VPFUtil::Coord3DLong   coord3DLong;       /**< DATA_TYPE_3D_COORD_LONG single val */
        VPFUtil::Coord3DLong*  coord3DLongArray;  /**< DATA_TYPE_3D_COORD_LONG multiple vals */
        VPFUtil::DateTime      dateTime;          /**< DATA_TYPE_DATE_TIME single val */
        VPFUtil::DateTime*     dateTimeArray;     /**< DATA_TYPE_DATE_TIME multiple vals */
        VPFUtil::Triplet       triplet;           /**< DATA_TYPE_TRIPLET VPF triplet single val */
        VPFUtil::Triplet*      tripletArray;      /**< DATA_TYPE_TRIPLET VPF triplet multiple vals */
    } _value;

    /** Load and create a text value with the given length from the given file and assign the
      * given data type
      * \param textType DATA_TYPE_TEXT, DATA_TYPE_TEXT_LATIN, DATA_TYPE_TEXT_FULL_LATIN,
      *        or DATA_TYPE_TEXT_MULTILINGUAL
      * \param textLen number of bytes of text
      * \param infile file to read
      * \return new text value with type DATA_TYPE_TEXT and buffer length (textLen)
      *         plus one for terminator ( Check IsValid() to ensure value was read
      *         successfully ) else NULL
      */
    static VPFDataValue* CreateText( const VPFUtil::DataType textType, const unsigned int textLen,
        VPFFile& infile );

    /** Load and create a single short float value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_SHORT_FLOAT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateShortFloat( VPFFile& infile );

    /** Load and create a short float fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_SHORT_FLOAT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateShortFloatFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single long float value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_LONG_FLOAT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateLongFloat( VPFFile& infile );

    /** Load and create a long float fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_LONG_FLOAT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateLongFloatFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single short int value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_SHORT_INTEGER 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateShortInt( VPFFile& infile );

    /** Load and create a short int fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_SHORT_INTEGER 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateShortIntFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single long int value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_LONG_INTEGER 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateLongInt( VPFFile& infile );

    /** Load and create a long int fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_LONG_INTEGER 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateLongIntFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single 2D coord short value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_2D_COORD_SHORT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create2DCoordShort( VPFFile& infile );

    /** Load and create a 2D coord short fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_2D_COORD_SHORT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create2DCoordShortFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single 2D coord long value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_2D_COORD_LONG
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create2DCoordLong( VPFFile& infile );

    /** Load and create a 2D coord long fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_2D_COORD_LONG 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create2DCoordLongFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single 3D coord short value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_3D_COORD_SHORT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create3DCoordShort( VPFFile& infile );

    /** Load and create a 3D coord short fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_3D_COORD_SHORT 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create3DCoordShortFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single 3D coord long value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_3D_COORD_LONG 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create3DCoordLong( VPFFile& infile );

    /** Load and create a 3D coord long fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_3D_COORD_LONG 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* Create3DCoordLongFixed( const unsigned int num, VPFFile& infile );

    /** Load and create a single date time value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_DATE_TIME 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateDateTime( VPFFile& infile );

    /** Load and create a date time fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_DATE_TIME 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateDateTimeFixed( const unsigned int num, VPFFile& infile );

    /** Create a null data value
      * \return new value with type DATA_TYPE_NULL else (NULL)
      */
    static VPFDataValue* CreateNull( void );

    /** Load and create a VPF triplet value from the given file
      * \param infile file to read
      * \return new value with type DATA_TYPE_TRIPLET
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateTriplet( VPFFile& infile );

    /** Load and create a VPF triplet fixed array value from the given file
      * \param num number of elements in the array
      * \param infile file to read
      * \return new value with type DATA_TYPE_TRIPLET 
      *         ( Check IsValid() to ensure value was read successfully ) else NULL
      */
    static VPFDataValue* CreateTripletFixed( const unsigned int num, VPFFile& infile );

    /** Read a VPF triplet from the given file
      * \param infile file to read
      * \param dst [out] gets read triplet on success
      * \return true if success else false
      */
    static bool ReadTriplet( VPFFile& infile, VPFUtil::Triplet& dst );

    /** Read one value in a triplet value from the given file
      * \param infile file to read
      * \param type indicates number of bits in field to read ( 0 = 0bits, 1 = 8bits, 2 = 16bits, 3=32bits )
      * \param val [out] receives value read from file on success else 0u
      * \param isValid [out] receives true if a non zero bits value was read into 'val' else false
      * \return true on success else false
      */
    static bool ReadTripletValue( VPFFile& infile, const unsigned char type, VPFUtil::UInt32& val, bool& isValid );

    /** Ctor - not called by user directly (use static Create* methods)
      * \param dataType data type for new value
      */
    VPFDataValue( const VPFUtil::DataType dataType )
        : _isValid( false )
        , _dataType( dataType )
        , _isArray( false )
        , _varLen( 0u )
    {}

private:
    // Disable implicit generated members
    VPFDataValue& operator=( const VPFDataValue& rhs );
    VPFDataValue( const VPFDataValue& src );
};

} // end namespace disti

#endif // _VPF_DATA_VALUE_H