lsattribute.h

#pragma once
 
#include <core_api/lsglobaldefinitions.h>
#include <core_api/iso_iec_988_1999.h>
#include <core_api/lsinterface.h>
#include <core_api/lsstring.h>
#include <core_api/lspod.h>
 
#include <Eigen/Core>
 
#include <vector>
#include <set>
#include <map>
 
namespace SCENE_API {
 
// Forward declarations
class LSAttribute_Implementation;
 
class LSAttribute : public LSInterface
{
public:
 
    CORE_API_EXPORT LSAttribute();
 
    CORE_API_EXPORT virtual ~LSAttribute();
 
    CORE_API_EXPORT LSAttribute(const LSAttribute& attribute);
 
    template<class T>
    LSAttribute(const T& value);
 
    CORE_API_EXPORT bool isValid() const;
 
    template<class T>
    T getValue() const;
 
    template<class T>
    void setValue(const T& value);
 
    CORE_API_EXPORT LSString toString() const;
 
    CORE_API_EXPORT bool fromString(LSString value);
 
    CORE_API_EXPORT LSString getType() const;
 
    CORE_API_EXPORT bool hasType(LSString type) const;
 
    template<class T>
    bool hasType() const;
 
    CORE_API_EXPORT LSAttribute& operator=(const LSAttribute& from);
 
    CORE_API_EXPORT void* operator new(size_t tSize);
 
    CORE_API_EXPORT void  operator delete(void* p);
 
protected:
    template<class T> void createFrom(const T& value);
 
protected:
    LS_INTERFACE(LSAttribute, LSInterface)
};
 
//-----------------------------------------------------------------------------
#define DECLARE_LSATTRIBUTE_TYPE(T) \
    template<> CORE_API_EXPORT LSAttribute::LSAttribute(const T& value); \
    template<> CORE_API_EXPORT T LSAttribute::getValue<T>() const; \
    template<> CORE_API_EXPORT void LSAttribute::setValue<T>(const T& value); \
    template<> CORE_API_EXPORT bool LSAttribute::hasType<T>() const;
 
//-----------------------------------------------------------------------------
#define DECLARE_LSATTRIBUTE_POD_TYPE(T) \
    DECLARE_LSATTRIBUTE_TYPE(LSPod<T>) \
    template<> CORE_API_EXPORT void LSAttribute::createFrom<LSPod<T> >(const LSPod<T>& value); \
    template<> inline LSAttribute::LSAttribute(const T& value) : LSInterface(0) \
    { createFrom(LSPod<T>(value)); } \
    template<> inline T LSAttribute::getValue<T>() const \
    { return LSAttribute::getValue<LSPod<T> >().get(); } \
    template<> inline void LSAttribute::setValue<T>(const T& value) \
    { LSAttribute::setValue<LSPod<T> >(value); } \
    template<> inline bool LSAttribute::hasType<T>() const \
    { return LSAttribute::hasType<LSPod<T> >(); }   
 
// Valid attribute types
typedef std::map<const LSString, LSString> StringMap;
 
DECLARE_LSATTRIBUTE_TYPE(int8_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<int8_t>)
DECLARE_LSATTRIBUTE_TYPE(uint8_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<uint8_t>)
DECLARE_LSATTRIBUTE_TYPE(int16_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<int16_t>)
DECLARE_LSATTRIBUTE_TYPE(uint16_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<uint16_t>)
DECLARE_LSATTRIBUTE_TYPE(int32_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<int32_t>)
DECLARE_LSATTRIBUTE_TYPE(uint32_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<uint32_t>)
DECLARE_LSATTRIBUTE_TYPE(int64_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<int64_t>)
DECLARE_LSATTRIBUTE_TYPE(uint64_t)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<uint64_t>)
DECLARE_LSATTRIBUTE_TYPE(double)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<double>)
DECLARE_LSATTRIBUTE_TYPE(bool)
DECLARE_LSATTRIBUTE_TYPE(LSString)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<LSString>)
DECLARE_LSATTRIBUTE_POD_TYPE(std::set<LSString>)
DECLARE_LSATTRIBUTE_POD_TYPE(StringMap)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector2d)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector2d>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector2f)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector2f>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector2i)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector2i>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector2ui)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector2us>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector3d)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector3d>)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<std::vector<Eigen::Vector3d> >)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector3f)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector3f>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector3us)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector3ui>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector4d)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Vector4d>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Vector4f)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Matrix4d)
DECLARE_LSATTRIBUTE_POD_TYPE(std::vector<Eigen::Matrix4d>)
DECLARE_LSATTRIBUTE_TYPE(Eigen::Matrix4f)
 
}