alvalue.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALVALUE_ALVALUE_ALVALUE_H_
#define _LIBALVALUE_ALVALUE_ALVALUE_H_

# include <cstdio>
# include <string>
# include <vector>

# include <alvalue/config.h>

namespace AL
{

#ifndef ALVALUE_VERBOSITY
# define ALVALUE_VERBOSITY

  typedef enum ALVALUE_API _TVerbosity {
    VerbosityNone=0,   
      VerbosityMini,   
      VerbosityMedium, 
      VerbosityFull    
      } Verbosity;
#endif

  class ALVALUE_API ALValue
  {
    friend void ConvertALValueToSoapXml(const ALValue *pAlValue,
                                        std::string &strToFill,
                                        bool bInAnArray);
    friend class ALNetwork;

  public:
    typedef int                                TALValueInt;
    typedef float                              TALValueFloat;
    typedef double                             TALValueDouble;
    typedef bool                               TALValueBool;
    typedef std::string                        TALValueString;

    typedef std::vector<unsigned char>         TAlValueBinaryData;
    typedef TAlValueBinaryData::iterator       ITAlValueBinaryData;
    typedef TAlValueBinaryData::const_iterator CITAlValueBinaryData;

    typedef std::vector<ALValue>               TAlValueArray;
    typedef TAlValueArray::iterator            ITAlValueArray;
    typedef TAlValueArray::const_iterator      CITAlValueArray;

    union unionValue {
      TAlValueArray      *asArray;  
      TALValueBool       asBool;    
      TALValueInt        asInt;     
      TALValueFloat      asFloat;   
      TALValueString     *asString; 
      TAlValueBinaryData *asObject; 
      TAlValueBinaryData *asBinary; 
    };

  public:
    enum Type {
      TypeInvalid = 0, 
      TypeArray,       
      TypeBool,        
      TypeInt,         
      TypeFloat,       
      TypeString,      
      TypeObject,      
      TypeBinary       
    };

  public:
    ALValue();
    ALValue(const bool &value);
    ALValue(const int &value);
    ALValue(const double &value);
    ALValue(const float &value);
    ALValue(const std::string &value);
    ALValue(const char *value);

    ALValue(const std::vector<std::string> &pListString);
    ALValue(const std::vector<float> &pListFloat);
    ALValue(const std::vector<int> &pListInt);

    ALValue(const void *value, int nBytes);
    ALValue(const char **pArrayOfString, int nNbrString);
    ALValue(const float *pFloat, int nNbrElement);
    ALValue(const int *pInt, int nNbrElement);

    ALValue(const TAlValueBinaryData &rhs);
    ALValue(ALValue const &rhs);

    virtual ~ALValue();

    void clear();

    ALValue& operator=(const ALValue &rhs);
    ALValue& operator=(const bool &rhs);
    ALValue& operator=(const int &rhs);
    ALValue& operator=(const double &rhs);
    ALValue& operator=(const float &rhs);
    ALValue& operator=(const char *rhs);
    ALValue& operator=(const TAlValueBinaryData &rhs);

    bool operator==(ALValue const &other) const;
    bool operator!=(ALValue const &other) const;

    operator       bool&();
    operator const bool() const;
    operator       int&();
    operator const int() const;
    operator       float&();
    operator const float() const;

    operator const double() const;

    operator       std::string&();
    operator const std::string&() const;

    operator       TAlValueBinaryData&();
    operator const TAlValueBinaryData&() const;
    operator const void*() const;

    typedef std::vector<std::string> TStringArray;
    typedef std::vector<float>       TFloatArray;
    typedef std::vector<int>         TIntArray;

    operator TStringArray() const;
    operator TFloatArray() const;
    operator TIntArray() const;

    ALValue& setObject(const void* pData, int nDataSizeInBytes);

    void     SetBinary(const void *rhs, int nDataSizeInBytes);
    ALValue& SetBinaryNoCopy(const void *rhs, int nDataSizeInBytes);

    const void* GetBinary() const;
    const void* getObject() const;

    float *getPtrValue();

