properties.h

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2017, Bielefeld University
 *  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 Bielefeld University 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.
 *********************************************************************/
 
/* Author: Robert Haschke
   Desc:   PropertyMap stores variables of stages
*/
 
#pragma once
 
#include <boost/any.hpp>
#include <typeindex>
#include <map>
#include <set>
#include <vector>
#include <functional>
#include <sstream>
#include <ros/serialization.h>
 
namespace moveit {
namespace task_constructor {
 
class Property;
class PropertyMap;
 
boost::any fromName(const PropertyMap& other, const std::string& other_name);
 
class Property
{
    friend class PropertyMap;
 
    Property(const boost::typeindex::type_info& type_info, const std::string& description,
             const boost::any& default_value);
 
public:
    using type_info = boost::typeindex::type_info;
 
    Property();
 
    class error;
    class undeclared;
    class undefined;
    class type_error;
 
    using SourceFlags = uint;
    using InitializerFunction = std::function<boost::any(const PropertyMap&)>;
 
    void setValue(const boost::any& value);
    void setCurrentValue(const boost::any& value);
    void setDefaultValue(const boost::any& value);
 
    void reset();
 
    inline bool defined() const { return !value_.empty(); }
 
    inline const boost::any& value() const { return value_.empty() ? default_ : value_; }
    inline boost::any& value() { return value_.empty() ? default_ : value_; }
    const boost::any& defaultValue() const { return default_; }
 
    static std::string serialize(const boost::any& value);
    static boost::any deserialize(const std::string& type_name, const std::string& wire);
    std::string serialize() const { return serialize(value()); }
 
    const std::string& description() const { return description_; }
    void setDescription(const std::string& desc) { description_ = desc; }
 
    static std::string typeName(const type_info& type_info);
    std::string typeName() const;
 
    bool initsFrom(SourceFlags source) const;
    Property& configureInitFrom(SourceFlags source, const InitializerFunction& f);
    Property& configureInitFrom(SourceFlags source, const std::string& name);
 
private:
    std::string description_;
    const type_info& type_info_;
    boost::any default_;
    boost::any value_;
 
    SourceFlags source_flags_ = 0;
    SourceFlags initialized_from_;
    InitializerFunction initializer_;
};
 
class Property::error : public std::runtime_error
{
protected:
    std::string property_name_;
    std::string msg_;
 
public:
    explicit error(const std::string& msg);
    const std::string& name() const { return property_name_; }
    void setName(const std::string& name);
    const char* what() const noexcept override { return msg_.c_str(); }
};
class Property::undeclared : public Property::error
{
public:
    explicit undeclared(const std::string& name, const std::string& msg = "undeclared");
};
class Property::undefined : public Property::error
{
public:
    explicit undefined(const std::string& name, const std::string& msg = "undefined");
};
class Property::type_error : public Property::error
{
public:
    explicit type_error(const std::string& current_type, const std::string& declared_type);
};
 
// hasSerialize<T>::value provides a true/false constexpr depending on whether operator<< is supported.
// This uses SFINAE, extracted from https://jguegant.github.io/blogs/tech/sfinae-introduction.html
template <typename T, typename = std::ostream&>
struct hasSerialize : std::false_type
{};
 
template <typename T>
struct hasSerialize<T, decltype(std::declval<std::ostream&>() << std::declval<T>())> : std::true_type
{};
 
template <typename T, typename = std::istream&>
struct hasDeserialize : std::false_type
{};
 
template <typename T>
struct hasDeserialize<T, decltype(std::declval<std::istream&>() >> std::declval<T&>())> : std::true_type
{};
 
class PropertySerializerBase
{
public:
    using SerializeFunction = std::string (*)(const boost::any&);
    using DeserializeFunction = boost::any (*)(const std::string&);
 
    static std::string dummySerialize(const boost::any& /*unused*/) { return ""; }
    static boost::any dummyDeserialize(const std::string& /*unused*/) { return boost::any(); }
 
protected:
    static bool insert(const std::type_index& type_index, const std::string& type_name, SerializeFunction serialize,
                       DeserializeFunction deserialize);
};
 
template <typename T>
class PropertySerializer : protected PropertySerializerBase
{
public:
    PropertySerializer() { insert(typeid(T), typeName<T>(), &serialize, &deserialize); }
 
