gls_metadata_attributes.h

Go to the documentation of this file.

/*! \file
  \brief  Defines templated metadata classes for DisplayObjects and other uses.
 
  \par Copyright Information
 
  Copyright (c) 2017 by 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 INCLUDED_GLS_METADATA_ATTRIBUTES_H
#define INCLUDED_GLS_METADATA_ATTRIBUTES_H
 
#include "display.h"
#include "disti_metadata.h"
#include "dynamic_array.h"
#include "gls_include.h"
#include "list.h"
#include "material.h"
#include "util.h"
#include "vertex.h"
 
#include <cassert>
#include <climits>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <locale>
#include <sstream>
#ifdef __VXWORKS__
#    include <ctype.h>
#else
#    include <cctype>
#endif
 
#ifdef DISTI_HAS_CPP11
#    include <functional>
#endif
 
namespace disti
{
const DistiAttributeBase::CallbackID DISTI_INVALID_CALLBACK_ID = ~0u; ///< Value to represent that a given callback was not successfully created.
 
/// Helper function used to remove converting int to bool performance warning on certain compilers.
/// \param value The value to convert.
/// \return The implictly converted value.
template<class T>
T ConvertToIntOrBool( int value )
{
    return static_cast<T>( value );
}
 
/// Helper function used to remove converting int to bool performance warning on certain compilers.
/// \param value The value to convert.
/// \return The implictly converted value.
template<>
inline bool ConvertToIntOrBool( int value )
{
    return value != 0;
}
 
/// Helper function used to convert string TRUE/FALSE/1/0 value into an appropriate boolean.
/// \param instr The stream to read a boolean string from.
/// \return The converted string value as a boolean.
template<class T>
T ReadValueAsIntOrBool( std::istream& instr )
{
    std::string value;
    instr >> value;
    T temp;
    if( strcasecmp( value.c_str(), "TRUE" ) == 0 )
    {
        temp = true;
    }
    else if( strcasecmp( value.c_str(), "FALSE" ) == 0 )
    {
        temp = false;
    }
    else
    {
        // Check based on an integer value
        temp = ConvertToIntOrBool<T>( atoi( value.c_str() ) );
    }
    return temp;
}
 
/// \cond INTERNAL
// Force the attribute classes to be instantiated
// so that they will be exported from the dll
// NOTE: These are not necessary if the class is instantiated or specialized elsewhere - BB
//template class DistiAttribute<unsigned char>;
 
// DistiAttribute<bool> Specialization
template<>
inline long DistiAttribute<bool>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<bool>::ValueInt( long val )
{
    *_attribPtr = ( val != 0 );
    CallCallback();
}
 
template<>
inline std::ostream& DistiAttribute<bool>::WriteValue( std::ostream& outstr )
{
    outstr << *_attribPtr;
 
    return outstr;
}
 
template<>
inline std::istream& DistiAttribute<bool>::ReadValue( std::istream& instr )
{
    *_attribPtr = ReadValueAsIntOrBool<bool>( instr );
    CallCallback();
    return instr;
}
 
// DistiAttribute<int> Specialization
template<>
inline long DistiAttribute<int>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<int>::ValueInt( long val )
{
    *_attribPtr = (int)val;
    CallCallback();
}
 
// DistiAttribute<short> Specialization
template<>
inline long DistiAttribute<short>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<short>::ValueInt( long val )
{
    *_attribPtr = (short)val;
    CallCallback();
}
 
// DistiAttribute<unsigned short> Specialization
template<>
inline long DistiAttribute<unsigned short>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<unsigned short>::ValueInt( long val )
{
    *_attribPtr = (unsigned short)val;
    CallCallback();
}
 
// DistiAttribute<unsigned char> Specialization
template<>
inline long DistiAttribute<unsigned char>::ValueInt() { return (long)*_attribPtr; }
template<>
inline void DistiAttribute<unsigned char>::ValueInt( long val )
{
    *_attribPtr = (unsigned char)val;
    CallCallback();
}
 
template<>
inline std::ostream& DistiAttribute<unsigned char>::WriteValue( std::ostream& outstr )
{
    // If we don't cast to int, an actual character will be written.  We want a number.
    outstr << (int)*_attribPtr;
    return outstr;
}
 
template<>
inline std::istream& DistiAttribute<unsigned char>::ReadValue( std::istream& instr )
{
    // If we don't cast to int, an actual character will be read.  We want a number.
    // Also, integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = static_cast<unsigned char>( ReadValueAsIntOrBool<int>( instr ) );
    CallCallback();
    return instr;
}
 
template<>
inline std::istream& DistiAttribute<int>::ReadValue( std::istream& instr )
{
    // integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = ReadValueAsIntOrBool<int>( instr );
    CallCallback();
    return instr;
}
 
template<>
inline std::istream& DistiAttribute<unsigned int>::ReadValue( std::istream& instr )
{
    // integer types should be able to read as TRUE or FALSE to preserve backwards compatibility for certain attributes (formerly handled by DistiAttributeUCharOrBool)
    *_attribPtr = ReadValueAsIntOrBool<unsigned int>( instr );
    CallCallback();
    return instr;
}
 
// DistiAttribute<float> Specialization
template<>
inline long DistiAttribute<float>::ValueInt() { return (long)*_attribPtr; }
 
template<>
inline void DistiAttribute<float>::ValueInt( long val )
{
    *_attribPtr = (float)val;
    CallCallback();
}
/// \endcond
 
/** Special case for transitioning from a bool to an int
  * Reads True or False, or integers.
  * Writes only integers. 
  */
class DistiAttributeUCharOrBool : public DistiAttribute<unsigned char>
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    GLS_EXPORT DistiAttributeUCharOrBool( CallbackMethodCallerBase* callback, const AttributeName& name, unsigned char* attribPtr );
 
    /// Constructor, creates local storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param value The initial value for this attribute.
    GLS_EXPORT DistiAttributeUCharOrBool( CallbackMethodCallerBase* callback, const AttributeName& name, unsigned char value );
 
    virtual GLS_EXPORT DistiAttributeBase& operator=( const DistiAttributeBase& oldClass ) DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT long ValueInt() DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void ValueInt( long val ) DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** For fixed length float arrays
  */
class DistiAttributeFloatArray : public DistiAttributeBase
{
    float* _array;  ///< An observing pointer to the underlying array storage.
    int    _length; ///< The length of the array in elements.
 
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param floatArray The underlying storage for the array.
    /// \param length The number of items in the array.
    GLS_EXPORT DistiAttributeFloatArray( CallbackMethodCallerBase* callback, const AttributeName& name, float* floatArray, int length );
 
    virtual GLS_EXPORT ~DistiAttributeFloatArray();
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::string Type() const DISTI_METHOD_OVERRIDE;
};
 
/** For fixed length double arrays
  */
class DistiAttributeDoubleArray : public DistiAttributeBase
{
    double* _array;  ///< An observing pointer to the underlying array storage.
    int     _length; ///< The length of the array in elements.
 
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param doubleArray The underlying storage for the array.
    /// \param length The number of items in the array.
    GLS_EXPORT DistiAttributeDoubleArray( CallbackMethodCallerBase* callback, const AttributeName& name, double* doubleArray, int length );
 
    virtual GLS_EXPORT ~DistiAttributeDoubleArray();
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::string Type() const DISTI_METHOD_OVERRIDE;
};
 
/** An enumeration for Texture Mode */
static DistiAttributeEnumDefList TextureModeEnumList(
    (char*)"TEXTURE_MAP_MODULATE", TEXTURE_MAP_MODULATE,
    (char*)"TEXTURE_MAP_DECAL", TEXTURE_MAP_DECAL,
    (char*)"TEXTURE_MAP_BLEND", TEXTURE_MAP_BLEND,
    (char*)"TEXTURE_MAP_REPLACE", TEXTURE_MAP_REPLACE,
    NULL );
 
/** Disti Attribute Texture Mode Enum */
template<class containerClass>
class DistiAttributeTextureModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributeTextureModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &TextureModeEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<TextureMap_e>();
    }
};
 
