spyXmlBlockElements.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2006 MaK Technologies, Inc.
 ** All rights reserved.
 *********************************************************************/
/*******************************************************************************
 ** $RCSfile: spyXmlBlockElements.h,v $ $Revision: 1.13 $ $State: Exp $
 *******************************************************************************/
#ifndef DtSpyXmlBlockElements_H_
#define DtSpyXmlBlockElements_H_

#include <rtiMsConfig.h>
#include <mtl/env.h>
#include <vlutil/vlExceptions.h>
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlString.h>
#include <set>
#include <sstream>
#include <iomanip>

using namespace MAKRti;


class DtSpyXmlBlock;
class DtSpyXmlBlockElements;
typedef DtBoost::shared_ptr<DtSpyXmlBlockElements> DtSpyXmlBlockElementsSP;
typedef DtBoost::weak_ptr<DtSpyXmlBlockElements>   DtSpyXmlBlockElementsWP;

// Since DtSpyXmlBlockElements are designed to be contained as members of
// DtSpyXmlBlocks, this list uses standard pointers to avoid circular references
// when parent has a shared pointer to child which contains an instance of
// an Element
typedef std::set< DtSpyXmlBlockElements* > DtSpyXmlBlockElementsSet;

// The xmlTagName parameter of DtSpyXmlBlockElement templates must point to
// a global string with external linkage the DtDEFINE_SPY_XML_TAG(tagName) macro
// is provided for convenience to declare valid tags
#define DtDECLARE_SPY_XML_TAG(tagName) extern const char DT_DLL_WWW tagName[];
#define DtDEFINE_SPY_XML_TAG(tagName, tagString) const char tagName[] = tagString;


// Provides converion from String to native types
// Must be specialized for types with no built in conversion
// TODO: should probably add a format specifier ( ie std::hex )
//       to make this function truly generic
#ifdef __solaris__
// Solaris cannot specialize templates differentiated solely by return type
template<typename T>
T DtConvertStringToValueType( const DtString& stringRep, T* dummy = 0 );

// Specialize for strings -> no-op
template<>
DtString DtConvertStringToValueType<DtString>( const DtString& stringRep, DtString* dummy );
#else
template<typename T>
T DtConvertStringToValueType( const DtString& stringRep );

// Specialize for strings -> no-op
template<>
DtString DtConvertStringToValueType<DtString>( const DtString& stringRep );
#endif // __solaris__



// ABC used to handle pairs of DtSpyXmlBlock Member Data elements and pointers to their XML representation
class DT_DLL_WWW DtSpyXmlBlockElements
{
public:
   
   DtSpyXmlBlockElements( DtString xmlTag, bool isAttribute, DtSpyXmlBlock* parent );
   virtual ~DtSpyXmlBlockElements();
   inline DtEnvValueSP xmlNode() const;
   inline bool isAttribute() const;

   // Output
   DtString type() const;
   DtString toString() const;

protected:

   virtual void syncElementToValue() = 0;
   
   // Copy and assignment unimplemented since they would have to be shallow copies
   DtSpyXmlBlockElements( const DtSpyXmlBlockElements& orig );
   DtSpyXmlBlockElements& operator=( const DtSpyXmlBlockElements& orig );

protected:
   
   bool            myIsXmlAttribute;
   DtEnvValueSP    myXmlElement;
   DtSpyXmlBlock* myParent;
};

// Specific type for Member Data elements and pointers to their XML representation
template< typename ValueType, bool isXmlAttribute = true >
class DtSpyXmlBlockElement : public DtSpyXmlBlockElements
{
public:

   DtSpyXmlBlockElement( const char* xmlTagName, DtSpyXmlBlock* parent );
   DtSpyXmlBlockElement( const char* xmlTagName, ValueType value, DtSpyXmlBlock* parent );
   virtual ~DtSpyXmlBlockElement();

   void setValue( ValueType value );
   ValueType value() const;

   operator ValueType() const;
   DtSpyXmlBlockElement& operator=( const ValueType& val );

protected:

   virtual void syncElementToValue();

   // Copy and assignment unimplemented since they would have to be shallow copies
   DtSpyXmlBlockElement( const DtSpyXmlBlockElement& orig );
   DtSpyXmlBlockElement& operator=( const DtSpyXmlBlockElement& orig );

protected:

   ValueType myValue;
};


DtEnvValueSP DtSpyXmlBlockElements::xmlNode() const { return myXmlElement; }
bool DtSpyXmlBlockElements::isAttribute() const { return myIsXmlAttribute; }

template< typename ValueType, bool isXmlAttribute >
DtSpyXmlBlockElement<ValueType, isXmlAttribute>::DtSpyXmlBlockElement( const char* xmlTagName, DtSpyXmlBlock* parent ) :
   DtSpyXmlBlockElements( xmlTagName, isXmlAttribute, parent ),
#ifdef __solaris__
   myValue( DtConvertStringToValueType<ValueType>( myXmlElement->value(), 0 )) {}
#else
   myValue( DtConvertStringToValueType<ValueType>( myXmlElement->value() )) {}
#endif //__solaris__

template<typename ValueType, bool isXmlAttribute >
DtSpyXmlBlockElement<ValueType, isXmlAttribute>::DtSpyXmlBlockElement(  const char* xmlTagName, ValueType value, DtSpyXmlBlock* parent ) :
   DtSpyXmlBlockElements( xmlTagName, isXmlAttribute, parent ),
   myValue( value )
{
   myXmlElement->setValue( myValue );
}


template<typename ValueType, bool isXmlAttribute >
DtSpyXmlBlockElement<ValueType, isXmlAttribute>::~DtSpyXmlBlockElement() {}

template< typename ValueType, bool isXmlAttribute >
void DtSpyXmlBlockElement<ValueType, isXmlAttribute>::syncElementToValue() { myXmlElement->setValue( myValue ); }

template< typename ValueType, bool isXmlAttribute >
void DtSpyXmlBlockElement<ValueType, isXmlAttribute>::setValue( ValueType value )
{
   myValue = value;
   myXmlElement->setValue( myValue );
}

template< typename ValueType, bool isXmlAttribute >
ValueType DtSpyXmlBlockElement<ValueType, isXmlAttribute>::value() const { return myValue; }

template< typename ValueType, bool isXmlAttribute >
DtSpyXmlBlockElement<ValueType, isXmlAttribute>::operator ValueType() const
{
   return myValue;
}

template< typename ValueType, bool isXmlAttribute >
DtSpyXmlBlockElement<ValueType, isXmlAttribute>& 
   DtSpyXmlBlockElement<ValueType, isXmlAttribute>::operator=( const ValueType& val )
{
   setValue( val );
   return *this;
}


#ifdef __solaris__
// Solaris cannot specialize templates differentiated solely by return type
template<typename T>
T DtConvertStringToValueType( const DtString& stringRep, T* dummy )
#else
template<typename T>
T DtConvertStringToValueType( const DtString& stringRep )
#endif // __solaris__
{
   T nativeRep;
   std::istringstream convert( stringRep.c_str() );
   convert >> nativeRep;
   if ( convert.fail() )
   {
      DtString error( "Conversion Failure - failed to convert: " );
      DtTHROW_NEW( DtUnknownException, error + stringRep );
   }
   return nativeRep;
}


#endif // DtSpyXmlBlockElements_H_