    template <class Q = T>
    static typename std::enable_if<ros::message_traits::IsMessage<Q>::value, std::string>::type typeName() {
        return ros::message_traits::DataType<T>::value();
    }
 
    template <class Q = T>
    static typename std::enable_if<!ros::message_traits::IsMessage<Q>::value, std::string>::type typeName() {
        return typeid(T).name();
    }
 
private:
    template <class Q = T>
    static typename std::enable_if<hasSerialize<Q>::value, std::string>::type serialize(const boost::any& value) {
        std::ostringstream oss;
        oss << boost::any_cast<T>(value);
        return oss.str();
    }
    template <class Q = T>
    static typename std::enable_if<hasSerialize<Q>::value && hasDeserialize<Q>::value, boost::any>::type
    deserialize(const std::string& wired) {
        std::istringstream iss(wired);
        T value;
        iss >> value;
        return value;
    }
 
    template <class Q = T>
    static typename std::enable_if<!hasSerialize<Q>::value, std::string>::type serialize(const boost::any& value) {
        return dummySerialize(value);
    }
    template <class Q = T>
    static typename std::enable_if<!hasSerialize<Q>::value || !hasDeserialize<Q>::value, boost::any>::type
    deserialize(const std::string& wire) {
        return dummyDeserialize(wire);
    }
};
 
class PropertyMap
{
    std::map<std::string, Property> props_;
 
    Property& declare(const std::string& name, const Property::type_info& type_info, const std::string& description,
                      const boost::any& default_value);
 
public:
    template <typename T>
    Property& declare(const std::string& name, const std::string& description = "") {
        PropertySerializer<T>();  // register serializer/deserializer
        return declare(name, typeid(T), description, boost::any());
    }
    template <typename T>
    Property& declare(const std::string& name, const T& default_value, const std::string& description = "") {
        PropertySerializer<T>();  // register serializer/deserializer
        return declare(name, typeid(T), description, default_value);
    }
 
    void exposeTo(PropertyMap& other, const std::set<std::string>& properties) const;
 
    void exposeTo(PropertyMap& other, const std::string& name, const std::string& other_name) const;
 
    bool hasProperty(const std::string& name) const;
 
    Property& property(const std::string& name);
    const Property& property(const std::string& name) const { return const_cast<PropertyMap*>(this)->property(name); }
 
    using iterator = std::map<std::string, Property>::iterator;
    using const_iterator = std::map<std::string, Property>::const_iterator;
 
    iterator begin() { return props_.begin(); }
    iterator end() { return props_.end(); }
    const_iterator begin() const { return props_.begin(); }
    const_iterator end() const { return props_.end(); }
 
    void configureInitFrom(Property::SourceFlags source, const std::set<std::string>& properties = {});
 
    template <typename T>
    void set(const std::string& name, const T& value) {
        auto it = props_.find(name);
        if (it == props_.end())  // name is not yet declared
            declare<T>(name, value, "");
        else
            it->second.setValue(value);
    }
 
    inline void set(const std::string& name, const char* value) { set<std::string>(name, value); }
 
    void setCurrent(const std::string& name, const boost::any& value);
 
    const boost::any& get(const std::string& name) const;
 
    template <typename T>
    const T& get(const std::string& name) const {
        const boost::any& value = get(name);
        if (value.empty())
            throw Property::undefined(name);
        return boost::any_cast<const T&>(value);
    }
    template <typename T>
    const T& get(const std::string& name, const T& fallback) const {
        const boost::any& value = get(name);
        return (value.empty()) ? fallback : boost::any_cast<const T&>(value);
    }
 
    size_t countDefined(const std::vector<std::string>& list) const;
 
    void reset();
 
    void performInitFrom(Property::SourceFlags source, const PropertyMap& other);
};
 
// boost::any needs a specialization to avoid infinite recursion
template <>
void PropertyMap::set<boost::any>(const std::string& name, const boost::any& value);
 
}  // namespace task_constructor
}  // namespace moveit