/** An enumeration for Texture Filter */
static DistiAttributeEnumDefList TextureFilterEnumList(
    (char*)"TEXTURE_FILTER_NEAREST", TEXTURE_FILTER_NEAREST,
    (char*)"TEXTURE_FILTER_LINEAR", TEXTURE_FILTER_LINEAR,
    (char*)"TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST", TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST,
    (char*)"TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR", TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR,
    (char*)"TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR", TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR,
    (char*)"TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST", TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST,
    NULL );
 
/** Disti Attribute Texture Filter Enum */
template<class containerClass>
class DistiAttributeTextureFilterEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributeTextureFilterEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &TextureFilterEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<TextureFilter_e>();
    }
};
 
/** An enumeration for Polygon Mode */
static DistiAttributeEnumDefList PolyModeEnumList(
    (char*)"POLY_MODE_UNDEFINED", POLY_MODE_UNDEFINED,
    (char*)"POLY_MODE_POINTS", POLY_MODE_POINTS,
    (char*)"POLY_MODE_OUTLINE", POLY_MODE_OUTLINE,
    (char*)"POLY_MODE_FILLED", POLY_MODE_FILLED,
    (char*)"POLY_MODE_FILL_AND_OUTLINE", POLY_MODE_FILL_AND_OUTLINE,
    NULL );
 
/** Disti Attribute Poly Mode Enum */
template<class containerClass>
class DistiAttributePolyModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributePolyModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &PolyModeEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<PolygonMode_e>();
    }
};
 
/** An enumeration for Polygon End Mode */
static DistiAttributeEnumDefList PolyEndEnumList(
    (char*)"POLY_OPEN", POLY_OPEN,
    (char*)"POLY_CLOSED", POLY_CLOSED,
    NULL );
 
/** Disti Attribute Poly End Enum */
template<class containerClass>
class DistiAttributePolyEndEnum : public DistiAttributeEnum<containerClass, int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();       ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributePolyEndEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &PolyEndEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<PolygonClose_e>();
    }
};
 
/** An enumeration for Shading enum */
static DistiAttributeEnumDefList ShadingEnumList(
    (char*)"FLAT", SHADING_FLAT,
    (char*)"GOURAUD", SHADING_GOURAUD,
    NULL );
 
/** Disti Attribute Shading Enum */
template<class containerClass>
class DistiAttributeShadingEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributeShadingEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &ShadingEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<ShadingType_e>();
    }
};
 
/** An enumeration for ColorMaterialMode enum */
template<class containerClass>
class DistiAttributeColorMaterialModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributeColorMaterialModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        static DistiAttributeEnumDefList ColorMaterialModeEnum(
            (char*)"NO_COLOR_MATERIAL", NO_COLOR_MATERIAL,
            (char*)"DIFFUSE_COLOR_MATERIAL", DIFFUSE_COLOR_MATERIAL,
            (char*)"AMBIENT_COLOR_MATERIAL", AMBIENT_COLOR_MATERIAL,
            (char*)"DIFFUSE_AND_AMBIENT_COLOR_MATERIAL", DIFFUSE_AND_AMBIENT_COLOR_MATERIAL,
            (char*)"EMISSION_COLOR_MATERIAL", EMISSION_COLOR_MATERIAL,
            (char*)"SPECULAR_COLOR_MATERIAL", SPECULAR_COLOR_MATERIAL,
            NULL );
 
        _pairList = &ColorMaterialModeEnum;
    }
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE { return false; }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<ColorMaterialMode_e>();
    }
};
 
/** An enumeration for Protection */
template<class containerClass>
class DistiAttributeProtectionEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame The object containing the set and get methods.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of this new attribute.
    DistiAttributeProtectionEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        static DistiAttributeEnumDefList ProtectionEnumList(
            (char*)"PUBLIC", PUBLIC,
            (char*)"PRIVATE", PRIVATE,
            (char*)"PROTECTED", PROTECTED,
            NULL );
        _pairList = &ProtectionEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<MemberAccess_e>();
    }
};
 
/** An enumeration for Alpha Mode */
static DistiAttributeEnumDefList AlphaModeEnumList(
    (char*)"ALPHA_MODE_UNDEFINED", ALPHA_MODE_UNDEFINED,
    (char*)"ALPHA_MODE_OPAQUE", ALPHA_MODE_OPAQUE,
    (char*)"ALPHA_MODE_2_LEVEL", ALPHA_MODE_2_LEVEL,
    (char*)"ALPHA_MODE_256_LEVEL", ALPHA_MODE_256_LEVEL,
    NULL );
 
/// \details The DistiAttributeAlphaModeEnum class.
template<class containerClass>
class DistiAttributeAlphaModeEnum : public DistiAttributeEnum<containerClass, const int, int>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttributeEnum<containerClass, const int, int> _BaseClass; ///< Deprecated typedef for the base class.
    typedef DistiAttributeEnum<containerClass, const int, int> BaseClass;  ///< Typedef for the base class.
    using BaseClass::_pairList;
 
    typedef void ( containerClass::*SetMethodType )( const int ); ///< Typedef for the set method function pointer.
    typedef int ( containerClass::*GetMethodType )();             ///< Typedef for the get method function pointer.
 
    /// Constructor
    /// \param frame Object containing the set and get methods.
    /// \param setMethod The set method function pointer to call.
    /// \param getMethod The get method function pointer to call.
    /// \param name The name of this new attribute.
    DistiAttributeAlphaModeEnum<containerClass>( containerClass* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name )
        : DistiAttributeEnum<containerClass, const int, int>( frame, setMethod, getMethod, name )
    {
        _pairList = &AlphaModeEnumList;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<AlphaMode_e>();
    }
};
 
/** An attribute for a char* string
  */
class DistiAttributeString : public DistiAttributeBase
{
    char* _local; ///< The underlying string storage for this attribute.
 
protected:
    char** _attribPtr; ///< A pointer to the pointer containing the underlying storage for this attribute.
 
public:
    /// This constructor makes the bold assumption that it can modify the contents.
    /// of the supplied char*, by realocating the memory.
    /// \param callback The callback function pointer to call.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to the pointer containing the original string value.
    GLS_EXPORT DistiAttributeString( CallbackMethodCallerBase* callback, const AttributeName& name, char** attribPtr );
 
    /// Creates local storage, and will resize as needed.
    /// \param callback The callback function pointer to call.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial string value.
    GLS_EXPORT DistiAttributeString( CallbackMethodCallerBase* callback, const AttributeName& name, char* initialValue );
 
    virtual GLS_EXPORT ~DistiAttributeString();
 
    /// \return The underlying string storage for this attribute.
    /// \note Be careful with this.
    GLS_EXPORT char* LocalStorageString();
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::string Type() const DISTI_METHOD_OVERRIDE;
};
 
/** Derived from DistiAttributeString, the only difference is that it 
  * reads and writes encoded strings instead of clear strings.
  */
class DistiAttributeEncodedString : public DistiAttributeString
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    GLS_EXPORT DistiAttributeEncodedString( CallbackMethodCallerBase* callback, const AttributeName& name, char** attribPtr );
 
    /// Constructor, creates local storage, and will resize as needed.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial string value for this attribute.
    GLS_EXPORT DistiAttributeEncodedString( CallbackMethodCallerBase* callback, const AttributeName& name, char* initialValue );
 
    // Normally ValueString just returns the value of WriteValue, but for encoded strings
    // this is probably not what we want, so have ValueString work with the unencoded string
    virtual GLS_EXPORT std::string ValueString() DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** Derived from DistiAttributeStdString, the only difference is that it 
  * reads and writes encoded strings instead of clear strings.
  */
class DistiAttributeEncodedStdString : public DistiAttribute<std::string>
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    GLS_EXPORT DistiAttributeEncodedStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string* attribPtr );
 
    /// Constructor, creates local storage, and will resize as needed.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial string value for this attribute.
    GLS_EXPORT DistiAttributeEncodedStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string initialValue );
 
    GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    // Normally ValueString just returns the value of WriteValue, but for encoded strings
    // this is probably not what we want, so have ValueString work with the unencoded string
    GLS_EXPORT std::string ValueString() DISTI_METHOD_OVERRIDE;
    GLS_EXPORT void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** For fixed length char array */
class DistiAttributeFixedString : public DistiAttributeBase
{
    char* _string; ///< Underlying storage for the string.
    int   _length; ///< Length of the underlying string storage in bytes.
 
public:
    /// Constructor
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param string The initial string value for this attribute.
    /// \param length The length of the string in bytes.
    GLS_EXPORT DistiAttributeFixedString( CallbackMethodCallerBase* callback, const AttributeName& name, char* string, int length );
 
