diff options
Diffstat (limited to 'src/dm/systems/Qt3DSDMDataTypes.h')
| -rw-r--r-- | src/dm/systems/Qt3DSDMDataTypes.h | 891 |
1 files changed, 891 insertions, 0 deletions
diff --git a/src/dm/systems/Qt3DSDMDataTypes.h b/src/dm/systems/Qt3DSDMDataTypes.h new file mode 100644 index 0000000..7a7157f --- /dev/null +++ b/src/dm/systems/Qt3DSDMDataTypes.h @@ -0,0 +1,891 @@ +/**************************************************************************** +** +** Copyright (C) 1993-2009 NVIDIA Corporation. +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt 3D Studio. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#pragma once +#ifndef QT3DSDM_DATA_H +#define QT3DSDM_DATA_H + +#include <memory> +#include <functional> + +#include "Qt3DSDMErrors.h" +#include "Qt3DSDMStringTable.h" +#include "Qt3DSDMWindowsCompatibility.h" +#include <stdexcept> +#include <vector> +#include <map> +#include <set> +#include <EABase/eabase.h> //char8_t, etc. +#include <EASTL/string.h> +#include <EASTL/vector.h> +#include "foundation/StrConvertUTF.h" +#include "foundation/Qt3DSDiscriminatedUnion.h" + +#include <QObject> + +namespace qt3dsdm { + +typedef const wchar_t *TCharPtr; +struct Qt3DSDMStr : public eastl::basic_string<qt3ds::foundation::TWCharEASTLConverter::TCharType> +{ + typedef qt3ds::foundation::TWCharEASTLConverter::TCharType TCharType; + typedef eastl::basic_string<qt3ds::foundation::TWCharEASTLConverter::TCharType> TStrType; + Qt3DSDMStr() {} + Qt3DSDMStr(const wchar_t *inStr) + : TStrType(qt3ds::NVUnionCast<const TCharType *>(inStr)) + { + } + Qt3DSDMStr(const TStrType &inOther) + : TStrType(inOther) + { + } + + const wchar_t *wide_str() const { return reinterpret_cast<const wchar_t *>(c_str()); } + bool operator==(const Qt3DSDMStr &inOther) const { return TStrType::compare(inOther) == 0; } + bool operator!=(const Qt3DSDMStr &inOther) const { return TStrType::compare(inOther) != 0; } + bool operator==(const wchar_t *inOther) const + { + return TStrType::compare(reinterpret_cast<const TCharType *>(inOther)) == 0; + } + bool operator!=(const wchar_t *inOther) const + { + return TStrType::compare(reinterpret_cast<const TCharType *>(inOther)) != 0; + } + + TStrType::size_type find_first_of(const wchar_t *p, size_type position = 0) const + { + return TStrType::find_first_of(reinterpret_cast<const TCharType *>(p), position); + } + TStrType::size_type find_first_not_of(const wchar_t *p, size_type position = 0) const + { + return TStrType::find_first_not_of(reinterpret_cast<const TCharType *>(p), position); + } + TStrType::size_type find_last_not_of(const wchar_t *p, + size_type position = TStrType::npos) const + { + return TStrType::find_last_not_of(reinterpret_cast<const TCharType *>(p), position); + } + TStrType::size_type find(const wchar_t *p, size_type position = 0) const + { + return TStrType::find(reinterpret_cast<const TCharType *>(p), position); + } + TStrType::size_type find(wchar_t p, size_type position = 0) const + { + return TStrType::find(static_cast<TCharType>(p), position); + } + TStrType::size_type rfind(const wchar_t *p, size_type position = TStrType::npos) const + { + return TStrType::rfind(reinterpret_cast<const TCharType *>(p), position); + } + TStrType::size_type rfind(wchar_t p, size_type position = TStrType::npos) const + { + return TStrType::rfind(p, position); + } + Qt3DSDMStr replace(size_type position, size_type length, const wchar_t *inNewStr) + { + return TStrType::replace(position, length, reinterpret_cast<const TCharType *>(inNewStr)); + } + + void append(const wchar_t *p) { TStrType::append(reinterpret_cast<const TCharType *>(p)); } + void append(const wchar_t *p, size_type position, size_type n) + { + TStrType::append(reinterpret_cast<const TCharType *>(p), position, n); + } + void append(const Qt3DSDMStr &p) { TStrType::append(p); } + void assign(const wchar_t *p) { TStrType::assign(reinterpret_cast<const TCharType *>(p)); } + void assign(const Qt3DSDMStr &p) { TStrType::assign(p); } +}; +typedef Qt3DSDMStr TCharStr; +typedef std::vector<wchar_t> TCharList; +typedef eastl::vector<TCharStr> TCharStrList; +typedef std::map<TCharStr, int> TCharStrIntMap; +typedef std::map<int, TCharStr> TIntTCharStrMap; +typedef std::vector<int> TIntList; +typedef std::set<int> TIntSet; +typedef eastl::vector<float> TFloatList; + +template <typename TDataType> +class CImmutableVector : private std::vector<TDataType> +{ +public: + typedef std::vector<TDataType> base; + + CImmutableVector(const std::vector<TDataType> &inSrc) + : base(inSrc) + { + } + CImmutableVector(const CImmutableVector &inSrc) + : base(inSrc) + { + } + + CImmutableVector &operator=(const CImmutableVector &inSrc) + { + base::operator=(inSrc); + return *this; + } + + typename std::vector<TDataType>::const_iterator begin() const { return base::begin(); } + typename std::vector<TDataType>::const_iterator end() const { return base::end(); } + + size_t size() const { return base::size(); } + + const TDataType &at(int inIndex) const { return base::at(inIndex); } + const TDataType &operator[](int inIndex) const { return base::at(inIndex); } +}; + +typedef CImmutableVector<TCharStr> TImmutableCharStrList; +typedef std::shared_ptr<TImmutableCharStrList> TImmutableCharStrListPtr; + +class CDataStr +{ + TCharList m_Data; + +public: + CDataStr() {} + CDataStr(TCharList &inData) { m_Data.swap(inData); } + CDataStr(const wchar_t *inData) + { + if (inData && *inData) + m_Data.insert(m_Data.begin(), inData, inData + wcslen(inData)); + m_Data.push_back(0); + } + CDataStr(const wchar_t *inData, size_t inLen) + { + if (inData && *inData) + m_Data.insert(m_Data.begin(), inData, inData + inLen); + if (m_Data.size() > 0 && m_Data.back() != 0) + m_Data.push_back(0); + } + CDataStr(const CDataStr &inOther) + : m_Data(inOther.m_Data) + { + } + virtual ~CDataStr() {} + + CDataStr &operator=(const CDataStr &inOther) + { + m_Data = inOther.m_Data; + return *this; + } + const wchar_t *GetData() const { return m_Data.size() <= 1 ? L"" : &(*m_Data.begin()); } + size_t GetLength() const { return m_Data.size() > 1 ? m_Data.size() - 1 : 0; } + bool operator==(const CDataStr &inOther) const { return m_Data == inOther.m_Data; } + QString toQString() const { return QString::fromWCharArray(GetData()); } +}; + +typedef std::shared_ptr<CDataStr> TDataStrPtr; + +struct SFloat2 +{ + float m_Floats[2]; + SFloat2(float f1 = 0, float f2 = 0) + { + m_Floats[0] = f1; + m_Floats[1] = f2; + } + SFloat2(const SFloat2 &inOther) { operator=(inOther); } + SFloat2 &operator=(const SFloat2 &inOther) + { + m_Floats[0] = inOther.m_Floats[0]; + m_Floats[1] = inOther.m_Floats[1]; + return *this; + } + bool operator==(const SFloat2 &other) const + { + return m_Floats[0] == other.m_Floats[0] && m_Floats[1] == other.m_Floats[1]; + } + float &operator[](size_t inIndex) + { + switch (inIndex) { + default: + throw std::out_of_range(""); + case 0: + case 1: + return m_Floats[inIndex]; + } + } + const float &operator[](size_t inIndex) const + { + switch (inIndex) { + default: + throw std::out_of_range(""); + case 0: + case 1: + return m_Floats[inIndex]; + } + } +}; + +struct SFloat3 +{ + float m_Floats[3]; + + SFloat3(float f1 = 0, float f2 = 0, float f3 = 0) + { + m_Floats[0] = f1; + m_Floats[1] = f2; + m_Floats[2] = f3; + } + SFloat3(const SFloat3 &inOther) { operator=(inOther); } + SFloat3 &operator=(const SFloat3 &inOther) + { + m_Floats[0] = inOther.m_Floats[0]; + m_Floats[1] = inOther.m_Floats[1]; + m_Floats[2] = inOther.m_Floats[2]; + return *this; + } + + bool operator==(const SFloat3 &other) const + { + return m_Floats[0] == other.m_Floats[0] && m_Floats[1] == other.m_Floats[1] + && m_Floats[2] == other.m_Floats[2]; + } + + float &operator[](size_t inIndex) + { + switch (inIndex) { + default: + throw std::out_of_range(""); + case 0: + case 1: + case 2: + return m_Floats[inIndex]; + } + } + const float &operator[](size_t inIndex) const + { + switch (inIndex) { + default: + throw std::out_of_range(""); + case 0: + case 1: + case 2: + return m_Floats[inIndex]; + } + } +}; + +struct SFloat4 +{ + float m_Floats[4]; + + SFloat4(float f1 = 0, float f2 = 0, float f3 = 0, float f4 = 1) + { + m_Floats[0] = f1; + m_Floats[1] = f2; + m_Floats[2] = f3; + m_Floats[3] = f4; + } + SFloat4(const SFloat4 &inOther) { operator=(inOther); } + SFloat4 &operator=(const SFloat4 &inOther) + { + m_Floats[0] = inOther.m_Floats[0]; + m_Floats[1] = inOther.m_Floats[1]; + m_Floats[2] = inOther.m_Floats[2]; + m_Floats[3] = inOther.m_Floats[3]; + return *this; + } + + bool operator==(const SFloat4 &other) const + { + return m_Floats[0] == other.m_Floats[0] && m_Floats[1] == other.m_Floats[1] + && m_Floats[2] == other.m_Floats[2] && m_Floats[3] == other.m_Floats[3]; + } + + float &operator[](size_t inIndex) + { + if (inIndex < 4) + return m_Floats[inIndex]; + + throw std::out_of_range(""); + } + const float &operator[](size_t inIndex) const + { + if (inIndex < 4) + return m_Floats[inIndex]; + + throw std::out_of_range(""); + } +}; + +struct SLong4 +{ + qt3ds::QT3DSU32 m_Longs[4]; + + SLong4(qt3ds::QT3DSU32 l1 = 0, + qt3ds::QT3DSU32 l2 = 0, + qt3ds::QT3DSU32 l3 = 0, + qt3ds::QT3DSU32 l4 = 0) + { + m_Longs[0] = l1; + m_Longs[1] = l2; + m_Longs[2] = l3; + m_Longs[3] = l4; + } + SLong4(const SLong4 &inOther) { operator=(inOther); } + SLong4 &operator=(const SLong4 &inOther) + { + m_Longs[0] = inOther.m_Longs[0]; + m_Longs[1] = inOther.m_Longs[1]; + m_Longs[2] = inOther.m_Longs[2]; + m_Longs[3] = inOther.m_Longs[3]; + return *this; + } + + bool operator==(const SLong4 &other) const + { + return m_Longs[0] == other.m_Longs[0] && m_Longs[1] == other.m_Longs[1] + && m_Longs[2] == other.m_Longs[2] && m_Longs[3] == other.m_Longs[3]; + } + + bool operator<(const SLong4 &other) const + { + if (m_Longs[0] < other.m_Longs[0]) + return true; + else if (m_Longs[0] == other.m_Longs[0]) { + if (m_Longs[1] < other.m_Longs[1]) + return true; + else if (m_Longs[1] == other.m_Longs[1]) { + if (m_Longs[2] < other.m_Longs[2]) + return true; + else if (m_Longs[3] < other.m_Longs[3]) + return true; + } + } + return false; + } + + bool Valid() const + { + bool retval = false; + for (int idx = 0; idx < 4; ++idx) + retval = retval || m_Longs[0] > 0; + return retval; + } +}; + +typedef std::vector<SLong4> TLong4Vec; + +struct SSizet4 +{ + size_t m_Longs[4]; + + SSizet4(size_t l1 = 0, size_t l2 = 0, size_t l3 = 0, size_t l4 = 0) + { + m_Longs[0] = l1; + m_Longs[1] = l2; + m_Longs[2] = l3; + m_Longs[3] = l4; + } + SSizet4(const SSizet4 &inOther) { operator=(inOther); } + SSizet4 &operator=(const SSizet4 &inOther) + { + m_Longs[0] = inOther.m_Longs[0]; + m_Longs[1] = inOther.m_Longs[1]; + m_Longs[2] = inOther.m_Longs[2]; + m_Longs[3] = inOther.m_Longs[3]; + return *this; + } + + bool operator==(const SSizet4 &other) const + { + return m_Longs[0] == other.m_Longs[0] && m_Longs[1] == other.m_Longs[1] + && m_Longs[2] == other.m_Longs[2] && m_Longs[3] == other.m_Longs[3]; + } + + bool operator<(const SSizet4 &other) const + { + if (m_Longs[0] < other.m_Longs[0]) + return true; + else if (m_Longs[0] == other.m_Longs[0]) { + if (m_Longs[1] < other.m_Longs[1]) + return true; + else if (m_Longs[1] == other.m_Longs[1]) { + if (m_Longs[2] < other.m_Longs[2]) + return true; + else if (m_Longs[3] < other.m_Longs[3]) + return true; + } + } + return false; + } + + bool Valid() const + { + bool retval = false; + for (int idx = 0; idx < 4; ++idx) + retval = retval || m_Longs[0] > 0; + return retval; + } +}; + +inline bool IsTrivial(const wchar_t *inStr) +{ + return inStr == NULL || *inStr == 0; +} +inline const wchar_t *NonNull(const wchar_t *inStr) +{ + return inStr ? inStr : L""; +} +inline bool AreEqual(const wchar_t *lhs, const wchar_t *rhs) +{ + return wcscmp(NonNull(lhs), NonNull(rhs)) == 0; +} + +inline bool IsTrivial(const char8_t *inStr) +{ + return inStr == NULL || *inStr == 0; +} +inline const char8_t *NonNull(const char8_t *inStr) +{ + return inStr ? inStr : ""; +} +inline bool AreEqual(const char8_t *lhs, const char8_t *rhs) +{ + return strcmp(NonNull(lhs), NonNull(rhs)) == 0; +} + +inline bool AreEqualCaseless(const char8_t *lhs, const char8_t *rhs) +{ + if (IsTrivial(lhs) && IsTrivial(rhs)) + return true; + if (IsTrivial(lhs) || IsTrivial(rhs)) + return false; + for (; *lhs && *rhs; ++lhs, ++rhs) + if (tolower(*lhs) != tolower(*rhs)) + return false; + if (*lhs || *rhs) + return false; + return true; +} + +struct SStringRef +{ + const wchar_t *m_Id; + + SStringRef(const wchar_t *id = L"") + : m_Id(NonNull(id)) + { + } + + operator const wchar_t *() const { return m_Id; } + bool operator==(const SStringRef &inOther) const { return AreEqual(m_Id, inOther.m_Id); } +}; +} + +// Traits specializations have to be in the same namespace as they were first declared. +namespace qt3ds { +namespace foundation { + + template <> + struct DestructTraits<qt3dsdm::SFloat2> + { + void destruct(qt3dsdm::SFloat2 &) {} + }; + template <> + struct DestructTraits<qt3dsdm::SFloat3> + { + void destruct(qt3dsdm::SFloat3 &) {} + }; + template <> + struct DestructTraits<qt3dsdm::SFloat4> + { + void destruct(qt3dsdm::SFloat4 &) {} + }; + template <> + struct DestructTraits<qt3dsdm::SLong4> + { + void destruct(qt3dsdm::SLong4 &) {} + }; + template <> + struct DestructTraits<qt3dsdm::SStringRef> + { + void destruct(qt3dsdm::SStringRef &) {} + }; + + template <> + struct EqualVisitorTraits<qt3dsdm::TDataStrPtr> + { + bool operator()(const qt3dsdm::TDataStrPtr &lhs, const qt3dsdm::TDataStrPtr &rhs) + { + if (lhs && rhs) + return *lhs == *rhs; + if (lhs || rhs) + return false; + return true; + } + }; +} +} + +namespace qt3dsdm { + +using qt3ds::NVUnionCast; + +struct ObjectReferenceType +{ + enum Enum { + Unknown = 0, + Absolute = 1, + Relative = 2, + }; +}; + +template <typename TDataType> +struct SObjectRefTypeTraits +{ +}; + +template <> +struct SObjectRefTypeTraits<SLong4> +{ + ObjectReferenceType::Enum getType() { return ObjectReferenceType::Absolute; } +}; +template <> +struct SObjectRefTypeTraits<TDataStrPtr> +{ + ObjectReferenceType::Enum getType() { return ObjectReferenceType::Relative; } +}; + +struct SObjectRefUnionTraits +{ + typedef ObjectReferenceType::Enum TIdType; + enum { + TBufferSize = sizeof(SSizet4), + }; + + static ObjectReferenceType::Enum getNoDataId() { return ObjectReferenceType::Unknown; } + + template <typename TDataType> + static TIdType getType() + { + return SObjectRefTypeTraits<TDataType>().getType(); + } + + template <typename TRetType, typename TVisitorType> + static TRetType visit(char *inData, TIdType inType, TVisitorType inVisitor) + { + switch (inType) { + case ObjectReferenceType::Absolute: + return inVisitor(*NVUnionCast<SLong4 *>(inData)); + case ObjectReferenceType::Relative: + return inVisitor(*NVUnionCast<TDataStrPtr *>(inData)); + default: + QT3DS_ASSERT(false); + case ObjectReferenceType::Unknown: + return inVisitor(); + } + } + + template <typename TRetType, typename TVisitorType> + static TRetType visit(const char *inData, TIdType inType, TVisitorType inVisitor) + { + switch (inType) { + case ObjectReferenceType::Absolute: + return inVisitor(*NVUnionCast<const SLong4 *>(inData)); + case ObjectReferenceType::Relative: + return inVisitor(*NVUnionCast<const TDataStrPtr *>(inData)); + default: + QT3DS_ASSERT(false); + case ObjectReferenceType::Unknown: + return inVisitor(); + } + } +}; + +typedef qt3ds::foundation:: + DiscriminatedUnion<qt3ds::foundation:: + DiscriminatedUnionGenericBase<SObjectRefUnionTraits, + SObjectRefUnionTraits::TBufferSize>, + SObjectRefUnionTraits::TBufferSize> + TObjRefUnionType; + +template <typename TDataType> +struct Qt3DSDMGetter +{ +}; + +template <typename TRetType, typename TDataType> +TRetType get(const TDataType &inType) +{ + return Qt3DSDMGetter<TDataType>().template doGet<TRetType>(inType); +} + +template <> +struct Qt3DSDMGetter<TObjRefUnionType> +{ + template <typename TRetType> + TRetType doGet(const TObjRefUnionType &inValue) + { + return inValue.getData<TRetType>(); + } +}; + +// Either an absolute reference (SLong4) or a relative reference (string) +struct SObjectRefType +{ + TObjRefUnionType m_Value; + + SObjectRefType(const TDataStrPtr &inValue) + : m_Value(inValue) + { + } + SObjectRefType(const SLong4 &inValue) + : m_Value(inValue) + { + } + SObjectRefType(const SObjectRefType &inOther) + : m_Value(inOther.m_Value) + { + } + SObjectRefType() {} + SObjectRefType &operator=(const SObjectRefType &inOther) + { + m_Value = inOther.m_Value; + return *this; + } + ObjectReferenceType::Enum GetReferenceType() const { return m_Value.getType(); } + bool operator==(const SObjectRefType &inOther) const { return m_Value == inOther.m_Value; } +}; + +inline bool Equals(const SObjectRefType &lhs, const SObjectRefType &rhs) +{ + return lhs == rhs; +} + +struct SStringOrIntTypes +{ + enum Enum { + Unknown = 0, + Int, + String, + }; +}; + +template <typename TDataType> +struct SStringOrIntTypeTraits +{ +}; + +template <> +struct SStringOrIntTypeTraits<long> +{ + SStringOrIntTypes::Enum getType() { return SStringOrIntTypes::Int; } +}; +template <> +struct SStringOrIntTypeTraits<int> +{ + SStringOrIntTypes::Enum getType() { return SStringOrIntTypes::Int; } +}; +template <> +struct SStringOrIntTypeTraits<TDataStrPtr> +{ + SStringOrIntTypes::Enum getType() { return SStringOrIntTypes::String; } +}; + +struct SStringOrIntUnionTraits +{ + typedef SStringOrIntTypes::Enum TIdType; + enum { + TBufferSize = sizeof(TDataStrPtr), + }; + + static SStringOrIntTypes::Enum getNoDataId() { return SStringOrIntTypes::Unknown; } + + template <typename TDataType> + static TIdType getType() + { + return SStringOrIntTypeTraits<TDataType>().getType(); + } + + template <typename TRetType, typename TVisitorType> + static TRetType visit(char *inData, TIdType inType, TVisitorType inVisitor) + { + switch (inType) { + case SStringOrIntTypes::Int: + return inVisitor(*NVUnionCast<long *>(inData)); + case SStringOrIntTypes::String: + return inVisitor(*NVUnionCast<TDataStrPtr *>(inData)); + default: + QT3DS_ASSERT(false); + case SStringOrIntTypes::Unknown: + return inVisitor(); + } + } + + template <typename TRetType, typename TVisitorType> + static TRetType visit(const char *inData, TIdType inType, TVisitorType inVisitor) + { + switch (inType) { + case SStringOrIntTypes::Int: + return inVisitor(*NVUnionCast<const qt3ds::QT3DSI32 *>(inData)); + case SStringOrIntTypes::String: + return inVisitor(*NVUnionCast<const TDataStrPtr *>(inData)); + default: + QT3DS_ASSERT(false); + case SStringOrIntTypes::Unknown: + return inVisitor(); + } + } +}; + +typedef qt3ds::foundation:: + DiscriminatedUnion<qt3ds::foundation:: + DiscriminatedUnionGenericBase<SStringOrIntUnionTraits, + SStringOrIntUnionTraits::TBufferSize>, + SStringOrIntUnionTraits::TBufferSize> + TStringOrIntUnionType; + +template <> +struct Qt3DSDMGetter<TStringOrIntUnionType> +{ + template <typename TRetType> + TRetType doGet(const TStringOrIntUnionType &inValue) + { + return inValue.getData<TRetType>(); + } +}; + +struct SStringOrInt +{ + TStringOrIntUnionType m_Value; + + SStringOrInt() {} + SStringOrInt(int inValue) + : m_Value(inValue) + { + } + SStringOrInt(TDataStrPtr inValue) + : m_Value(inValue) + { + } + SStringOrInt(const SStringOrInt &inOther) + : m_Value(inOther.m_Value) + { + } + + SStringOrInt &operator=(const SStringOrInt &inOther) + { + m_Value = inOther.m_Value; + return *this; + } + + SStringOrIntTypes::Enum GetType() const { return m_Value.getType(); } + + bool operator==(const SStringOrInt &inOther) const { return m_Value == inOther.m_Value; } +}; + +inline bool Equals(const SStringOrInt &lhs, const SStringOrInt &rhs) +{ + return lhs == rhs; +} + +//comes from broken X.h +#ifdef None +#undef None +#endif + +#ifdef Bool +#undef Bool +#endif + +struct DataModelDataType { + + enum Value { + None, + Float, + Float2, + Float3, + Float4, + Long, + String, + Bool, + Long4, + StringRef, + ObjectRef, + StringOrInt, + FloatList, + RangedNumber // datainput-specific type for editor only + }; + + + Q_ENUM(Value) + Q_GADGET +}; + + +class IStringTable; + +template <typename TDataType> +struct Qt3DSDMValueTyper +{ +}; + +template <typename TDataType> +inline DataModelDataType::Value GetValueType(const TDataType &inValue) +{ + return Qt3DSDMValueTyper<TDataType>().Get(inValue); +} + +template <typename TDataType> +struct SDefaulter +{ +}; + +template <typename TDataType> +inline bool SetDefault(DataModelDataType::Value inDataType, TDataType &outValue) +{ + return SDefaulter<TDataType>().SetDefault(inDataType, outValue); +} + +typedef void (*Qt3DSDMDebugLogFunction)(const char *message); +// UICDMSimpleDataCore.cpp +extern Qt3DSDMDebugLogFunction g_DataModelDebugLogger; + +#define QT3DSDM_DEBUG_LOG(msg) \ + { \ + if (g_DataModelDebugLogger) { \ + g_DataModelDebugLogger(msg); \ + } \ + } +struct Qt3DSDMLogScope +{ + const char *m_EndMessage; + Qt3DSDMLogScope(const char *inStartMessage, const char *inEndMessage) + : m_EndMessage(inEndMessage) + { + QT3DSDM_DEBUG_LOG(inStartMessage); + } + ~Qt3DSDMLogScope() { QT3DSDM_DEBUG_LOG(m_EndMessage); } +}; + +#define QT3DSDM_LOG_FUNCTION(fnname) Qt3DSDMLogScope __fn_scope(fnname " Enter", fnname " Leave"); +} + +#endif |