//  //
//  #### #     #   #                                -= SQLiteX =-                              //
// #     #     ## ## Variant.h                                                                 //
//  ##   #      ###                                                                            //
//   ##  #      ###  SQLite variant type                                                       //
//     # #     ## ##                                                                           //
// ####  ##### #   # R1                                   (C)2005 Markus Ewald -> License.txt  //
//  //
#ifndef SQLITEX_VARIANT_H
#define SQLITEX_VARIANT_H

#include "SQLiteX/SQLiteX.h"
#include <string>
#include <vector>

namespace SQLiteX {

//  //
//  SQLiteX::Variant                                                                           //
//  //
/// SQLite variant
/** Variant which supports the data types allowed in a SQLite table. Useful since SQLite
    itself offers full variant semantics for individual values of a data set.
*/
class Variant {
  public:
    enum Type {
      T_NULL = SQLITE_NULL,
      T_INT = SQLITE_INTEGER,
      T_FLOAT = SQLITE_FLOAT,
      T_TEXT = SQLITE_TEXT,
      T_BLOB = SQLITE_BLOB,
    };

    /// Constructor
    SQLITEX_API Variant();
    /// Copy constructor
    SQLITEX_API Variant(const Variant &Value);
    /// Int constructor
    SQLITEX_API Variant(int nValue);
    /// Long long int constructor
    SQLITEX_API Variant(long long int nValue);
    /// Double constructor
    SQLITEX_API Variant(double dValue);
    /// String constructor
    SQLITEX_API Variant(const char *pszString);
    /// String constructor
    SQLITEX_API Variant(const std::string &sString);
    /// Blob constructor
    SQLITEX_API Variant(const std::vector<unsigned char> &Data);
    /// Blob constructor
    SQLITEX_API Variant(std::vector<unsigned char> &Data, bool bDestructive = false);
    /// Destructor
    SQLITEX_API ~Variant();

  //
  // Variant implementation
  //
  public:
    /// Reset contents
    SQLITEX_API void reset();

    /// Retrieve type of value
    SQLITEX_API inline Type getType() const { return m_eType; }

    /// Convert to specified type
    template<typename VarType> VarType to() const {
      return static_cast<VarType>(*this);
    }

    /// Assign copy
    SQLITEX_API Variant &operator =(const Variant &Value);
    /// Assign integer
    SQLITEX_API Variant &operator =(int nValue);
    /// Assign double
    SQLITEX_API Variant &operator =(double dValue);
    /// Assign string
    SQLITEX_API Variant &operator =(const char *pszString);
    /// Assign string
    SQLITEX_API Variant &operator =(const std::string &sString);
    /// Assign blob
    SQLITEX_API Variant &operator =(const std::vector<unsigned char> &Data);

    /// Convert to integer
    SQLITEX_API operator int() const;
    /// Convert to double
    SQLITEX_API operator double() const;
    /// Convert to string
    SQLITEX_API operator std::string() const;
    /// Convert to blob
    SQLITEX_API operator std::vector<unsigned char>() const;

  private:
    /// Actual type of the value
    Type m_eType;

    union {
      /// Integer value
      int m_nValue;
      /// Floating point value
      double m_dValue;
      /// String value
      std::string *m_psString;
      /// Blob value
      std::vector<unsigned char> *m_pData;
    };
};

} // namespace SQLiteX

#endif // SQLITEX_VARIANT_H