    virtual GLS_EXPORT ~DistiAttributeFixedString();
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** Attribute for std::string */
class DistiAttributeStdString : public DistiAttribute<std::string>
{
    std::string _localStorageString; ///< Underlying storage for the string.
 
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    GLS_EXPORT DistiAttributeStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string* attribPtr );
 
    /// Constructor, creates local storage, and will resize as needed.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial string value for this attribute.
    GLS_EXPORT DistiAttributeStdString( CallbackMethodCallerBase* callback, const AttributeName& name, std::string initialValue );
 
    virtual GLS_EXPORT ~DistiAttributeStdString();
 
    /// \return A pointer to the underlying string storage.
    /// \note Be careful with this.
    GLS_EXPORT std::string* LocalStorageString();
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** Attribute for Location */
class DistiAttributeLocation : public DistiAttribute<Vertex>
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    GLS_EXPORT DistiAttributeLocation( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex* attribPtr );
 
    virtual GLS_EXPORT ~DistiAttributeLocation();
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
/** Attribute for a dictionary of attributes */
class DistiAttributeDictionaryAttribute : public DistiAttributeBase
{
protected:
    DistiAttribDict* _dict; ///< An observing pointer to a dictionary of attributes.
 
public:
    /// Constructor
    /// \param name The name of this new attribute.
    /// \param dict The attribute dictionary this attribute will point to.
    GLS_EXPORT DistiAttributeDictionaryAttribute( const AttributeName& name, DistiAttribDict* dict );
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    /// Add a new attribute to this property's dictionary.
    /// \param attr The attribute to add.
    virtual void Add( DistiAttributeBase* attr ) { _dict->Add( attr ); }
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::string Type() const DISTI_METHOD_OVERRIDE;
};
 
/** Attribute for a dictionary of attributes that cares for its siblings */
class DistiAttributeDictionaryAttributeSibling : public DistiAttributeBase
{
protected:
    DistiAttribDict*    _dict;    ///< An observing pointer to a dictionary of attributes.
    DistiAttributeBase* _sibling; ///< An observing pointer to this attribute's sibling.
    bool                _hasRead; ///< If true, ReadValue will be called on the sibling when ReadValue is called on this attribute.
 
public:
    /// Constructor
    /// \param name The name of this new attribute.
    /// \param dict The attribute dictionary this attribute will point to.
    /// \param sibling The sibling attribute for this attribute.
    GLS_EXPORT DistiAttributeDictionaryAttributeSibling( const AttributeName& name, DistiAttribDict* dict, DistiAttributeBase* sibling );
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    /// Add a new attribute to this property's dictionary.
    /// \param attr The attribute to add.
    virtual void Add( DistiAttributeBase* attr ) { _dict->Add( attr ); }
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT std::string Type() const DISTI_METHOD_OVERRIDE;
};
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
/** \class DistiAttributeStdMap
  * An attribute for a std::map
  */
template<class Map_t>
class DistiAttributeStdMap : public DistiAttributeBase
{
    Map_t* _attribPtr; ///< Storage for the underlying std::map type.
 
public:
    /// Constructor, from existing storage.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    DistiAttributeStdMap(
        CallbackMethodCallerBase* callback, const AttributeName& name, Map_t* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }
 
    /// Constructor, creates local storage, and will resize as needed.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    DistiAttributeStdMap( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Map_t() )
    {
    }
 
    virtual ~DistiAttributeStdMap()
    {
        if( _localStorage )
            delete _attribPtr;
        _attribPtr = NULL;
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return _attribPtr != 0 && _attribPtr->size();
    }
 
    /// \return A special value that identifies this attribute as being empty.
    static std::string GetEmptyValue() { return "$$DISTI_EMPTY$$"; }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        outstr << "\n"
               << DistiAttribDict::SpacingString() << "{\n";
        DistiAttribDict::SpacingInc();
 
        if( _attribPtr )
        {
            typename Map_t::iterator i;
            for( i = _attribPtr->begin(); i != _attribPtr->end(); ++i )
            {
                std::ostringstream str;
                str << i->second;
                const std::string second = str.str();
 
                outstr << DistiAttribDict::SpacingString() << i->first << " "
                       << ( second.empty() ? GetEmptyValue() : second ) << '\n';
            }
        }
 
        DistiAttribDict::SpacingDec();
        outstr << DistiAttribDict::SpacingString() << "}\n";
 
        return outstr;
    }
 
#if defined( _MSC_VER )
#    pragma warning( push )
#    pragma warning( disable : 4701 ) // GLS-11071
#endif
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        instr.ignore( INT_MAX, '{' );
 
        if( instr.good() )
        {
            std::stringstream fontStream;
            instr.get( *fontStream.rdbuf(), '}' );
            if( instr.good() )
            {
                instr.ignore( 1 );
                while( fontStream.good() )
                {
                    // Get rid of all the leading white space before reading the key
#ifdef _WIN32
                    std::stringstream::char_type c;
#else
                    // std::stringstream::char_type c; causes a parse error before `;' on Linux
                    char c;
#endif
                    do
                    {
                        fontStream.get( c );
#ifdef _WIN32
                    } while( fontStream.good() && std::isspace( c ) );
#else
                    } while( fontStream.good() && isspace( c ) );
#endif
 
                    if( fontStream.good() )
                    {
                        fontStream.putback( c );
 
                        typename Map_t::key_type    key;
                        typename Map_t::mapped_type value;
 
                        std::string strVal;
                        fontStream >> key;
                        std::getline( fontStream >> std::ws, strVal );
 
                        if( strVal != GetEmptyValue() )
                        {
                            std::istringstream str( strVal );
                            str >> value;
                        }
 
                        ( *_attribPtr )[ key ] = value;
                    }
                }
            }
        }
        return instr;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<Map_t>();
    }
 
#if defined( _MSC_VER )
#    pragma warning( pop )
#endif
}; // end DistiAttributeStdMap
 
/** \class DistiAttributeVertexArray
  * An attribute for either a Vector or Vertex 
  */
template<class T> // Either Vector or Vertex
class DistiAttributeVertexArray : public DistiAttributeBase
{
protected:
    T**           _attribPtr;         ///< Underlying storage for this attribute.
    typedef T*    Tptr;               ///< Shorthand typedef for a pointer to the template type.
    unsigned int* _numVertices;       ///< The number of vertices in a variable length array.
    unsigned int  _numElements;       ///< The number of vertices in a fixed length array.
    bool          _fixedArray;        ///< If true, this array is not resizable.
    bool          _compatabilityMode; ///< If true, backward compatibility mode will be used, values will be read with scanf.
 
public:
    /// Set the compatibility parsing mode for this attribute.
    /// \param mode The new mode to set.
    void SetCompatabilityMode( bool mode ) { _compatabilityMode = mode; }
 
