Variant.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Copyright (C) 2009-2010 Cassio Neri Moreira
 *
 * This file is part of the KeyValue library.
 *
 * The KeyValue library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * The KeyValue library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with KeyValue. If not, see <http://www.gnu.org/licenses/>.
 *
 **************************************************************************/

#ifndef KEYVALUE_VALUE_VARIANT_H_
#define KEYVALUE_VALUE_VARIANT_H_

#include <iosfwd>

#include <boost/variant.hpp>

#include "keyvalue/extern/String.h"
#include "keyvalue/extern/Ptime.h"
#include "keyvalue/frontend/LexicalToolKit.h"
#include "keyvalue/value/Nothing.h"

namespace keyvalue {
namespace value {

// Forward declaration
class Single;

class Variant {

public:

  typedef boost::variant<Nothing, bool, double, ptime, string> DataType_;

  Variant();

  Variant(const DataType_& data);

  template <typename Rhs>
  Variant(const Rhs& rhs);

  Variant(const Single& data);

  template <typename Rhs>
  Variant&
  operator=(const Rhs& rhs);

  template <typename ElementType>
  bool
  is(frontend::LexicalToolKit::IO io) const;

  template <typename ElementType>
  ElementType
  get(frontend::LexicalToolKit::IO io) const;

  friend std::ostream&
  operator<<(std::ostream& os, const Variant& variant);

private:

  template <typename ElementType>
  const ElementType*
  get() const;

  DataType_ data_;

}; // class Variant

std::ostream&
operator<<(std::ostream& os, const Variant& rhs);

template <typename Rhs>
struct Parent;

template <>
struct Parent<Variant::DataType_> {
  typedef Variant Type_;
};

template <>
struct Parent<Nothing> {
  typedef Variant::DataType_ Type_;
};

template <>
struct Parent<bool> {
  typedef Variant::DataType_ Type_;
};

template <>
struct Parent<double> {
  typedef Variant::DataType_ Type_;
};

template <>
struct Parent<unsigned int> {
  typedef double Type_;
};

template <>
struct Parent<long unsigned int> {
  typedef double Type_;
};

template <>
struct Parent<string> {
  typedef Variant::DataType_ Type_;
};

template <>
struct Parent<char[]> {
  typedef string Type_;
};

template <size_t N>
struct Parent<char[N]> {
  typedef string Type_;
};

template <size_t N>
struct Parent<const char[N]> {
  typedef string Type_;
};

template <>
struct Parent<char *> {
  typedef string Type_;
};

template <>
struct Parent<ptime> {
  typedef Variant::DataType_ Type_;
};

/*--------------------------------------------------------------------------
 * Variant()
 *------------------------------------------------------------------------*/

template <typename Rhs>
Variant::Variant(const Rhs& rhs) :
  data_(Variant(typename Parent<Rhs>::Type_(rhs)).data_) {
}

/*--------------------------------------------------------------------------
 * operator=()
 *------------------------------------------------------------------------*/

template <typename Rhs>
Variant&
Variant::operator=(const Rhs& rhs) {
  return *this = typename Parent<Rhs>::Type_(rhs);
}

} // namespace value
} // namespace keyvalue

#endif // KEYVALUE_VALUE_VARIANT_H_