dtk_val.hpp

Go to the documentation of this file.

#ifndef __DTK_VAL_HPP__
#define __DTK_VAL_HPP__
 
#include "def/define.h"
#include "dtk/config.hpp"
#include "util/BaseTypes/dtk_dir.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_status.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_uuid.hpp"
#include "util/error_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include <iosfwd>
#include <type_traits>
#include <utility>
 
enum Dtk_val_type{
    DTK_VAL_TYPE_UNKNOWN = 0,
    DTK_VAL_TYPE_INT,
    DTK_VAL_TYPE_CHAR,
    DTK_VAL_TYPE_DOUBLE,
    DTK_VAL_TYPE_STRING,
    DTK_VAL_TYPE_RGB,
    DTK_VAL_TYPE_PNT,
    DTK_VAL_TYPE_DIR,
    DTK_VAL_TYPE_UUID,
     DTK_VAL_TYPE_INTARRAY,
     DTK_VAL_TYPE_BUFFERDATA
};
 
namespace Dtk_Detail_Val
{
     template <Dtk_val_type v, bool trivial = false> struct Value : std::integral_constant<Dtk_val_type, v> { static bool const is_trivial = trivial; };
 
     template <typename T = void> struct ValueFor;
     template <> struct ValueFor<Dtk_Char8> : Value<DTK_VAL_TYPE_CHAR, true> {};
     template <> struct ValueFor<Dtk_Int32> : Value<DTK_VAL_TYPE_INT, true> {};
     template <> struct ValueFor<Dtk_Double64> : Value<DTK_VAL_TYPE_DOUBLE, true> {};
     template <> struct ValueFor<Dtk_RGB> : Value<DTK_VAL_TYPE_RGB> {};
     template <> struct ValueFor<Dtk_pnt> : Value<DTK_VAL_TYPE_PNT> {};
     template <> struct ValueFor<Dtk_dir> : Value<DTK_VAL_TYPE_DIR> {};
     template <> struct ValueFor<Dtk_UUID> : Value<DTK_VAL_TYPE_UUID> {};
     template <> struct ValueFor<Dtk_string> : Value<DTK_VAL_TYPE_STRING> {};
     template <> struct ValueFor<Dtk_tab<Dtk_Int32>> : Value<DTK_VAL_TYPE_INTARRAY> {};
     template <> struct ValueFor<Dtk_tab<Dtk_Char8>> : Value<DTK_VAL_TYPE_BUFFERDATA> {};
 
     template <typename T> struct Binder : ValueFor<T>
     {
          static T * GetPointer( void * u ) 
          { 
               return GetPointer( u, std::integral_constant<bool, Binder::is_trivial>() ); 
          }
          static T const * GetPointer( void const * u ) 
          { 
               return GetPointer( u, std::integral_constant<bool, Binder::is_trivial>() ); 
          }
     private:
          static T * GetPointer( void * u, std::integral_constant<bool, true> ) { return static_cast< T * >( u ); }
          static T * GetPointer( void * u, std::integral_constant<bool, false> ) { return *static_cast< T ** >( u ); }
          static T const * GetPointer( void const * u, std::integral_constant<bool, true> ) { return static_cast< T const * >( u ); }
          static T const * GetPointer( void const * u, std::integral_constant<bool, false> ) { return *static_cast< T * const * >( u ); }
     };
}
 
class Dtk_Val
{
protected: 
    union {
        Dtk_Int32 int_val;
        Dtk_Char8 char_val;
        Dtk_Double64 double_val;
        Dtk_string * string_val;
        Dtk_RGB * rgb_val;
        Dtk_pnt * pnt_val;
        Dtk_dir * dir_val;
        Dtk_UUID * uuid_val;
        Dtk_tab< Dtk_Int32 > * tab_val;
          Dtk_tab<Dtk_Char8> * buffer_val;
    }_val;
    enum Dtk_val_type _type;
    void _init() DTK_NOEXCEPT;
    void _reset() DTK_NOEXCEPT;
    void _copy(const Dtk_Val&s);
     void _move( Dtk_Val && ) DTK_NOEXCEPT;
public:
    Dtk_Val();
    Dtk_Val(const Dtk_Int32 val);
    Dtk_Val(const Dtk_Char8 val);
    Dtk_Val(const Dtk_Double64 val);
     Dtk_Val( const Dtk_Val& val );
     Dtk_Val( Dtk_Val && ) DTK_NOEXCEPT;
    Dtk_Val(const Dtk_string& val);
     Dtk_Val( Dtk_string && );
    Dtk_Val(const Dtk_RGB & val);
    Dtk_Val(const Dtk_pnt & val);
    Dtk_Val(const Dtk_dir & val);
     Dtk_Val(const Dtk_UUID & val);
     Dtk_Val(const Dtk_tab< Dtk_Int32 > & val);
     Dtk_Val( Dtk_tab<Dtk_Int32> && );
     Dtk_Val( Dtk_tab<Dtk_Char8> bd );
    Dtk_Val& operator = (const Dtk_Val& s);
     Dtk_Val & operator=( Dtk_Val && ) DTK_NOEXCEPT;
public:
    int         GetInt(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    char        GetChar(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    double      GetDouble(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    Dtk_string  GetString(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    Dtk_RGB     GetRgb(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    Dtk_pnt     GetPnt(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
    Dtk_dir     GetDir(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
     Dtk_UUID    GetUuid(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
     Dtk_tab< Dtk_Int32 >  GetIntArray(Dtk_status & st = Dtk_status::GetDefaultStatus()) const;
     Dtk_tab<Dtk_Char8> GetBufferData( Dtk_status & st = Dtk_status::GetDefaultStatus() ) const;
public:
     template <typename T> std::pair<bool, T> Get() const
     {
          typedef Dtk_Detail_Val::Binder<T> Binded;
          return ( _type == Binded::value )
               ? std::make_pair( true, *Binded::GetPointer( &_val ) )
               : std::make_pair( false, T() );
     }
     template <typename T> T * GetIf()
     {
          typedef Dtk_Detail_Val::Binder<T> Binded;
          return ( _type == Binded::value ) ? Binded::GetPointer( &_val ) : nullptr;
     }
     template <typename T> T const * GetIf() const
     {
          typedef Dtk_Detail_Val::Binder<T> Binded;
          return ( _type == Binded::value ) ? Binded::GetPointer( &_val ) : nullptr;
     }
public:
    Dtk_val_type GetValType() const;
public:
    ~Dtk_Val();
    friend std::ostream& operator<<(std::ostream& o,const Dtk_Val& d);
    Dtk_ErrorStatus _Store(void*);
};
 
 
 
 
#endif //#ifndef __DTK_VAL_HPP__