    /// Constructor, for variable length arrays.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    /// \param numVertices The number of elements in the existing storage.
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, T** attribPtr, unsigned int* numVertices )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _numVertices( numVertices )
        , _numElements( 0 )
        , _fixedArray( false )
    {
        _compatabilityMode = true;
    }
 
    /// Constructor, for fixed arrays.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    /// \param numElements The number of elements in the existing storage.
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr, unsigned int numElements )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Tptr( attribPtr ) )
        , _numVertices( NULL )
        , _numElements( numElements )
        , _fixedArray( true )
    {
        _compatabilityMode = true;
    }
 
    virtual ~DistiAttributeVertexArray()
    {
        if( ( _fixedArray || _localStorage ) && _attribPtr )
            delete _attribPtr;
        _attribPtr = NULL;
    }
 
    /// \return True if this object is ready to have its WriteValue() called.
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( *_attribPtr != NULL );
    }
 
    /// Write data from this attribute into the stream.
    /// \param outstr The stream to write to.
    /// \return The stream in its current state.
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( *_attribPtr != NULL )
        {
            unsigned int numVerts = _numElements;
            if( !_fixedArray )
            {
                outstr << *_numVertices;
                numVerts = *_numVertices;
            }
            DistiAttribDict::SpacingInc();
            for( unsigned int i = 0; i < numVerts; i++ )
            {
                outstr << '\n';
                outstr << ( *_attribPtr )[ i ];
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
 
    /// Read data from the stream into this attribute.
    /// \param instr Stream to read from.
    /// \return The stream in its current state.
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        unsigned int numVerts = _numElements;
 
        if( !_fixedArray )
        {
            instr >> numVerts;
            *_numVertices = numVerts;
 
            // Remove old storage if any
            if( *_attribPtr != NULL )
                delete[] * _attribPtr;
 
            // Create new storage
            if( numVerts > 0 )
                *_attribPtr = new T[ numVerts ];
            else
                *_attribPtr = NULL;
        }
 
        if( !_compatabilityMode )
        {
            char buf[ 1024 ];
            // Get newline character
            instr.getline( buf, 1024 );
        }
 
        for( unsigned int i = 0; i < numVerts; i++ )
        {
            if( !_compatabilityMode )
            {
                char buf[ 1024 ];
                instr.getline( buf, 1024 );
#ifdef GLS_DEBUG
                int count =
#endif
                    std::sscanf( buf, "%f %f %f",
                        &( ( *_attribPtr )[ i ].x ),
                        &( ( *_attribPtr )[ i ].y ),
                        &( ( *_attribPtr )[ i ].z ) );
#ifdef GLS_DEBUG
                assert( 3 == count );
#endif
            }
            else
            {
                instr >> ( *_attribPtr )[ i ];
            }
        }
        CallCallback();
        return instr;
    }
 
    /// Equality operator
    /// \param rArg The object to compare to.
    /// \return Whether or not the objects are equal.
    virtual bool operator==( const DistiAttributeBase& rArg ) DISTI_METHOD_OVERRIDE
    {
        DistiAttributeVertexArray<T>* r = dynamic_cast<DistiAttributeVertexArray<T>*>( const_cast<DistiAttributeBase*>( &rArg ) );
        if( !r )
        {
            return DistiAttributeBase::operator==( rArg );
        }
 
        if( !( _name == r->_name ) || _numElements != r->_numElements )
            return false;
 
        for( unsigned int i = 0u; i < _numElements; ++i )
        {
            T leftVert  = ( *_attribPtr )[ i ];
            T rightVert = ( *r->_attribPtr )[ i ];
            if( !disti::Equal( leftVert.x, rightVert.x ) || !disti::Equal( leftVert.y, rightVert.y ) || !disti::Equal( leftVert.z, rightVert.z ) )
            {
                return false;
            }
        }
 
        return true;
    }
 
    /// Demangles type Tptr.
    /// \return String containing new name for type Tptr.
    /// \pre none
    /// \post none
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<Tptr>();
    }
};
 
/** An attribute for either a Vector or Vertex */
template<>
class DistiAttributeVertexArray<Vertex> : public DistiAttributeBase
{
protected:
    Vertex**        _attribPtr;         ///< Underlying storage for this attribute.
    typedef Vertex* Tptr;               ///< Shorthand typedef for a pointer to a vertex.
    unsigned int*   _numVertices;       ///< The number of vertices in a variable length array.
    unsigned int    _numElements;       ///< The number of vertices in a fixed length array.
    bool            _fixedArray;        ///< If true, this array is not resizable.
    bool            _compatabilityMode; ///< If true, backward compatibility mode will be used, values will be read with scanf.
 
public:
    /// Set the compatibility parsing mode for this attribute.
    /// \param mode The new mode to set.
    void SetCompatabilityMode( bool mode ) { _compatabilityMode = mode; }
 
    /// Constructor, for variable length arrays.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    /// \param numVertices The number of elements in the existing storage.
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex** attribPtr, unsigned int* numVertices )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _numVertices( numVertices )
        , _numElements( 0 )
        , _fixedArray( false )
    {
        _compatabilityMode = true;
    }
 
    /// Constructor, for fixed arrays.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    /// \param numElements The number of elements in the existing storage.
    DistiAttributeVertexArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vertex* attribPtr, unsigned int numElements )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new Tptr( attribPtr ) )
        , _numVertices( NULL )
        , _numElements( numElements )
        , _fixedArray( true )
    {
        _compatabilityMode = true;
    }
 
    virtual ~DistiAttributeVertexArray()
    {
        if( ( _fixedArray || _localStorage ) && _attribPtr )
            delete _attribPtr;
        _attribPtr = NULL;
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( *_attribPtr != NULL );
    }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( *_attribPtr != NULL )
        {
            unsigned int numVerts = _numElements;
            if( !_fixedArray )
            {
                outstr << *_numVertices;
                numVerts = *_numVertices;
            }
            DistiAttribDict::SpacingInc();
            for( unsigned int i = 0; i < numVerts; i++ )
            {
                outstr << '\n';
                outstr << ( *_attribPtr )[ i ];
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
 
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        unsigned int numVerts = _numElements;
 
        if( !_fixedArray )
        {
            instr >> numVerts;
            *_numVertices = numVerts;
 
            // Remove old storage if any
            if( *_attribPtr != NULL )
                delete[] * _attribPtr;
 
            // Create new storage
            *_attribPtr = new Vertex[ numVerts ];
        }
 
        if( !_compatabilityMode )
        {
            char buf[ 1024 ];
            // Get newline character
            instr.getline( buf, 1024 );
        }
 
        for( unsigned int i = 0; i < numVerts; i++ )
        {
            if( !_compatabilityMode )
            {
                char buf[ 1024 ];
                instr.getline( buf, 1024 );
                int r, g, b, a;
#ifdef GLS_DEBUG
                int count =
#endif
                    std::sscanf( buf, "%f %f %f %d %d %d %d",
                        &( ( *_attribPtr )[ i ].x ),
                        &( ( *_attribPtr )[ i ].y ),
                        &( ( *_attribPtr )[ i ].z ),
                        &r, &g, &b, &a );
#ifdef GLS_DEBUG
                assert( 7 == count );
#endif
 
                ( *_attribPtr )[ i ].color.RGBA( (unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a );
            }
            else
            {
                instr >> ( *_attribPtr )[ i ];
            }
        }
        CallCallback();
        return instr;
    }
 
    virtual bool operator==( const DistiAttributeBase& rArg ) DISTI_METHOD_OVERRIDE
    {
        DistiAttributeVertexArray<Vertex>* r = dynamic_cast<DistiAttributeVertexArray<Vertex>*>( const_cast<DistiAttributeBase*>( &rArg ) );
        if( !r )
        {
            return DistiAttributeBase::operator==( rArg );
        }
 
        if( !( _name == r->_name ) || _numElements != r->_numElements )
            return false;
 
        for( unsigned int i = 0u; i < _numElements; ++i )
        {
            Vertex leftVert  = ( *_attribPtr )[ i ];
            Vertex rightVert = ( *r->_attribPtr )[ i ];
            if( !disti::Equal( leftVert.x, rightVert.x ) || !disti::Equal( leftVert.y, rightVert.y ) || !disti::Equal( leftVert.z, rightVert.z ) || leftVert.color != rightVert.color )
            {
                return false;
            }
        }
 
        return true;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<Tptr>();
    }
};
 
/** This is used specifically for changing from TexturePoints as Vertexs to TexturePoints as Vectors.
  * It uses file version information to decide when expect what.
  */
class DistiAttributeTexturePointArray : public DistiAttributeVertexArray<Vector>
{
public:
    /// Constructor, for fixed arrays.
    /// \param callback The callback method function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to existing storage for this attribute.
    /// \param numElements The number of elements in the existing storage.
    DistiAttributeTexturePointArray( CallbackMethodCallerBase* callback, const AttributeName& name, Vector* attribPtr, unsigned int numElements )
        : DistiAttributeVertexArray<Vector>( callback, name, attribPtr, numElements )
    {
    }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        unsigned int numVerts = _numElements;
 
        for( unsigned int i = 0; i < numVerts; i++ )
        {
            outstr << '\n';
            outstr << ( *_attribPtr )[ i ];
        }
        return outstr;
    }
 
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        unsigned int numVerts = _numElements;
 
        for( unsigned int i = 0; i < numVerts; i++ )
        {
            // Get the whole line and then stream it into the Vector.
            // Before version 3.0, GL Studio files had full Vertex data
            // including color information stored after the location.
            // Reading whole lines comsumes this color information which is
            // then discarded.
            std::string line;
            std::getline( instr, line );
            // There must have been a leading newline, so read the first line again
            if( i == 0 && line.length() == 0 )
                std::getline( instr, line );
 
            std::stringstream strm( line );
            strm >> ( *_attribPtr )[ i ];
        }
        CallCallback();
        return instr;
    }
};
 
