ServiceDefinition.h

Go to the documentation of this file.

 
#pragma once
 
#include "RobotRaconteur/Message.h"
#include "RobotRaconteur/DataTypes.h"
#include "RobotRaconteur/Error.h"
#include "RobotRaconteur/RobotRaconteurConstants.h"
 
#include <boost/tuple/tuple.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
 
namespace RobotRaconteur
{
class ROBOTRACONTEUR_CORE_API ServiceEntryDefinition;
class ROBOTRACONTEUR_CORE_API MemberDefinition;
class ROBOTRACONTEUR_CORE_API FunctionDefinition;
class ROBOTRACONTEUR_CORE_API PropertyDefinition;
class ROBOTRACONTEUR_CORE_API EventDefinition;
class ROBOTRACONTEUR_CORE_API ObjRefDefinition;
class ROBOTRACONTEUR_CORE_API PipeDefinition;
class ROBOTRACONTEUR_CORE_API CallbackDefinition;
class ROBOTRACONTEUR_CORE_API WireDefinition;
class ROBOTRACONTEUR_CORE_API MemoryDefinition;
class ROBOTRACONTEUR_CORE_API TypeDefinition;
class ROBOTRACONTEUR_CORE_API ExceptionDefinition;
class ROBOTRACONTEUR_CORE_API UsingDefinition;
class ROBOTRACONTEUR_CORE_API ConstantDefinition;
class ROBOTRACONTEUR_CORE_API EnumDefinition;
class ROBOTRACONTEUR_CORE_API EnumDefinitionValue;
 
class ROBOTRACONTEUR_CORE_API ServiceDefinitionParseException;
class ROBOTRACONTEUR_CORE_API ServiceDefinitionVerifyException;

struct ROBOTRACONTEUR_CORE_API ServiceDefinitionParseInfo
{
    std::string ServiceName;
    std::string RobDefFilePath;
    std::string Line;
    int32_t LineNumber;

    ServiceDefinitionParseInfo();
    void Reset();
};

class ROBOTRACONTEUR_CORE_API RobotRaconteurVersion
{
  public:
    RobotRaconteurVersion();

    RobotRaconteurVersion(uint32_t major, uint32_t minor, uint32_t patch = 0, uint32_t tweak = 0);

    RobotRaconteurVersion(boost::string_ref v);

    std::string ToString() const;

    void FromString(boost::string_ref v, const ServiceDefinitionParseInfo* parse_info = NULL);

    ROBOTRACONTEUR_CORE_API friend bool operator==(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);
    ROBOTRACONTEUR_CORE_API friend bool operator!=(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);
    ROBOTRACONTEUR_CORE_API friend bool operator>(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);
    ROBOTRACONTEUR_CORE_API friend bool operator>=(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);
    ROBOTRACONTEUR_CORE_API friend bool operator<(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);
    ROBOTRACONTEUR_CORE_API friend bool operator<=(const RobotRaconteurVersion& v1, const RobotRaconteurVersion& v2);

    operator bool() const;

    uint32_t major;
    uint32_t minor;
    uint32_t patch;
    uint32_t tweak;

    ServiceDefinitionParseInfo ParseInfo;
};

class ROBOTRACONTEUR_CORE_API ServiceDefinitionParseException : public ServiceDefinitionException
{
 
  public:
    ServiceDefinitionParseInfo ParseInfo;

    std::string ShortMessage;

    ServiceDefinitionParseException(const std::string& e);

    ServiceDefinitionParseException(const std::string& e, const ServiceDefinitionParseInfo& info);

    virtual std::string ToString() const;
 
    RR_OVIRTUAL const char* what() const throw() RR_OVERRIDE;
 
    RR_OVIRTUAL ~ServiceDefinitionParseException() throw() RR_OVERRIDE {}
 
  private:
    std::string what_store;
};

class ROBOTRACONTEUR_CORE_API ServiceDefinitionVerifyException : public ServiceDefinitionException
{
 
  public:
    ServiceDefinitionParseInfo ParseInfo;

    std::string ShortMessage;

    ServiceDefinitionVerifyException(const std::string& e);

    ServiceDefinitionVerifyException(const std::string& e, const ServiceDefinitionParseInfo& info);

    virtual std::string ToString() const;
 
    RR_OVIRTUAL const char* what() const throw() RR_OVERRIDE;
 
