anyreference.hpp

Go to the documentation of this file.

#pragma once
/*
**  Copyright (C) 2013 Aldebaran Robotics
**  See COPYING for the license
*/

#ifndef _QI_TYPE_DETAIL_ANYREFERENCE_HPP_
#define _QI_TYPE_DETAIL_ANYREFERENCE_HPP_

#include <vector>
#include <map>
#include <stdexcept>
#include <cmath>
#include <qi/atomic.hpp>
#include <qi/types.hpp>
#include <qi/api.hpp>
#include <qi/type/fwd.hpp>
#include <qi/type/detail/typeinterface.hpp>
#include <boost/type_traits/remove_const.hpp>

namespace qi {

class AnyReference;
using AnyReferenceVector = std::vector<AnyReference>;

namespace detail {

class QI_API AnyReferenceBase
{
protected:
  AnyReferenceBase();


  explicit AnyReferenceBase(TypeInterface* type);

  AnyReferenceBase(TypeInterface* type, void* value)
    : _type(type)
    , _value(value)
  {}

  AnyReference _element(const AnyReference& key, bool throwOnFailure, bool autoInsert);

public:
  std::pair<AnyReference, bool> convert(TypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(ListTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(StructTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(MapTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(IntTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(FloatTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(RawTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(StringTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(PointerTypeInterface* targetType) const;
  std::pair<AnyReference, bool> convert(DynamicTypeInterface* targetType) const;

  template<typename T>
  T* ptr(bool check = true);

  bool isValid() const;
  bool isValue() const;

  AnyReference convertCopy(TypeInterface* targetType) const;


  template <typename T>
  static AnyReference from(const T& ref);

  template <typename T>
  static AnyReference fromPtr(const T* ptr);

  AnyReference clone() const;
  void destroy();



  template<typename T>
  T to() const;

  template<typename T>
  T to(const T&) const;

  int64_t      toInt()    const;
  uint64_t     toUInt()   const;
  float        toFloat()  const;
  double       toDouble() const;
  std::string  toString() const;

  template<typename T>
  std::vector<T> toList() const;

  template<typename K, typename V>
  std::map<K, V> toMap() const;

  AnyObject  toObject() const;

  AnyValue toTuple(bool homogeneous) const;

  qi::Signature signature(bool resolveDynamic = false) const;
  TypeKind kind() const;
  AnyReference unwrap() const;


  template<typename T>
  T& as();

  int64_t&     asInt64()  { return as<int64_t>();}
  uint64_t&    asUInt64() { return as<uint64_t>();}
  int32_t&     asInt32()  { return as<int32_t>();}
  uint32_t&    asUInt32() { return as<uint32_t>();}
  int16_t&     asInt16()  { return as<int16_t>();}
  uint16_t&    asUInt16() { return as<uint16_t>();}
  int8_t&      asInt8()   { return as<int8_t>();}
  uint8_t&     asUInt8()  { return as<uint8_t>();}
  double&      asDouble() { return as<double>();}
  float&       asFloat()  { return as<float>();}
  std::string& asString() { return as<std::string>();}

  std::pair<char*, size_t> asRaw() const;

  AnyReference content() const;


  AnyReferenceVector asTupleValuePtr();
  AnyReferenceVector asListValuePtr();
  std::map<AnyReference, AnyReference> asMapValuePtr();

  void update(const AutoAnyReference& b);

  template<typename T>
  void set(const T& val);

  void set(int64_t v)            { setInt(v); }
  void set(int32_t v)            { setInt(v); }
  void set(uint64_t v)           { setUInt(v); }
  void set(uint32_t v)           { setUInt(v); }
  void set(float v)              { setFloat(v); }
  void set(double v)             { setDouble(v); }
  void set(const std::string& v) { setString(v); }

  void  setInt(int64_t v);
  void  setUInt(uint64_t v);
  void  setFloat(float v);
  void  setDouble(double v);
  void  setString(const std::string& v);
  void  setDynamic(const AnyReference &value);

  void  setRaw(const char *buffer, size_t size);

  void  setTuple(const AnyReferenceVector& values);


  template<typename K>
  AnyReference operator[](const K& key);
  AnyReference operator[](const AnyReference& key);

  template<typename E, typename K>
  E& element(const K& key);

  template<typename K>
  AnyReference at(const K& key);
  template<typename K>
  AnyReference at(const K& key) const;
  AnyReference at(const AnyReference& key);
  AnyReference at(const AnyReference& key) const;

  size_t size() const;

  //TODO: use AutoAnyReference
  template<typename T>
  void append(const T& element);
  void append(const AnyReference& element);

  template<typename K, typename V>
  void insert(const K& key, const V& val);
  void insert(const AnyReference& key, const AnyReference& val);


  template<typename K>
  AnyReference find(const K& key);

  AnyIterator begin() const; //we lie on const but GV does not honor it yet
  AnyIterator end() const;

  AnyReference operator*() const;


  TypeInterface* type() const { return _type; }
  std::vector<TypeInterface*> membersType() const;
  void* rawValue() const { return _value; }

protected:
  TypeInterface* _type;
  void*          _value;
};

} // namespace detail

class QI_API AnyReference : public detail::AnyReferenceBase {
public:
  AnyReference()
    : AnyReferenceBase()
  {}

  AnyReference(const AnyReferenceBase& rhs)
    : AnyReferenceBase(rhs)
  {}

  explicit AnyReference(TypeInterface* type)
    : AnyReferenceBase(type)
  {}

  AnyReference(TypeInterface* type, void* value)
    : AnyReferenceBase(type, value)
  {}

private:
  //block the dangerous automatic cast from AnyValue to AnyRef
  //use AnyValue::asReference() to take a ref on the content of a value.
  //use AnyValue::from(value) to take a ref on the value.
  AnyReference(const AnyValue& val)
  {
    throw std::runtime_error("invalid internal operation.");
  };
};

using AnyReferenceVector = std::vector<AnyReference>;
QI_API bool operator< (const AnyReference& a, const AnyReference& b);
QI_API bool operator==(const AnyReference& a, const AnyReference& b);
QI_API bool operator!=(const AnyReference& a, const AnyReference& b);

QI_API AnyReference makeGenericTuple(const AnyReferenceVector& values);

QI_API AnyReference makeGenericTuplePtr(
    const std::vector<TypeInterface*>& types,
    const std::vector<void*>& values);

class QI_API AutoAnyReference: public AnyReference
{
public:
  AutoAnyReference () {}
  AutoAnyReference(const AutoAnyReference& b)
    : AnyReference()
  {
    _value = b._value;
    _type = b._type;
  }

  AutoAnyReference(const AnyReference &self)
    : AnyReference(self)
  {}

  AutoAnyReference(const detail::AnyReferenceBase &self)
    : AnyReference(self)
  {}

  template<typename T>
  AutoAnyReference(const T& ptr)
  {
    *(AnyReference*)this = AnyReference::from(ptr);
  }
};

} // namespace qi

#include <qi/type/detail/anyreference.hxx>

#include <qi/type/typeinterface.hpp>

/* Since AnyReference does not handle its memory, it cannot be used
 * inside a AnyReference. use AnyValue instead.
 */
QI_NO_TYPE(qi::AnyReference);
QI_NO_TYPE(qi::AutoAnyReference);

#endif