/** \class DistiAttributeNeverWrite
  * Allows for the normal template to be used to load a value but never write it out
  * This is used for compatability mostly.
  */
template<class T>
class DistiAttributeNeverWrite : public DistiAttribute<T>
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    DistiAttributeNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttribute<T>( callback, name, attribPtr )
    {
    }
 
    /// Constructor, creates local storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial value of the attribute.
    DistiAttributeNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, const T& initialValue )
        : DistiAttribute<T>( callback, name, initialValue )
    {
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE { return false; }
};
 
/** \class DistiAttributeStdStringNeverWrite
  * Allows for the normal template to be used to load a value but never write it out
  * This is used for compatability mostly.
  */
class DistiAttributeStdStringNeverWrite : public DistiAttributeStdString
{
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    DistiAttributeStdStringNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, std::string* attribPtr )
        : DistiAttributeStdString( callback, name, attribPtr )
    {
    }
 
    /// Constructor, creates local storage
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param initialValue The initial value of the attribute.
    DistiAttributeStdStringNeverWrite( CallbackMethodCallerBase* callback, const AttributeName& name, const std::string& initialValue )
        : DistiAttributeStdString( callback, name, initialValue )
    {
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE { return false; }
};
 
/** \class DistiAttributeAlias
  * Give an alternate name to an existing attribute.
  * This is used for compatability mostly. i.e. GlsTextBox "String" as an alias of "Text".
  */
class DistiAttributeAlias : public DistiAttributeBase
{
public:
    /// Constructor
    /// \param callback The method function pointer to call back.
    /// \param name The name to be given to this alias.
    /// \param originalName The name of the original attribute to link to.
    /// \param dict The attribute dictionary containing the original attribute.
    DistiAttributeAlias( CallbackMethodCallerBase* callback, const AttributeName& name, const AttributeName& originalName, DistiAttribDict* dict )
        : DistiAttributeBase( callback, name, false )
        , _originalAttribName( originalName )
        , _dictionary( dict )
    {
    }
 
    virtual DISTI_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT bool ValueChanged() DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void ResetValueChanged() DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT std::string ValueString() DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT long        ValueInt() DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void        ValueInt( long val ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT double      ValueFloat() DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void        ValueFloat( double val ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
    DISTI_EXPORT std::string        Type() const DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT bool       operator==( const DistiAttributeBase& r ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT CallbackID RegisterObserver( AttributeObserver* callback ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void       UnregisterObserver( CallbackID id ) DISTI_METHOD_OVERRIDE;
    virtual DISTI_EXPORT void       NotifyObservers() DISTI_METHOD_OVERRIDE;
 
protected:
    AttributeName    _originalAttribName; ///< Name of the original attribute that this alias points to.
    DistiAttribDict* _dictionary;         ///< The dictionary containing the original attribute.
};
 
/** \class DistiAttributeDynamicArray
  * An attribute for a dynamic array
  * T must be related to DynamicArray
  */
template<class T, bool showIndex /* In the output */>
class DistiAttributeDynamicArray : public DistiAttributeBase
{
    T* _attribPtr; ///< The underlying storage for this attribute.
 
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    DistiAttributeDynamicArray( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }
 
    /// Constructor, creates local storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    DistiAttributeDynamicArray( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new T() )
    {
    }
 
    ~DistiAttributeDynamicArray()
    {
        if( _localStorage )
            delete _attribPtr;
        _attribPtr = NULL;
    }
 
    bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( _attribPtr != NULL && _attribPtr->Capacity() );
    }
 
    std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( _attribPtr != NULL )
        {
            unsigned numEntries = _attribPtr->Count();
            outstr << numEntries;
 
            DistiAttribDict::SpacingInc();
 
            for( unsigned i = 0; i < numEntries; i++ )
            {
                outstr << '\n';
 
                if( showIndex )
                {
                    outstr << DistiAttribDict::SpacingString() << i << "    ";
                }
                outstr.width( 1 );
                outstr << DistiAttribDict::SpacingString() << ( *_attribPtr )[ i ] << " ";
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
 
    std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        unsigned numEntries = 0;
        instr >> numEntries;
 
        _attribPtr->Count( numEntries ); // Set count of objects in
        for( unsigned i = 0; i < numEntries; i++ )
        {
            // We read the entry number, which may differ from the index if values are skipped.
            unsigned entry = i;
            if( showIndex )
            {
                instr >> entry;
            }
            instr >> ( *_attribPtr )[ entry ];
        }
        CallCallback();
        return instr;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<T>();
    }
};
 
/** \class DistiAttributeStdVector
  * An attribute for a std::vector
  * T must be related to std::vector
  */
template<class T, bool showIndex /* In the output */>
class DistiAttributeStdVector : public DistiAttributeBase
{
private:
    T* _attribPtr; ///< The underlying storage for this attribute.
 
    DistiAttributeStdVector( const DistiAttributeStdVector& other );
 
public:
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    DistiAttributeStdVector( CallbackMethodCallerBase* callback, const AttributeName& name, T* attribPtr )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
    {
    }
 
    /// Constructor, creates local storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    DistiAttributeStdVector( CallbackMethodCallerBase* callback, const AttributeName& name )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new T() )
    {
    }
 
    virtual ~DistiAttributeStdVector()
    {
        if( _localStorage )
        {
            delete _attribPtr;
        }
        _attribPtr = NULL;
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( _attribPtr != NULL && _attribPtr->size() );
    }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( _attribPtr != NULL )
        {
            const std::size_t numEntries = _attribPtr->size();
            outstr << numEntries;
 
            DistiAttribDict::SpacingInc();
 
            for( std::size_t i = 0; i < numEntries; i++ )
            {
                outstr << '\n';
 
                if( showIndex )
                {
                    outstr << DistiAttribDict::SpacingString() << i << "    ";
                }
                outstr.width( 1 );
                outstr << DistiAttribDict::SpacingString() << ( *_attribPtr )[ i ] << " ";
            }
            DistiAttribDict::SpacingDec();
        }
        return outstr;
    }
 
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        if( _attribPtr != NULL )
        {
            int numEntries;
            instr >> numEntries;
 
            _attribPtr->resize( numEntries ); // Set count of objects in
            int entry;
            for( int i = 0; i < numEntries; i++ )
            {
                entry = i;
                if( showIndex )
                {
                    instr >> entry;
                }
                instr >> ( *_attribPtr )[ entry ];
            }
            CallCallback();
        }
 
        return instr;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<T>();
    }
};
 
/** An attribute for a DynamicArray of homogeneous items
  * T must have ReadValue and WriteValue methods
  * Replacement for DistiAttributeHomogeneousAttributeArray
  */
template<class T>
class DistiAttributeHomogeneousItemArray : public DistiAttributeBase
{
public:
    typedef T* ( *CreateItemCb )(); ///< Typedef for a function pointer used to create new items for the list.
 
protected:
    DynamicArray<T*>* _array;    ///< Underlying storage for this attribute.
    CreateItemCb      _createCb; ///< Function pointer called to create new items in the list.
 
public:
    /// Constructor requires a dynamic array of T*.
    /// Uses existing storage.
    /// \param name The name for this new attribute.
    /// \param array The underlying storage for this property.
    /// \param createCb The function pointer called to generate new objects of T for the list.
    DistiAttributeHomogeneousItemArray( const AttributeName& name, DynamicArray<T*>* array, CreateItemCb createCb )
        : DistiAttributeBase( NULL, name, false )
        , _array( array )
        , _createCb( createCb )
    {
    }
 
    virtual ~DistiAttributeHomogeneousItemArray() {}
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE { return _array && _array->Count(); }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        outstr << "\n"
               << DistiAttribDict::SpacingString() << "{\n";
        DistiAttribDict::SpacingInc();
        for( unsigned int i = 0; i < _array->Count(); i++ )
        {
            if( ( *_array )[ i ] )
            {
                outstr << DistiAttribDict::SpacingString();
                outstr << "Item: "; // Everything in the list is called Item
                ( ( *_array )[ i ] )->WriteValue( outstr );
                outstr << "\n";
            }
        }
        DistiAttribDict::SpacingDec();
        outstr << DistiAttribDict::SpacingString() << "}\n";
        return outstr;
    }
 
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        // Scan through the token including the ':'
        std::string buf;
 
        while( DistiAttribDict::ScanToken( instr, buf ) )
        {
            if( !buf.length() )
                continue;
 
            if( buf == "Item" )
            {
                // Eat the space between the : and the data
                instr.get();
                // Dynamically create it, and add it to the end of the list
                if( T* const createdItem = dynamic_cast<T*>( _createCb() ) )
                {
                    _array->PushBack( createdItem );
                    _array->Back()->ReadValue( instr );
                }
            }
        }
        return instr;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        // clang-format off
        return Demangle< DynamicArray<T*> >();
    // clang-format on
    }
};
/** The attribute used in generated code for accessing class properties
  * It can have a get method, set method, and an attribute pointer, or almost
  * any combination of the three.
  * T must have a default constructor, even if it doesn't initialize.
  * SetArgT is the argument type for the SetMethodType.  
  *  Specify this if the argument for the Set call is not "const &T".
  * GetReturnT is the return type for the GetMethodType.  
  *  Specify this if the return type for the Get call is not T
  * The get and set methods are called when the attribute interface is used for access.
  * If the methods are not provided, the attribute stream operators are used instead.
  * If the property does not have a method or attribute pointer, it will not be able to read/write its value.
  */