    void ToStringArray(TStringArray &pArrayToFill,
                       bool bInsertDefaultOnError = false) const;
    void ToFloatArray(TFloatArray &pArrayToFill,
                      bool bInsertDefaultOnError = false) const;
    void ToIntArray(TIntArray &pArrayToFill,
                    bool bInsertDefaultOnError = false) const;


    ALValue& operator[](int i);

    const ALValue& operator[](int i) const;

    enum Type getType() const;

    bool isValid () const;
    bool isArray () const;
    bool isBool  () const;
    bool isInt   () const;
    bool isFloat () const;
    bool isString() const;
    bool isObject() const;
    bool isBinary() const;


    unsigned int getSize() const;


    void arrayReserve(int size);

    void arraySetSize(int size);

    void arrayPush(const ALValue &pSrcToCopyNotOwned);

    void arrayPopFront();

    std::string toString(Verbosity pnVerbosity = VerbosityMini) const;

    std::string toPythonBuffer() const;

    bool decodeB64(const char *pszB64);

    bool decodeB64Object(const char *pszB64);

    void encodeB64(std::string &strOutput) const;

    static enum Type deduceType(const char *szInput,
                                int nLimitToLen = 0x7FFFFFFF);

    void unSerializeFromText(const char *szInput,
                             int nLimitToLen = 0x7FFFFFFF);

    std::string serializeToText(void) const;

    static bool xUnSerializeFromText_InnerTest(void);

    template <typename T0>
      static ALValue array(const T0 &a0);
    template <typename T0, typename T1>
      static ALValue array(const T0 &a0, const T1 &a1);
    template <typename T0, typename T1, typename T2>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2);
    template <typename T0, typename T1, typename T2, typename T3>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3);
    template <typename T0, typename T1, typename T2, typename T3, typename T4>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4);
    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5);
    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6);
    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7);
    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7, const T8 &a8);
    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
      static ALValue array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7, const T8 &a8, const T9 &a9);

  protected:
    void xInvalidate();
    void xAssertCompatibleType(enum Type pnWantedType);
    void xAssertType(enum Type pnWantedType) const;
    void xAssertArraySize(int pnSize) const;
    void assertStruct();
    int              _type;
    union unionValue _value;

  public:
    const unionValue getUnionValue();

    TAlValueArray *getArrayPtr() const;

    static std::string TypeToString(enum Type pnType);

  };

  template <typename T0>
  ALValue ALValue::array(const T0 &a0)
  {
    ALValue result;
    result.arraySetSize(1);
    result[0] = a0;
    return result;
  }

  template <typename T0, typename T1>
  ALValue ALValue::array(const T0 &a0, const T1 &a1)
  {
    ALValue result;
    result.arraySetSize(2);
    result[0] = a0;
    result[1] = a1;
    return result;
  }

  template <typename T0, typename T1, typename T2>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2)
  {
    ALValue result;
    result.arraySetSize(3);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3)
  {
    ALValue result;
    result.arraySetSize(4);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4)
  {
    ALValue result;
    result.arraySetSize(5);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5)
  {
    ALValue result;
    result.arraySetSize(6);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    result[5] = a5;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6)
  {
    ALValue result;
    result.arraySetSize(7);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    result[5] = a5;
    result[6] = a6;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7)
  {
    ALValue result;
    result.arraySetSize(8);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    result[5] = a5;
    result[6] = a6;
    result[7] = a7;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7, const T8 &a8)
  {
    ALValue result;
    result.arraySetSize(9);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    result[5] = a5;
    result[6] = a6;
    result[7] = a7;
    result[8] = a8;
    return result;
  }

  template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
  ALValue ALValue::array(const T0 &a0, const T1 &a1, const T2 &a2, const T3 &a3, const T4 &a4, const T5 &a5, const T6 &a6, const T7 &a7, const T8 &a8, const T9 &a9)
  {
    ALValue result;
    result.arraySetSize(10);
    result[0] = a0;
    result[1] = a1;
    result[2] = a2;
    result[3] = a3;
    result[4] = a4;
    result[5] = a5;
    result[6] = a6;
    result[7] = a7;
    result[8] = a8;
    result[9] = a9;
    return result;
  }
} // namespace AL

std::ostream &operator<<(std::ostream &os, const AL::ALValue &a);

#endif  // _LIBALVALUE_ALVALUE_ALVALUE_H_