Loading...
Searching...
No Matches
RDAny.h
Go to the documentation of this file.
// Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Novartis Institutes for BioMedical Research Inc.
// nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include <RDGeneral/export.h>
#ifndef RDKIT_RDANY_H
#define RDKIT_RDANY_H
#include <any>
#include <RDGeneral/BoostStartInclude.h>
#include <boost/utility.hpp>
#include <boost/lexical_cast.hpp>
#include <RDGeneral/BoostEndInclude.h>
#include "LocaleSwitcher.h"
#include "RDValue.h"
#include <string>
#include <vector>
#include <sstream>
namespace RDKit {
// RDValue does not dynamically create POD types (kind of like
// cdiggins::any) However, it doesn't use RTTI type info
// directly, it uses a companion short valued type
// to determine what to do.
// For unregistered types, it falls back to std::any.
// The Size of an RDAny is (sizeof(double) + sizeof(short) == 10 bytes)
//
// For the sake of compatibility, errors throw std::bad_any_cast
//
// Examples:
//
// RDAny v(2.);
// v = 1;
// std::vector<double> d;
// v == d;
// v.asDoubleVect().push_back(4.)
// rdany_cast<std::vector<double>(v).push_back(4.)
//
// Falls back to std::any for non registered types
// v = boost::shared_ptr<ROMol>(new ROMol(m));
//
// Safe container for RDValue -- cleans up memory and copy constructs
struct RDAny {
RDValue m_value;
RDAny() : m_value() {}
template <class T>
RDAny(const T &d) : m_value(d) {}
/*
explicit RDAny(bool v) : m_value(v) {}
template <class T>
explicit RDAny(std::vector<T> *v) : m_value(v) {}
template <class T>
explicit RDAny(const boost::shared_ptr<T> &v) : m_value(v) {}
*/
RDAny(const RDAny &rhs) { copy_rdvalue(m_value, rhs.m_value); }
~RDAny() { RDValue::cleanup_rdvalue(m_value); }
// For easy of use:
// RDAny v;
// v = 2.0;
// v = std::string("foo...");
RDAny &operator=(const RDAny &rhs) {
copy_rdvalue(m_value, rhs.m_value);
return *this;
}
RDAny &operator=(float d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(int d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(unsigned int d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(bool d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::string &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::vector<double> &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::vector<float> &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::vector<int> &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::vector<unsigned int> &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = d;
return *this;
}
RDAny &operator=(const std::vector<std::string> &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d);
return *this;
}
RDAny &operator=(const std::any &d) {
RDValue::cleanup_rdvalue(m_value);
m_value = RDValue(d); // new std::any(d);
return *this;
}
template <class T>
RDAny &operator=(const T &d) {
RDValue::cleanup_rdvalue(m_value);
std::any *v = new std::any(d);
m_value = RDValue(v);
return *this;
}
};
////////////////////////////////////////////////////////////////
// rdany_cast
////////////////////////////////////////////////////////////////
// Const Access
template <class T>
const T rdany_cast(const RDAny &d) {
return rdvalue_cast<T>(d.m_value);
}
// Direct access
template <class T>
T rdany_cast(RDAny &d) {
return rdvalue_cast<T>(d.m_value);
}
template <class T>
typename boost::enable_if<boost::is_arithmetic<T>, T>::type from_rdany(
const RDAny &arg) {
T res;
if (arg.m_value.getTag() == RDTypeTag::StringTag) {
Utils::LocaleSwitcher ls;
try {
res = rdany_cast<T>(arg);
} catch (const std::bad_any_cast &exc) {
try {
res = boost::lexical_cast<T>(rdany_cast<std::string>(arg));
} catch (...) {
throw exc;
}
}
} else {
res = rdany_cast<T>(arg);
}
return res;
}
template <class T>
typename boost::disable_if<boost::is_arithmetic<T>, T>::type from_rdany(
const RDAny &arg) {
return rdany_cast<T>(arg);
}
} // namespace RDKit
#endif
BoostEndInclude.h
BoostStartInclude.h
LocaleSwitcher.h
RDValue.h
RDKit::Utils::LocaleSwitcher
Definition LocaleSwitcher.h:44
export.h
RDKit::RDTypeTag::StringTag
static const boost::uint64_t StringTag
Definition RDValue-doublemagic.h:103
RDKit
Std stuff.
Definition Abbreviations.h:19
RDKit::copy_rdvalue
void copy_rdvalue(RDValue &dest, const RDValue &src)
Definition RDValue-doublemagic.h:339
RDKit::rdany_cast
const T rdany_cast(const RDAny &d)
Definition RDAny.h:178
RDKit::rdvalue_cast
T rdvalue_cast(RDValue_cast_t v)
Definition RDValue-doublemagic.h:420
RDKit::from_rdany
boost::enable_if< boost::is_arithmetic< T >, T >::type from_rdany(const RDAny &arg)
Definition RDAny.h:189
RDKit::RDAny
Definition RDAny.h:70
RDKit::RDAny::m_value
RDValue m_value
Definition RDAny.h:71
RDKit::RDAny::operator=
RDAny & operator=(const RDAny &rhs)
Definition RDAny.h:92
RDKit::RDAny::operator=
RDAny & operator=(const std::vector< std::string > &d)
Definition RDAny.h:151
RDKit::RDAny::operator=
RDAny & operator=(const std::string &d)
Definition RDAny.h:121
RDKit::RDAny::RDAny
RDAny(const T &d)
Definition RDAny.h:75
RDKit::RDAny::operator=
RDAny & operator=(const std::vector< double > &d)
Definition RDAny.h:127
RDKit::RDAny::~RDAny
~RDAny()
Definition RDAny.h:85
RDKit::RDAny::RDAny
RDAny(const RDAny &rhs)
Definition RDAny.h:83
RDKit::RDAny::operator=
RDAny & operator=(const std::vector< float > &d)
Definition RDAny.h:133
RDKit::RDAny::operator=
RDAny & operator=(const std::any &d)
Definition RDAny.h:157
RDKit::RDAny::operator=
RDAny & operator=(int d)
Definition RDAny.h:103
RDKit::RDAny::operator=
RDAny & operator=(const std::vector< unsigned int > &d)
Definition RDAny.h:145
RDKit::RDAny::RDAny
RDAny()
Definition RDAny.h:73
RDKit::RDAny::operator=
RDAny & operator=(const T &d)
Definition RDAny.h:164
RDKit::RDAny::operator=
RDAny & operator=(float d)
Definition RDAny.h:97
RDKit::RDAny::operator=
RDAny & operator=(unsigned int d)
Definition RDAny.h:109
RDKit::RDAny::operator=
RDAny & operator=(const std::vector< int > &d)
Definition RDAny.h:139
RDKit::RDAny::operator=
RDAny & operator=(bool d)
Definition RDAny.h:115
RDKit::RDValue
Definition RDValue-doublemagic.h:166
RDKit::RDValue::getTag
boost::uint64_t getTag() const
Definition RDValue-doublemagic.h:282
RDKit::RDValue::cleanup_rdvalue
static void cleanup_rdvalue(RDValue v)
Definition RDValue-doublemagic.h:331