template<class containerT, class T, class SetArgT = const T&, class GetReturnT = T>
class DistiAttributeProperty : public DistiAttribute<T>
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DistiAttribute<T> _BaseClass;                           ///< Deprecated typedef for the base class.
    typedef DistiAttribute<T> BaseClass;                            ///< Typedef for the base class.
    typedef void ( containerT::*SetMethodType )( SetArgT );         ///< Typedef for the set method function pointer.
    typedef GetReturnT ( containerT::*GetMethodType )();            ///< Typedef for the get method function pointer.
    typedef GetReturnT ( containerT::*GetMethodConstType )() const; ///< Typedef for the get method const function pointer.
 
    float         _precision; ///< Number of digits of floating point precision.
    containerT*   _container; ///< Object that contains the set and get methods.
    SetMethodType _setMethod; ///< The set method function pointer.
    GetMethodType _getMethod; ///< The get method function pointer.
 
    /// Constructor
    /// \param name The name of the new attribute.
    /// \param frame The object containing the set and get methods.
    /// \param attribPtr The pointer to the underlying storage for this attribute.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    DistiAttributeProperty( const AttributeName& name, containerT* frame, T* attribPtr, SetMethodType setMethod, GetMethodType getMethod )
        : BaseClass( NULL, name, attribPtr )
        , _precision( 0 )
        , _container( frame )
        , _setMethod( setMethod )
        , _getMethod( getMethod )
    {
        // Automatically use some precision for floats
        if( typeid( T ) == typeid( float ) || typeid( T ) == typeid( double ) || typeid( T ) == typeid( long double ) )
        {
            _precision = 10;
        }
    }
 
    virtual bool OkToWrite() const DISTI_METHOD_OVERRIDE
    {
        return ( this->_attribPtr || _getMethod );
    }
 
    // The DistiAttribute<> classes override the DistiAttributeBase implementation for these methods.  Here, we revert back to the DistiAttributeBase implementation
    virtual std::string ValueString() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueString(); }
    virtual void        ValueString( const std::string& s ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueString( s ); }
 
    virtual long ValueInt() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueInt(); }
    virtual void ValueInt( long val ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueInt( val ); }
 
    virtual double ValueFloat() DISTI_METHOD_OVERRIDE { return DistiAttributeBase::ValueFloat(); }
    virtual void   ValueFloat( double val ) DISTI_METHOD_OVERRIDE { DistiAttributeBase::ValueFloat( val ); }
 
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        if( _precision > 0 )
            outstr.precision( int( _precision ) );
 
        if( _getMethod && _container )
        {
            // Save the current _attribPtr
            T* tempAttribPtr = this->_attribPtr;
 
            // Get the value from the method.
            T temp( ( _container->*_getMethod )() );
 
            // Temporarily change the _attribPtr
            this->_attribPtr = &temp;
 
            // Call the base class to format the _attribPtr
            BaseClass::WriteValue( outstr );
 
            // Put the _attribPtr back to where it belongs
            this->_attribPtr = tempAttribPtr;
        }
        else if( this->_attribPtr )
        {
            BaseClass::WriteValue( outstr );
        }
 
        return outstr;
    }
 
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        if( _setMethod && _container )
        {
            // Save the current _attribPtr
            T* tempAttribPtr = this->_attribPtr;
            T  temp;
 
            // Set _attribPtr to the temp variable;
            this->_attribPtr = &temp;
 
            // Call the base class to format the input
            BaseClass::ReadValue( instr );
 
            // Call the method
            ( _container->*_setMethod )( static_cast<SetArgT>( temp ) );
 
            this->_attribPtr = tempAttribPtr;
        }
        else if( this->_attribPtr )
        {
            BaseClass::ReadValue( instr );
        }
 
        return instr;
    }
 
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<T>();
    }
 
    virtual T Value() DISTI_METHOD_OVERRIDE
    {
        if( _getMethod && _container )
        {
            // Get the value from the method
            return ( _container->*_getMethod )();
        }
        else if( this->_attribPtr )
        {
            return BaseClass::Value();
        }
        else
        {
            return T();
        }
    }
 
    virtual void Value( const T& val ) DISTI_METHOD_OVERRIDE // this has to match the base class's prototype so we override it, ie can't use SetArgT here
    {
        if( _setMethod && _container )
        {
            ( _container->*_setMethod )( static_cast<SetArgT>( val ) );
        }
        else if( this->_attribPtr )
        {
            BaseClass::Value( val );
        }
    }
};
 
/// Overloaded helper function to create a DistiAttributeProperty where the setter param is of type Type and the getter is non-const. (See other variants below.)
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL)
/// \param getMethod The getter method for the property (can be NULL)
/// \return The DistiAttributeProperty instance, which is owned by the caller.
/// \code
///    Attributes().Add( CreateDistiAttributeProperty<int>( MetaTextureIndex, this, &DisplayObject::TextureIndex, &DisplayObject::TextureIndex ) );
/// \endcode
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                    attrName,
    Class* const                                                            obj,
    const typename DistiAttributeProperty<Class, Type, Type>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, Type, Type>::GetMethodType getMethod = NULL )
{
    return new DistiAttributeProperty<Class, Type, Type>( attrName, obj, NULL, setMethod, getMethod );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where the getter is const.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL).
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                         attrName,
    Class* const                                                                 obj,
    const typename DistiAttributeProperty<Class, Type, Type>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Type, Type>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type, Type>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type>::GetMethodType>( getMethod ) );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where there is no setter method and the getter is const.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename Type, class Class>
DistiAttributeProperty<Class, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                                   attrName,
    Class* const                                                           obj,
    const typename DistiAttributeProperty<Class, Type>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type>( attrName, obj, NULL, NULL,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type>::GetMethodType>( getMethod ) );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where there is no setter method and the getter is non-const.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename Type, class Class>
DistiAttributeProperty<Class, Type>* CreateDistiAttributeProperty(
    const AttributeName&                                              attrName,
    Class* const                                                      obj,
    const typename DistiAttributeProperty<Class, Type>::GetMethodType getMethod )
{
    return new DistiAttributeProperty<Class, Type>( attrName, obj, NULL, NULL, getMethod );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where the setter param is of type const Type& and the getter is non-const.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL).
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, const Type&>* CreateDistiAttributeProperty(
    const AttributeName&                                                           attrName,
    Class* const                                                                   obj,
    const typename DistiAttributeProperty<Class, Type, const Type&>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodType getMethod = NULL )
{
    return new DistiAttributeProperty<Class, Type, const Type&>( attrName, obj, NULL, setMethod, getMethod );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where the setter param is of type const Type& and the getter is const.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL).
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename Type, class Class>
DistiAttributeProperty<Class, Type, const Type&>* CreateDistiAttributeProperty(
    const AttributeName&                                                                attrName,
    Class* const                                                                        obj,
    const typename DistiAttributeProperty<Class, Type, const Type&>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Type, const Type&>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Type, const Type&>::GetMethodType>( getMethod ) );
}
 