    RR_OVIRTUAL ~ServiceDefinitionVerifyException() throw() RR_OVERRIDE {}
 
  private:
    std::string what_store;
};

class ROBOTRACONTEUR_CORE_API ServiceDefinition : public RR_ENABLE_SHARED_FROM_THIS<ServiceDefinition>
{
  public:
    std::string Name;

    std::vector<RR_SHARED_PTR<ServiceEntryDefinition> > Structures;
    std::vector<RR_SHARED_PTR<ServiceEntryDefinition> > Pods;
    std::vector<RR_SHARED_PTR<ServiceEntryDefinition> > NamedArrays;
    std::vector<RR_SHARED_PTR<ServiceEntryDefinition> > Objects;

    std::vector<std::string> Options;

    std::vector<std::string> Imports;

    std::vector<RR_SHARED_PTR<UsingDefinition> > Using;

    std::vector<RR_SHARED_PTR<ExceptionDefinition> > Exceptions;

    std::vector<RR_SHARED_PTR<ConstantDefinition> > Constants;

    std::vector<RR_SHARED_PTR<EnumDefinition> > Enums;

    RobotRaconteurVersion StdVer;

    ServiceDefinitionParseInfo ParseInfo;

    std::string DocString;
 
    virtual ~ServiceDefinition() {}

    virtual std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    void FromString(boost::string_ref s, std::vector<ServiceDefinitionParseException>& warnings,
                    const ServiceDefinitionParseInfo* parse_info = NULL);

    virtual void ToStream(std::ostream& os) const;

    void FromStream(std::istream& is, const ServiceDefinitionParseInfo* parse_info = NULL);

    void FromStream(std::istream& is, std::vector<ServiceDefinitionParseException>& warnings,
                    const ServiceDefinitionParseInfo* parse_info = NULL);

    void CheckVersion(const RobotRaconteurVersion& ver = RobotRaconteurVersion(0, 0)) const;

    ServiceDefinition();

    void Reset();
};

class ROBOTRACONTEUR_CORE_API NamedTypeDefinition
{
  public:
    std::string Name;
    virtual DataTypes RRDataType() const = 0;
    virtual std::string ResolveQualifiedName() = 0;
    virtual ~NamedTypeDefinition() {}
};

class ROBOTRACONTEUR_CORE_API ServiceEntryDefinition : public RR_ENABLE_SHARED_FROM_THIS<ServiceEntryDefinition>,
                                                       public NamedTypeDefinition
{
  public:
    std::vector<RR_SHARED_PTR<MemberDefinition> > Members;

    DataTypes EntryType;

    std::vector<std::string> Implements;

    std::vector<std::string> Options;

    std::vector<RR_SHARED_PTR<ConstantDefinition> > Constants;

    ServiceDefinitionParseInfo ParseInfo;

    std::string DocString;

    ServiceEntryDefinition(const RR_SHARED_PTR<ServiceDefinition>& def);
 
    RR_OVIRTUAL ~ServiceEntryDefinition() RR_OVERRIDE {}

    virtual std::string ToString();

    virtual void ToStream(std::ostream& os) const;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    void FromString(boost::string_ref s, std::vector<ServiceDefinitionParseException>& warnings,
                    const ServiceDefinitionParseInfo* parse_info = NULL);

    void FromStream(std::istream& is, const ServiceDefinitionParseInfo* parse_info = NULL);

    void FromStream(std::istream& is, std::vector<ServiceDefinitionParseException>& warnings,
                    const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_WEAK_PTR<ServiceDefinition> ServiceDefinition_;

    void Reset();
 
    RR_OVIRTUAL DataTypes RRDataType() const RR_OVERRIDE;
    RR_OVIRTUAL std::string ResolveQualifiedName() RR_OVERRIDE;
};

class ROBOTRACONTEUR_CORE_API MemberDefinition : public RR_ENABLE_SHARED_FROM_THIS<MemberDefinition>
{
  public:
    std::string Name;
    RR_WEAK_PTR<ServiceEntryDefinition> ServiceEntry;

    std::vector<std::string> Modifiers;

    ServiceDefinitionParseInfo ParseInfo;

    std::string DocString;
 
    MemberDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);

    virtual MemberDefinition_NoLock NoLock() const;
 
    virtual ~MemberDefinition() {}

    virtual std::string ToString() { return ""; }

    virtual void Reset();
};

class ROBOTRACONTEUR_CORE_API PropertyDefinition : public MemberDefinition
{
  public:
    RR_SHARED_PTR<TypeDefinition> Type;

    PropertyDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL ~PropertyDefinition() RR_OVERRIDE {}

    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    std::string ToString(bool isstruct) const;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;

    MemberDefinition_Direction Direction();
};

class ROBOTRACONTEUR_CORE_API FunctionDefinition : public MemberDefinition
{
  public:
    RR_SHARED_PTR<TypeDefinition> ReturnType;
    std::vector<RR_SHARED_PTR<TypeDefinition> > Parameters;

    FunctionDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;

    bool IsGenerator();
};

class ROBOTRACONTEUR_CORE_API EventDefinition : public MemberDefinition
{
  public:
    std::vector<RR_SHARED_PTR<TypeDefinition> > Parameters;

    EventDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;
};

class ROBOTRACONTEUR_CORE_API ObjRefDefinition : public MemberDefinition
{
  public:
    std::string ObjectType;

    DataTypes_ArrayTypes ArrayType;

    DataTypes_ContainerTypes ContainerType;

    ObjRefDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;
};

class ROBOTRACONTEUR_CORE_API PipeDefinition : public MemberDefinition
{
  public:
    RR_SHARED_PTR<TypeDefinition> Type;

    PipeDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;

    MemberDefinition_Direction Direction() const;

    bool IsUnreliable() const;
};

class ROBOTRACONTEUR_CORE_API CallbackDefinition : public MemberDefinition
{
  public:
    RR_OVIRTUAL ~CallbackDefinition() RR_OVERRIDE {}

    RR_SHARED_PTR<TypeDefinition> ReturnType;
    std::vector<RR_SHARED_PTR<TypeDefinition> > Parameters;

    CallbackDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;
};

class ROBOTRACONTEUR_CORE_API WireDefinition : public MemberDefinition
{
  public:
    RR_SHARED_PTR<TypeDefinition> Type;

    WireDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;

    MemberDefinition_Direction Direction();
};

class ROBOTRACONTEUR_CORE_API MemoryDefinition : public MemberDefinition
{
  public:
    RR_SHARED_PTR<TypeDefinition> Type;

    MemoryDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& ServiceEntry);
 
    RR_OVIRTUAL std::string ToString() RR_OVERRIDE;

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    RR_OVIRTUAL void Reset() RR_OVERRIDE;

    MemberDefinition_Direction Direction();
};

class ROBOTRACONTEUR_CORE_API TypeDefinition
{
  public:
    virtual ~TypeDefinition() {}

    std::string Name;

    DataTypes Type;
    std::string TypeString;

    DataTypes_ArrayTypes ArrayType;
    bool ArrayVarLength;
    std::vector<int32_t> ArrayLength;

    DataTypes_ContainerTypes ContainerType;

    RR_WEAK_PTR<MemberDefinition> member;

    ServiceDefinitionParseInfo ParseInfo;

    TypeDefinition();

    TypeDefinition(const RR_SHARED_PTR<MemberDefinition>& member);

    virtual std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    static DataTypes DataTypeFromString(boost::string_ref d);

    static std::string StringFromDataType(DataTypes d);

    void Reset();

    void CopyTo(TypeDefinition& def) const;

    RR_SHARED_PTR<TypeDefinition> Clone() const;

    void Rename(boost::string_ref name);

    void RemoveContainers();

    void RemoveArray();

    void QualifyTypeStringWithUsing();

    void UnqualifyTypeStringWithUsing();

    RR_SHARED_PTR<NamedTypeDefinition> ResolveNamedType(
        const std::vector<RR_SHARED_PTR<ServiceDefinition> >& other_defs =
            std::vector<RR_SHARED_PTR<ServiceDefinition> >(),
        const RR_SHARED_PTR<RobotRaconteurNode>& node = RR_SHARED_PTR<RobotRaconteurNode>(),
        const RR_SHARED_PTR<RRObject>& client = RR_SHARED_PTR<RRObject>());
 
    // Don't modify directly, use ResolveNamedType. Left public for specalized use.
    RR_WEAK_PTR<NamedTypeDefinition> ResolveNamedType_cache;
};

class ROBOTRACONTEUR_CORE_API ExceptionDefinition
{
  public:
    virtual ~ExceptionDefinition();

