usAny.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef US_ANY_H
#define US_ANY_H
 
#include <algorithm>
#include <typeinfo>
#include <sstream>
#include <vector>
#include <list>
#include <set>
#include <map>
 
#include <usGlobalConfig.h>
#include <MitkCppMicroServicesExports.h>
 
namespace us {
 
class Any;
 
MITKCPPMICROSERVICES_EXPORT std::string any_value_to_string(const Any& any);
 
MITKCPPMICROSERVICES_EXPORT std::string any_value_to_json(const Any& val);
MITKCPPMICROSERVICES_EXPORT std::string any_value_to_json(const std::string& val);
MITKCPPMICROSERVICES_EXPORT std::string any_value_to_json(bool val);
 
template<class T>
std::string any_value_to_string(const T& val)
{
  std::stringstream ss;
  ss << val;
  return ss.str();
}
 
template<class T>
std::string any_value_to_json(const T& val)
{
  return any_value_to_string(val);
}
 
template<typename Iterator>
std::string container_to_string(Iterator i1, Iterator i2)
{
  std::stringstream ss;
  ss << "[";
  const Iterator begin = i1;
  for ( ; i1 != i2; ++i1)
  {
    if (i1 == begin) ss << any_value_to_string(*i1);
    else ss << "," << any_value_to_string(*i1);
  }
  ss << "]";
  return ss.str();
}
 
template<typename Iterator>
std::string container_to_json(Iterator i1, Iterator i2)
{
  std::stringstream ss;
  ss << "[";
  const Iterator begin = i1;
  for ( ; i1 != i2; ++i1)
  {
    if (i1 == begin) ss << any_value_to_json(*i1);
    else ss << "," << any_value_to_json(*i1);
  }
  ss << "]";
  return ss.str();
}
 
template<class E>
std::string any_value_to_string(const std::vector<E>& vec)
{
  return container_to_string(vec.begin(), vec.end());
}
 
template<class E>
std::string any_value_to_json(const std::vector<E>& vec)
{
  return container_to_json(vec.begin(), vec.end());
}
 
template<class E>
std::string any_value_to_string(const std::list<E>& l)
{
  return container_to_string(l.begin(), l.end());
}
 
template<class E>
std::string any_value_to_json(const std::list<E>& l)
{
  return container_to_json(l.begin(), l.end());
}
 
template<class E>
std::string any_value_to_string(const std::set<E>& s)
{
  return container_to_string(s.begin(), s.end());
}
 
template<class E>
std::string any_value_to_json(const std::set<E>& s)
{
  return container_to_json(s.begin(), s.end());
}
 
template<class M>
std::string any_value_to_string(const std::map<M, Any>& m);
 
template<class K, class V>
std::string any_value_to_string(const std::map<K, V>& m);
 
template<class M>
std::string any_value_to_json(const std::map<M, Any>& m);
 
template<class K, class V>
std::string any_value_to_json(const std::map<K, V>& m);
 
 
class Any
{
public:
 
  Any(): _content(nullptr)
  { }
 
  template <typename ValueType>
  Any(const ValueType& value)
    : _content(new Holder<ValueType>(value))
  { }
 
  Any(const Any& other)
    : _content(other._content ? other._content->Clone() : nullptr)
  { }
 
  ~Any()
  {
    delete _content;
  }
 
  Any& Swap(Any& rhs)
  {
    std::swap(_content, rhs._content);
    return *this;
  }
 
  template <typename ValueType>
  Any& operator = (const ValueType& rhs)
  {
    Any(rhs).Swap(*this);
    return *this;
  }
 
  Any& operator = (const Any& rhs)
  {
    Any(rhs).Swap(*this);
    return *this;
  }
 
  bool Empty() const
  {
    return !_content;
  }
 
  std::string ToString() const
  {
    return Empty() ? std::string() : _content->ToString();
  }
 
  std::string ToJSON() const
  {
    return Empty() ? "null" : _content->ToJSON();
  }
 
  const std::type_info& Type() const
  {
    return _content ? _content->Type() : typeid(void);
  }
 
private:
 
  class Placeholder
  {
  public:
    virtual ~Placeholder()
    { }
 
    virtual std::string ToString() const = 0;
    virtual std::string ToJSON() const = 0;
 
    virtual const std::type_info& Type() const = 0;
    virtual Placeholder* Clone() const = 0;
  };
 
  template <typename ValueType>
  class Holder: public Placeholder
  {
  public:
    Holder(const ValueType& value)
      : _held(value)
    { }
 
    std::string ToString() const override
    {
      return any_value_to_string(_held);
    }
 
    std::string ToJSON() const override
    {
      return any_value_to_json(_held);
    }
 
    const std::type_info& Type() const override
    {
      return typeid(ValueType);
    }
 
    Placeholder* Clone() const override
    {
      return new Holder(_held);
    }
 