/// Overloaded helper function to create a DistiAttributeProperty where the getter and setter are different base types (e.g. int vs bool).
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL).
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<typename GetReturnT, typename SetArgT, class Class>
DistiAttributeProperty<Class, GetReturnT, SetArgT>* CreateDistiAttributeProperty(
    const AttributeName&                                                             attrName,
    Class* const                                                                     obj,
    const typename DistiAttributeProperty<Class, GetReturnT, SetArgT>::SetMethodType setMethod,
    const typename DistiAttributeProperty<Class, GetReturnT, SetArgT>::GetMethodType getMethod )
{
    return new DistiAttributeProperty<Class, GetReturnT, SetArgT>( attrName, obj, NULL, setMethod, getMethod );
}
 
/// Overloaded helper function for properties that formerly used DistiAttributeLocation, which wraps properties that are stored in c++ as a Vertex but used in the Resources as a Vector.
/// \tparam Type The type of the property (int, float, GlsColor, etc.)
/// \tparam Class The class of the object that owns this parameter (typically a subclass of DisplayObject)
/// \param attrName The attribute name for this property.
/// \param obj The display object instance associated with this property.
/// \param setMethod The setter method for the property (can be NULL).
/// \param getMethod The getter method for the property (can be NULL).
/// \return The DistiAttributeProperty instance, which is owned by the caller.
template<class Class>
DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>* CreateDistiAttributePropertyVertexToVector(
    const AttributeName&                                                                                   attrName,
    Class* const                                                                                           obj,
    const typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::SetMethodType      setMethod,
    const typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::GetMethodConstType getMethod )
{
    return new DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>( attrName, obj, NULL, setMethod,
        reinterpret_cast<typename DistiAttributeProperty<Class, Vector, const Vertex&, const Vertex&>::GetMethodType>( getMethod ) );
}
 
/** An empty attribute used where a reference to an attribute
  * must be returned, but needs to be blank 
  */
class DistiEmptyAttribute : public DistiAttributeBase
{
public:
    DistiEmptyAttribute()
        : DistiAttributeBase( NULL, AttributeName( "EmptyAttribute" ), false )
    {
    }
 
    // Write nothing
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        return outstr;
    }
 
    // Read nothing
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
        return instr;
    }
};
 
/** \class DistiAttributeEnumDirect
  * A Disti Attribute which reads and writes enumerations directly, bypassing method calls.
  */
template<class enumType>
class DistiAttributeEnumDirect : public DistiAttributeBase
{
protected:
    enumType* _attribPtr; ///< Underlying storage for this attribute.
 
public:
    DistiAttributeEnumDefList* _pairList; ///< Observing pointer to the enum string to integer conversion data.
 
    /// Constructor, uses existing storage.
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param attribPtr A pointer to a pointer to existing storage for this attribute.
    /// \param pairList The enum string to integer data to use for this attribute.
    DistiAttributeEnumDirect( CallbackMethodCallerBase* callback, const AttributeName& name, enumType* attribPtr, DistiAttributeEnumDefList* pairList )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _pairList( pairList )
    {
    }
 
    /// Constructor, creates local storage
    /// \param callback The callback function pointer to call back.
    /// \param name The name of this new attribute.
    /// \param value The initial value for this attribute.
    /// \param pairList The enum string to integer data to use for this attribute.
    DistiAttributeEnumDirect( CallbackMethodCallerBase* callback, const AttributeName& name, const enumType& value, DistiAttributeEnumDefList* pairList )
        : DistiAttributeBase( callback, name, true )
        , _attribPtr( new enumType( value ) )
        , _pairList( pairList )
    {
    }
 
    virtual ~DistiAttributeEnumDirect()
    {
        if( _localStorage && _attribPtr )
            delete _attribPtr;
    }
 
    /// \return The attribute value as an integer.
    virtual long ValueInt() DISTI_METHOD_OVERRIDE { return (long)*_attribPtr; };
 
    /// Set the attribute value as an integer.
    /// \param val The new value to set.
    virtual void ValueInt( long val ) DISTI_METHOD_OVERRIDE { *_attribPtr = (enumType)val; };
 
    /// Assignment operator
    /// \param oldClass The object to copy from.
    /// \return The resulting object (this).
    virtual DistiAttributeBase& operator=( const DistiAttributeBase& oldClass ) DISTI_METHOD_OVERRIDE
    {
        DistiAttributeEnumDirect* ptr = dynamic_cast<DistiAttributeEnumDirect*>( const_cast<DistiAttributeBase*>( &oldClass ) );
        if( ptr )
        {
            *_attribPtr = ( enumType ) * ( ptr->_attribPtr );
            CallCallback();
        }
        else
        {
            return DistiAttributeBase::operator=( oldClass );
        }
        return *this;
    }
 
    /// Write data from this attribute into the stream.
    /// \param outstr The stream to write to.
    /// \return The stream in its current state.
    virtual std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE
    {
        bool foundIt = false;
#ifndef __VXWORKS__
        typename DistiAttributeEnumDefList::iterator item = _pairList->begin();
        while( item != _pairList->end() )
        {
            if( ( *item )->_enum == *_attribPtr )
            {
                outstr << ( *item )->_string;
                foundIt = true;
                break;
            }
            ++item;
        }
        if( !foundIt )
        {
            //Didn't find it so just write the number
            outstr << (int)*_attribPtr;
        }
#endif
 
        return outstr;
    }
 
    /// Read data from the stream into this attribute.
    /// \param instr The stream to read from.
    /// \return The stream in its current state.
    virtual std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE
    {
#ifndef __VXWORKS__
        char value[ 64 ];
        instr >> value;
 
        bool                                         foundIt = false;
        typename DistiAttributeEnumDefList::iterator item    = _pairList->begin();
 
        // First look by enumeration
        while( item != _pairList->end() )
        {
            if( strcmp( ( *item )->_string, value ) == 0 )
            {
                *_attribPtr = (enumType)( *item )->_enum;
                CallCallback();
 
                foundIt = true;
                break;
            }
            ++item;
        }
 
        // If not found, assume that the numerical value is specified.
        if( !foundIt )
        {
            *_attribPtr = (enumType)atoi( value );
            CallCallback();
        }
#endif
 
        return instr;
    }
 