    std::string Name;
    std::string DocString;

    RR_WEAK_PTR<ServiceDefinition> service;

    ServiceDefinitionParseInfo ParseInfo;

    ExceptionDefinition(const RR_SHARED_PTR<ServiceDefinition>& service);

    std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    void Reset();
};

class ROBOTRACONTEUR_CORE_API UsingDefinition
{
  public:
    virtual ~UsingDefinition();

    std::string QualifiedName;
    std::string UnqualifiedName;

    RR_WEAK_PTR<ServiceDefinition> service;

    ServiceDefinitionParseInfo ParseInfo;

    UsingDefinition(const RR_SHARED_PTR<ServiceDefinition>& service);

    std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);
};

struct ROBOTRACONTEUR_CORE_API ConstantDefinition_StructField
{
    std::string Name;
    std::string ConstantRefName;
};

class ROBOTRACONTEUR_CORE_API ConstantDefinition
{
  public:
    virtual ~ConstantDefinition();

    std::string Name;

    RR_SHARED_PTR<TypeDefinition> Type;

    std::string Value;

    std::string DocString;

    RR_WEAK_PTR<ServiceDefinition> service;
    RR_WEAK_PTR<ServiceEntryDefinition> service_entry;

    ServiceDefinitionParseInfo ParseInfo;

    ConstantDefinition(const RR_SHARED_PTR<ServiceDefinition>& service);

    ConstantDefinition(const RR_SHARED_PTR<ServiceEntryDefinition>& service_entry);

    std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    void Reset();

    static bool VerifyTypeAndValue(TypeDefinition& t, boost::string_ref value);

    bool VerifyValue() const;

    template <typename T>
    T ValueToScalar() const
    {
        T v;
        if (!detail::try_convert_string_to_number(boost::trim_copy(Value), v))
        {
            throw ServiceDefinitionParseException("Invalid constant", ParseInfo);
        }
        return v;
    }

    template <typename T>
    RR_INTRUSIVE_PTR<RRArray<T> > ValueToArray() const
    {
        boost::iterator_range<std::string::const_iterator> value1(Value);
        value1 = boost::trim_copy_if(value1, boost::is_any_of(" \t{}"));
        value1 = boost::trim_copy(value1);
        if (value1.empty())
            return AllocateRRArray<T>(0);
 
        size_t n = 0;
 
        // Count number of elements
        typedef boost::split_iterator<std::string::const_iterator> string_split_iterator;
        for (string_split_iterator e = boost::make_split_iterator(
                 value1, boost::token_finder(boost::is_any_of(","), boost::token_compress_on));
             e != string_split_iterator(); e++)
        {
            n++;
        }
 
        RR_INTRUSIVE_PTR<RRArray<T> > o = AllocateRRArray<T>(n);
 
        size_t i = 0;
 
        // Read elements
        typedef boost::split_iterator<std::string::const_iterator> string_split_iterator;
        for (string_split_iterator e = boost::make_split_iterator(
                 value1, boost::token_finder(boost::is_any_of(","), boost::token_compress_on));
             e != string_split_iterator(); e++)
        {
            if (!detail::try_convert_string_to_number(boost::trim_copy(*e), (*o)[i]))
            {
                throw ServiceDefinitionParseException("Invalid constant", ParseInfo);
            }
            i++;
        }
 
        if (i != n)
            throw InternalErrorException("Internal error");
        return o;
    }

    std::string ValueToString();

    std::vector<ConstantDefinition_StructField> ValueToStructFields() const;
 
    static std::string UnescapeString(boost::string_ref in);
    static std::string EscapeString(boost::string_ref in);
};

class ROBOTRACONTEUR_CORE_API EnumDefinition : public NamedTypeDefinition
{
  public:
    RR_OVIRTUAL ~EnumDefinition() RR_OVERRIDE;

    std::vector<EnumDefinitionValue> Values;

    RR_WEAK_PTR<ServiceDefinition> service;

    ServiceDefinitionParseInfo ParseInfo;

    std::string DocString;

    EnumDefinition(const RR_SHARED_PTR<ServiceDefinition>& service);

    std::string ToString();

    void FromString(boost::string_ref s, const ServiceDefinitionParseInfo* parse_info = NULL);

    bool VerifyValues() const;

    void Reset();
 
