Accessible.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013-2015, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_FRAMEWORK_ACCESSIBLE_H
#define SURGSIM_FRAMEWORK_ACCESSIBLE_H

#include <boost/any.hpp>
#include <boost/preprocessor.hpp>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <yaml-cpp/yaml.h>

#include "SurgSim/Math/Matrix.h"

namespace SurgSim
{
namespace Framework
{

class Accessible
{
public:

    Accessible();

    ~Accessible();

    typedef std::function<boost::any(void)> GetterType;
    typedef std::function<void (boost::any)> SetterType;

    typedef std::function<YAML::Node(void)> EncoderType;
    typedef std::function<void(const YAML::Node*)> DecoderType;

    template <class T>
    T getValue(const std::string& name) const;

    boost::any getValue(const std::string& name) const;

    template <class T>
    bool getValue(const std::string& name, T* value) const;

    void setValue(const std::string& name, const boost::any& value);

    bool isReadable(const std::string& name) const;

    bool isWriteable(const std::string& name) const;

    void setGetter(const std::string& name, GetterType func);

    void setSetter(const std::string& name, SetterType func);

    void setAccessors(const std::string& name, GetterType getter, SetterType setter);

    void removeAccessors(const std::string& name);

    void forwardProperty(const std::string& name, const Accessible& target, const std::string& targetProperty);

    void setSerializable(const std::string& name, EncoderType encoder, DecoderType decoder);

    void setDecoder(const std::string& name, DecoderType decoder);


    YAML::Node encode() const;

    void decode(const YAML::Node& node, const std::vector<std::string>& ignoredProperties = std::vector<std::string>());

    std::vector<std::string> getProperties();
private:

    Accessible(const Accessible& other) /*= delete*/;
    Accessible& operator=(const Accessible& other) /*= delete*/;

    struct Functors
    {
        Functors() : getter(nullptr), setter(nullptr), encoder(nullptr), decoder(nullptr) {}
        GetterType getter;
        SetterType setter;
        EncoderType encoder;
        DecoderType decoder;
    };

    std::unordered_map<std::string, Functors> m_functors;

};

struct Property
{
    std::weak_ptr<Accessible> accessible;
    std::string name;
};

template <>
boost::any Accessible::getValue(const std::string& name) const;


template <class T>
T convert(boost::any val);

template <>
SurgSim::Math::Matrix44f convert(boost::any val);

template <>
std::string convert(boost::any val);

#define SURGSIM_ADD_RW_PROPERTY(class, type, property, getter, setter) \
    setAccessors(#property, \
                std::bind(&class::getter, this),\
                std::bind(&class::setter, this, std::bind(SurgSim::Framework::convert<type>,std::placeholders::_1)))

#define SURGSIM_ADD_RO_PROPERTY(class, type, property, getter) \
    setGetter(#property, \
    std::bind(&class::getter, this))

#define SURGSIM_ADD_SERIALIZABLE_PROPERTY(class, type, property, getter, setter) \
    setAccessors(#property, \
                std::bind(&class::getter, this),\
                std::bind(&class::setter, this, std::bind(SurgSim::Framework::convert<type>,std::placeholders::_1)));\
    setSerializable(#property,\
                std::bind(&YAML::convert<type>::encode, std::bind(&class::getter, this)),\
                std::bind(&class::setter, this, std::bind(&YAML::Node::as<type>,std::placeholders::_1)))

#define SURGSIM_ADD_SETTER(class, type, property, setter) \
    {\
        setDecoder(#property, std::bind((void(class::*)(const type&))&class::setter, this,\
                    std::bind(&YAML::Node::as<type>,std::placeholders::_1))); \
        setSetter(#property, std::bind((void(class::*)(const type&))&class::setter, this,\
                    std::bind(SurgSim::Framework::convert<type>,std::placeholders::_1)));\
    }


}; // Framework
}; // SurgSim

#define SURGSIM_ENUM_TOSTRING(r, data, elem)    \
    case data::elem: \
        result = BOOST_PP_STRINGIZE(elem); \
        break;

#define SURGSIM_ENUM_FROMSTRING(r, data, elem)    \
    if (value == BOOST_PP_STRINGIZE(elem)) \
    { \
        rhs = data::elem; \
        return true; \
    }

#define SURGSIM_ENUM_TYPE int8_t

#define SURGSIM_SERIALIZABLE_ENUM(name, enumerators) \
    enum name : SURGSIM_ENUM_TYPE\
    { \
        BOOST_PP_SEQ_ENUM(enumerators) \
    }; \
    namespace YAML \
    { \
    template <> \
    struct convert<name> \
    { \
        static Node encode(const name& rhs) \
        { \
            Node result; \
            switch (rhs) \
            { \
                BOOST_PP_SEQ_FOR_EACH(SURGSIM_ENUM_TOSTRING, name, enumerators) \
                default: \
                    SURGSIM_FAILURE() << "Can not find enum value in " << #name  << ": " << rhs; \
            } \
            return result; \
        } \
        static bool decode(const Node& node, name& rhs) \
        { \
            std::string value = node.as<std::string>(); \
            std::transform(value.begin(), value.end(), value.begin(), ::toupper); \
            BOOST_PP_SEQ_FOR_EACH(SURGSIM_ENUM_FROMSTRING, name, enumerators) \
            SURGSIM_FAILURE() << "Unknown " <<  #name << ": " << value; \
            return false; \
        } \
    }; \
    }

#include "SurgSim/Framework/Accessible-inl.h"

#endif