Class Struct

include/cpp/Pointer.h:127–197

template<typename T, typename HANDLER = DefaultStructHandler >
class Struct
{
public:
   T value;
   // This allows 'StaticCast' to be used from arrays
   typedef Dynamic Ptr;

   inline Struct( ) : value() {  }
   inline Struct( const T &inRHS ) : value(inRHS) {  }
   inline Struct( const null &) { value = T(); }
   inline Struct( const Reference<T> &);
   inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }

   template<class... TArgs>
   Struct(TArgs... args) : value(std::forward<TArgs>(args)...) {}

   inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
   inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
   inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }

   operator Dynamic() const
   {
      hx::Object *result = 0;
      HANDLER::handler(dhoToDynamic, (void *)&value, sizeof(T), &result );
      if (result)
         return result;
      return CreateDynamicStruct( &value, sizeof(T), HANDLER::handler);
   }
   operator String() const { return HANDLER::toString(&value); }

   inline Struct( const hx::Val &inRHS) { fromDynamic(inRHS.asObject()); }
   operator hx::Val() const { return operator Dynamic(); }

   bool operator==(const Struct<T,HANDLER> &inRHS) const { return value==inRHS.value; }
   bool operator==(const null &inRHS) const { return false; }
   bool operator!=(const null &inRHS) const { return true; }

   // Haxe uses -> notation
   inline T *operator->() { return &value; }

   T &get() { return value; }

   static inline bool is( const Dynamic &inRHS)
   {
      hx::Object *ptr = inRHS.mPtr;
      if (!ptr)
         return false;
      StructHandlerDynamicParams convert(ptr, ptr->__CStr());
      HANDLER::handler(dhoIs, 0, sizeof(T), &convert );
      return convert.outProcessed;
   }


   inline void fromDynamic( hx::Object *ptr)
   {
      if (!ptr)
      {
         value = T();