    ValueType _held;
 
  private: // intentionally left unimplemented
    Holder& operator=(const Holder &);
  };
 
private:
    template <typename ValueType>
    friend ValueType* any_cast(Any*);
 
    template <typename ValueType>
    friend ValueType* unsafe_any_cast(Any*);
 
    Placeholder* _content;
};
 
class BadAnyCastException : public std::bad_cast
{
public:
 
  BadAnyCastException(const std::string& msg = "")
    : std::bad_cast(), _msg(msg)
  {}
 
  ~BadAnyCastException() throw() override {}
 
  const char * what() const throw() override
  {
    if (_msg.empty())
      return "us::BadAnyCastException: "
             "failed conversion using us::any_cast";
    else
      return _msg.c_str();
  }
 
private:
 
  std::string _msg;
};
 
template <typename ValueType>
ValueType* any_cast(Any* operand)
{
  return operand && operand->Type() == typeid(ValueType)
      ? &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held
      : nullptr;
}
 
template <typename ValueType>
const ValueType* any_cast(const Any* operand)
{
  return any_cast<ValueType>(const_cast<Any*>(operand));
}
 
template <typename ValueType>
ValueType any_cast(const Any& operand)
{
  ValueType* result = any_cast<ValueType>(const_cast<Any*>(&operand));
  if (!result) throw BadAnyCastException("Failed to convert between const Any types");
  return *result;
}
 
template <typename ValueType>
ValueType any_cast(Any& operand)
{
  ValueType* result = any_cast<ValueType>(&operand);
  if (!result) throw BadAnyCastException("Failed to convert between Any types");
  return *result;
}
 
template <typename ValueType>
const ValueType& ref_any_cast(const Any & operand)
{
  ValueType* result = any_cast<ValueType>(const_cast<Any*>(&operand));
  if (!result) throw BadAnyCastException("RefAnyCast: Failed to convert between const Any types");
  return *result;
}
 
template <typename ValueType>
ValueType& ref_any_cast(Any& operand)
{
  ValueType* result = any_cast<ValueType>(&operand);
  if (!result) throw BadAnyCastException("RefAnyCast: Failed to convert between Any types");
  return *result;
}
 
template <typename ValueType>
ValueType* unsafe_any_cast(Any* operand)
{
  return &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held;
}
 
template <typename ValueType>
const ValueType* unsafe_any_cast(const Any* operand)
{
  return any_cast<ValueType>(const_cast<Any*>(operand));
}
 
 
template<class K>
std::string any_value_to_string(const std::map<K, Any>& m)
{
  std::stringstream ss;
  ss << "{";
  typedef typename std::map<K, Any>::const_iterator Iterator;
  Iterator i1 = m.begin();
  const Iterator begin = i1;
  const Iterator end = m.end();
  for ( ; i1 != end; ++i1)
  {
    if (i1 == begin) ss << i1->first << " : " << i1->second.ToString();
    else ss << ", " << i1->first << " : " << i1->second.ToString();
  }
  ss << "}";
  return ss.str();
}
 
template<class K, class V>
std::string any_value_to_string(const std::map<K, V>& m)
{
  std::stringstream ss;
  ss << "{";
  typedef typename std::map<K, V>::const_iterator Iterator;
  Iterator i1 = m.begin();
  const Iterator begin = i1;
  const Iterator end = m.end();
  for ( ; i1 != end; ++i1)
  {
    if (i1 == begin) ss << i1->first << " : " << i1->second;
    else ss << ", " << i1->first << " : " << i1->second;
  }
  ss << "}";
  return ss.str();
}
 
template<class K>
std::string any_value_to_json(const std::map<K, Any>& m)
{
  std::stringstream ss;
  ss << "{";
  typedef typename std::map<K, Any>::const_iterator Iterator;
  Iterator i1 = m.begin();
  const Iterator begin = i1;
  const Iterator end = m.end();
  for ( ; i1 != end; ++i1)
  {
    if (i1 == begin) ss << "\"" << i1->first << "\" : " << i1->second.ToJSON();
    else ss << ", " << "\"" << i1->first << "\" : " << i1->second.ToJSON();
  }
  ss << "}";
  return ss.str();
}
 
template<class K, class V>
std::string any_value_to_json(const std::map<K, V>& m)
{
  std::stringstream ss;
  ss << "{";
  typedef typename std::map<K, V>::const_iterator Iterator;
  Iterator i1 = m.begin();
  const Iterator begin = i1;
  const Iterator end = m.end();
  for ( ; i1 != end; ++i1)
  {
    if (i1 == begin) ss << "\"" << i1->first << "\" : " << i1->second;
    else ss << ", " << "\"" << i1->first << "\" : " << i1->second;
  }
  ss << "}";
  return ss.str();
}
 
}
 
#endif // US_ANY_H