    /// Demangles type enumType.
    /// \return String containing new name for type enumType.
    /// \pre none
    /// \post none
    std::string Type() const DISTI_METHOD_OVERRIDE
    {
        return Demangle<enumType>();
    }
};
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject callback.
/// \param instance The DisplayObject instance.
/// \param Class The current class name, derived from DisplayObject.
/// \param Method The class's method name for the callback.
/// \code{.cpp}
///    // Given a class ScrollList that inherits from DisplayObject...
///    ScrollList::ScrollList()
///    {
///        DISTI_REGISTER_METHOD_CALLBACK( this, &ScrollList::EventCallback );
///    }
///
///    int ScrollList::EventCallback( Group* self, DisplayEvent* ev )
///    {
///         // ... event handler code ...
///    }
/// \endcode
////////////////////////////////////////////////////////////////////////////////
#define DISTI_REGISTER_METHOD_CALLBACK( instance, Class, Method )                                             \
    {                                                                                                         \
        typedef CallbackMethodCallerTemplate<Class, Class> Caller;                                            \
        typedef typename Caller::MethodType1               MethodType;                                        \
        const MethodType                                   callback = reinterpret_cast<MethodType>( Method ); \
        ThisClass::CallbackCaller( new Caller( callback, instance ) );                                        \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject method caller for
/// MethodType 1.
/// \param object The DisplayObject instance.
/// \param method The method that should be called.
/// \param parent The parent to the object
////////////////////////////////////////////////////////////////////////////////
#define DISTI_SET_OBJECT_CALLBACK1( object, method, parent )            \
    ( object )->CallbackCaller(                                         \
        new CallbackMethodCallerTemplate<DisplayObject, DisplayObject>( \
            (disti::CallbackMethodCallerTemplate<DisplayObject, DisplayObject>::MethodType1)( method ), ( parent ) ) );
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type \a Type.
///                      Can be NULL if no member variable is desired.
/// \sa DISTI_ADD_ATTRIBUTE_CALLBACK
/// \sa DISTI_ADD_ATTRIBUTE_SET_GET
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE( Type, name, memberVarAddr )                                        \
    {                                                                                           \
        static const AttributeName           attr( name );                                      \
        CallbackAttributeNotifier<ThisClass> cb( this, attr );                                  \
        this->Attributes().Add( new DistiAttribute<Type>( &cb, ( attr ), ( memberVarAddr ) ) ); \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute that has a
/// callback function.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type \a Type.
///                      Can be NULL if no member variable is desired.
/// \param callbackFunction A member function pointer to the function called when this
///                 attribute is changed.
/// \sa DISTI_ADD_ATTRIBUTE
/// \sa DISTI_ADD_ATTRIBUTE_SET_GET
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_CALLBACK( Type, name, memberVarAddr, callbackFunction )                          \
    {                                                                                                        \
        typedef void ( ThisClass::*Method )(); /* Member function pointer */                                 \
        static const AttributeName           attr( name );                                                   \
        CallbackAttributeNotifier<ThisClass> cb( this, attr, reinterpret_cast<Method>( callbackFunction ) ); \
        this->Attributes().Add( new DistiAttribute<Type>( &cb, ( attr ), ( memberVarAddr ) ) );              \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a DisplayObject attribute that has a
/// setter and a getter function.
/// \param Type The type of the attribute.
/// \param name The unique string name identifying the attribute.
/// \param setter A member function pointer to the setter function (can be NULL)
/// \param getter A member function pointer to the getter function (can be NULL)
/// \sa DISTI_ADD_ATTRIBUTE
/// \sa DISTI_ADD_ATTRIBUTE_CALLBACK
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_SET_GET( Type, name, setter, getter )                                   \
    {                                                                                               \
        static const AttributeName attr( name );                                                    \
        this->Attributes().Add( CreateDistiAttributeProperty<Type>( attr, this, setter, getter ) ); \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a string as a DisplayObject attribute.
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type std::string.
///                      Can be NULL if no member variable is desired.
/// \sa DISTI_ADD_ATTRIBUTE_STRING_CALLBACK
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_STRING( name, memberVarAddr )                                         \
    {                                                                                             \
        static const AttributeName           attr( name );                                        \
        CallbackAttributeNotifier<ThisClass> cb( this, attr );                                    \
        this->Attributes().Add( new DistiAttributeEncodedStdString( &cb, attr, memberVarAddr ) ); \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup a string as a DisplayObject attribute
/// with a callback
/// \param name The unique string name identifying the attribute.
/// \param memberVarAddr A pointer to the member variable of type std::string.
///                      Can be NULL if no member variable is desired.
/// \param callbackFunction The function that gets called when the attribute changes.
/// \sa DISTI_ADD_ATTRIBUTE_STRING
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_STRING_CALLBACK( name, memberVarAddr, callbackFunction )                         \
    {                                                                                                        \
        typedef void ( ThisClass::*Method )(); /* Member function pointer */                                 \
        static const AttributeName           attr( name );                                                   \
        CallbackAttributeNotifier<ThisClass> cb( this, attr, reinterpret_cast<Method>( callbackFunction ) ); \
        this->Attributes().Add( new DistiAttributeEncodedStdString( &cb, attr, memberVarAddr ) );            \
    }
 
////////////////////////////////////////////////////////////////////////////////
/// A macro for boilerplate code to setup an alias to an existing DisplayObject attribute.
/// \param aliasName The unique string name identifying the attribute.
/// \param origName The unique string idenfifying the attribute to create the alias from.
/// \param obj The object containing the origName attribute.
/// \sa DISTI_ADD_ATTRIBUTE
////////////////////////////////////////////////////////////////////////////////
#define DISTI_ADD_ATTRIBUTE_ALIAS( aliasName, origName, obj )                                        \
    {                                                                                                \
        static const AttributeName aliasAttr( aliasName );                                           \
        static const AttributeName origAttr( origName );                                             \
        DistiAttribDict&           attributes = ( obj )->Attributes();                               \
        this->Attributes().Add( new DistiAttributeAlias( NULL, aliasAttr, origAttr, &attributes ) ); \
    }
 
#ifdef DISTI_HAS_CPP11
 
/// \details The AttributeFnCallback class. An implementation of the AttributeObserver interface.
class AttributeFnCallback : public AttributeObserver
{
public:
    /// Constructor
    /// \note Should not be called directly, call Connect().
    /// \param object The object associated with this callback.
    /// \param func The callback function pointer to call.
    AttributeFnCallback( WeakReferenceable* object, std::function<void()> func )
        : _func( std::move( func ) )
        , _object( object )
    {
        GLS_VERIFY( NULL != object );
    }
 
    void Call( DistiAttributeBase& ev ) DISTI_METHOD_OVERRIDE
    {
        if( IsValid() )
        {
            _func();
        }
    }
 
    virtual bool IsValid() const DISTI_METHOD_OVERRIDE
    {
        return !_object.IsNull() && _func;
    }
 
protected:
    std::function<void()>      _func;   ///< The callback function pointer to call.
    WeakRef<WeakReferenceable> _object; ///< The object associated with this callback, callback will only be called if this object is valid.
};
 
/// Helper function to create a new AttributeFnCallback object.
/// \note Should not be called directly, call Connect().
/// \param obj The object associated with this callback.
/// \param func The callback function pointer to call.
/// \return A new AttributeFnCallback object.
inline AttributeObserver* CreateAttributeFnCallback(
    WeakReferenceable* const     obj,
    const std::function<void()>& func )
{
    return new AttributeFnCallback( obj, func );
}
 
/// Helper function to link an object, attribute, and callback via a AttributeFnCallback object.
/// \param obj The object containing the resource to track.
/// \param resource The name of the resource to track.
/// \param funcOwner The owner of the callback (often the same as obj).
/// \param func The callback function pointer to call.
/// \return A valid CallbackID if successful, otherwise DISTI_INVALID_CALLBACK_ID.
inline DistiAttributeBase::CallbackID Connect( DisplayObject* obj, const std::string& resource, WeakReferenceable* funcOwner, std::function<void()> func )
{
    auto& res = obj->Resource( resource.c_str() );
    if( dynamic_cast<disti::DistiEmptyAttribute*>( &res ) )
    {
        std::cout << "Unknown attribute name: " << resource << std::endl;
        return DISTI_INVALID_CALLBACK_ID;
    }
 
    return res.RegisterObserver( CreateAttributeFnCallback( funcOwner, std::move( func ) ) );
}
#endif
 
/// Helper function to link an object, attribute, and callback via a CreateAttributeMethodCallback object.
/// \tparam Class the class of the object containing the callback.
/// \param obj The object containing the resource to track.
/// \param resource The name of the resource to track.
/// \param methodInstance The owner of the callback.
/// \param method The callback function pointer to call.
/// \return A valid CallbackID if successful, otherwise DISTI_INVALID_CALLBACK_ID
template<class Class>
DistiAttributeBase::CallbackID Connect( DisplayObject* obj, const std::string& resource, Class* const methodInstance, const typename AttributeMethodCallback<Class>::Callback method )
{
    DistiAttributeBase& res = obj->Resource( resource.c_str() );
    if( dynamic_cast<disti::DistiEmptyAttribute*>( &res ) )
    {
        std::cout << "Unknown attribute name: " << resource << std::endl;
        return DISTI_INVALID_CALLBACK_ID;
    }
    return res.RegisterObserver( CreateAttributeMethodCallback( methodInstance, method ) );
}
 
/// Unregisters an observer by deleting the underlying callback object.
/// \note Does nothing if a valid observer is not found.
/// \param obj The object containing the resource.
/// \param resource The name of the resource.
/// \param id The CallbackID returned from a Connect() function identifying the callback to disconnect.
inline void Disconnect( DisplayObject* obj, const std::string& resource, DistiAttributeBase::CallbackID id )
{
    DistiAttributeBase& res = obj->Resource( resource.c_str() );
    if( !dynamic_cast<disti::DistiEmptyAttribute*>( &res ) && id != DISTI_INVALID_CALLBACK_ID )
    {
        res.UnregisterObserver( id );
    }
}
 
} // namespace disti
 
#endif