    RR_OVIRTUAL DataTypes RRDataType() const RR_OVERRIDE;
    RR_OVIRTUAL std::string ResolveQualifiedName() RR_OVERRIDE;
};

class ROBOTRACONTEUR_CORE_API EnumDefinitionValue
{
  public:
    EnumDefinitionValue();

    std::string Name;
    int32_t Value;
    bool ImplicitValue;
    bool HexValue;

    std::string DocString;
};

ROBOTRACONTEUR_CORE_API void VerifyServiceDefinitions(const std::vector<RR_SHARED_PTR<ServiceDefinition> >& def,
                                                      std::vector<ServiceDefinitionParseException>& warnings);

ROBOTRACONTEUR_CORE_API void VerifyServiceDefinitions(const std::vector<RR_SHARED_PTR<ServiceDefinition> >& def);

ROBOTRACONTEUR_CORE_API bool CompareServiceDefinitions(const RR_SHARED_PTR<ServiceDefinition>& def1,
                                                       const RR_SHARED_PTR<ServiceDefinition>& def2);

ROBOTRACONTEUR_CORE_API boost::tuple<boost::string_ref, boost::string_ref> SplitQualifiedName(boost::string_ref name);

template <typename T>
RR_SHARED_PTR<T> TryFindByName(const std::vector<RR_SHARED_PTR<T> >& v, boost::string_ref name)
{
    for (typename std::vector<RR_SHARED_PTR<T> >::const_iterator e = v.begin(); e != v.end(); ++e)
    {
        const RR_SHARED_PTR<T>& ee = *e;
        if (ee)
        {
            if (ee->Name == name)
            {
                return ee;
            }
        }
    }
 
    return RR_SHARED_PTR<T>();
}
 
ROBOTRACONTEUR_CORE_API size_t EstimatePodPackedElementSize(
    const RR_SHARED_PTR<ServiceEntryDefinition>& def,
    const std::vector<RR_SHARED_PTR<ServiceDefinition> >& other_defs = std::vector<RR_SHARED_PTR<ServiceDefinition> >(),
    const RR_SHARED_PTR<RobotRaconteurNode>& node = RR_SHARED_PTR<RobotRaconteurNode>(),
    const RR_SHARED_PTR<RRObject>& client = RR_SHARED_PTR<RRObject>());
 
ROBOTRACONTEUR_CORE_API boost::tuple<DataTypes, size_t> GetNamedArrayElementTypeAndCount(
    const RR_SHARED_PTR<ServiceEntryDefinition>& def,
    const std::vector<RR_SHARED_PTR<ServiceDefinition> >& other_defs = std::vector<RR_SHARED_PTR<ServiceDefinition> >(),
    const RR_SHARED_PTR<RobotRaconteurNode>& node = RR_SHARED_PTR<RobotRaconteurNode>(),
    const RR_SHARED_PTR<RRObject>& client = RR_SHARED_PTR<RRObject>());
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using ServiceDefinitionPtr = RR_SHARED_PTR<ServiceDefinition>;
using NamedTypeDefinitionPtr = RR_SHARED_PTR<NamedTypeDefinition>;
using ServiceEntryDefinitionPtr = RR_SHARED_PTR<ServiceEntryDefinition>;
using MemberDefinitionPtr = RR_SHARED_PTR<MemberDefinition>;
using FunctionDefinitionPtr = RR_SHARED_PTR<FunctionDefinition>;
using PropertyDefinitionPtr = RR_SHARED_PTR<PropertyDefinition>;
using EventDefinitionPtr = RR_SHARED_PTR<EventDefinition>;
using ObjRefDefinitionPtr = RR_SHARED_PTR<ObjRefDefinition>;
using PipeDefinitionPtr = RR_SHARED_PTR<PipeDefinition>;
using CallbackDefinitionPtr = RR_SHARED_PTR<CallbackDefinition>;
using WireDefinitionPtr = RR_SHARED_PTR<WireDefinition>;
using MemoryDefinitionPtr = RR_SHARED_PTR<MemoryDefinition>;
using TypeDefinitionPtr = RR_SHARED_PTR<TypeDefinition>;
using UsingDefinitionPtr = RR_SHARED_PTR<UsingDefinition>;
using EnumDefinitionPtr = RR_SHARED_PTR<EnumDefinition>;
using ConstantDefinitionPtr = RR_SHARED_PTR<ConstantDefinition>;
#endif
 
} // namespace RobotRaconteur