diff options
author | sanine <sanine.not@pm.me> | 2022-03-04 10:47:15 -0600 |
---|---|---|
committer | sanine <sanine.not@pm.me> | 2022-03-04 10:47:15 -0600 |
commit | 058f98a63658dc1a2579826ba167fd61bed1e21f (patch) | |
tree | bcba07a1615a14d943f3af3f815a42f3be86b2f3 /src/mesh/assimp-master/contrib/openddlparser/include | |
parent | 2f8028ac9e0812cb6f3cbb08f0f419e4e717bd22 (diff) |
add assimp submodule
Diffstat (limited to 'src/mesh/assimp-master/contrib/openddlparser/include')
8 files changed, 1795 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/DDLNode.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/DDLNode.h new file mode 100644 index 0000000..593a5f1 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/DDLNode.h @@ -0,0 +1,173 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> + +#include <string> +#include <vector> + +BEGIN_ODDLPARSER_NS + +// Forward declarations +class IOStreamBase; +class Value; +class OpenDDLParser; + +struct Identifier; +struct Reference; +struct Property; +struct DataArrayList; + +/// +/// @ingroup OpenDDLParser +/// @brief This class represents one single instance in the object tree of the parsed OpenDDL-file. +/// +/// A DDLNode represents one leaf in the OpenDDL-node tree. It can have one parent node and multiple children. +/// You can assign special properties to a single DDLNode instance. +/// A node instance can store values via a linked list. You can get the first value from the DDLNode. +/// A node can store data-array-lists and references as well. +/// +class DLL_ODDLPARSER_EXPORT DDLNode { +public: + friend class OpenDDLParser; + + /// @brief The child-node-list type. + typedef std::vector<DDLNode *> DllNodeList; + + /// @brief The child-node-list iterator. + typedef std::vector<DDLNode *>::iterator DDLNodeIt; + +public: + /// @brief The class destructor. + ~DDLNode(); + + /// @brief Will attach a parent node instance, an older one will be released. + /// @param parent [in] The parent node instance. + void attachParent(DDLNode *parent); + + /// @brief Will try to detach a parent node instance, if there is any. + void detachParent(); + + /// @brief Returns the assigned parent node instance, will return ddl_nullptr id no parent is assigned. + /// @return The parent node instance. + DDLNode *getParent() const; + + /// @brief Returns the child node list. + /// @return The list of child nodes. + const DllNodeList &getChildNodeList() const; + + /// Set the type of the DDLNode instance. + /// @param type [in] The type. + void setType(const std::string &type); + + /// @brief Returns the type of the DDLNode instance. + /// @return The type of the DDLNode instance. + const std::string &getType() const; + + /// Set the name of the DDLNode instance. + /// @param name [in] The name. + void setName(const std::string &name); + + /// @brief Returns the name of the DDLNode instance. + /// @return The name of the DDLNode instance. + const std::string &getName() const; + + /// @brief Set a new property set. + /// @param prop [in] The first element of the property set. + void setProperties(Property *prop); + + /// @brief Returns the first element of the assigned property set. + /// @return The first property of the assigned property set. + Property *getProperties() const; + + /// @brief Looks for a given property. + /// @param name [in] The name for the property to look for. + /// @return true, if a corresponding property is assigned to the node, false if not. + bool hasProperty(const std::string &name); + + /// @brief Will return true, if any properties are assigned to the node instance. + /// @return True, if properties are assigned. + bool hasProperties() const; + + /// @brief Search for a given property and returns it. Will return ddl_nullptr if no property was found. + /// @param name [in] The name for the property to look for. + /// @return The property or ddl_nullptr if no property was found. + Property *findPropertyByName(const std::string &name); + + /// @brief Set a new value set. + /// @param val [in] The first value instance of the value set. + void setValue(Value *val); + + /// @brief Returns the first element of the assigned value set. + /// @return The first property of the assigned value set. + Value *getValue() const; + + /// @brief Set a new DataArrayList. + /// @param dtArrayList [in] The DataArrayList instance. + void setDataArrayList(DataArrayList *dtArrayList); + + /// @brief Returns the DataArrayList. + /// @return The DataArrayList. + DataArrayList *getDataArrayList() const; + + /// @brief Set a new Reference set. + /// @param refs [in] The first value instance of the Reference set. + void setReferences(Reference *refs); + + /// @brief Returns the first element of the assigned Reference set. + /// @return The first property of the assigned Reference set. + Reference *getReferences() const; + + /// @brief Will dump the node into the stream. + /// @param stream [in] The stream to write to. + void dump(IOStreamBase &stream); + + /// @brief The creation method. + /// @param type [in] The DDLNode type. + /// @param name [in] The name for the new DDLNode instance. + /// @param parent [in] The parent node instance or ddl_nullptr if no parent node is there. + /// @return The new created node instance. + static DDLNode *create(const std::string &type, const std::string &name, DDLNode *parent = nullptr); + +private: + DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent = nullptr); + DDLNode(); + DDLNode(const DDLNode &) ddl_no_copy; + DDLNode &operator=(const DDLNode &) ddl_no_copy; + static void releaseNodes(); + +private: + std::string m_type; + std::string m_name; + DDLNode *m_parent; + std::vector<DDLNode *> m_children; + Property *m_properties; + Value *m_value; + DataArrayList *m_dtArrayList; + Reference *m_references; + size_t m_idx; + static DllNodeList s_allocatedNodes; +}; + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h new file mode 100644 index 0000000..6ccc83b --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h @@ -0,0 +1,245 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <cstddef> +#include <string> +#include <vector> + +#include <stdio.h> +#include <string.h> +#ifndef _WIN32 +#include <inttypes.h> +#endif + +#if defined(_MSC_VER) && !defined(OPENDDL_STATIC_LIBARY) + +#define TAG_DLL_EXPORT __declspec(dllexport) +#define TAG_DLL_IMPORT __declspec(dllimport) +#ifdef OPENDDLPARSER_BUILD +#define DLL_ODDLPARSER_EXPORT TAG_DLL_EXPORT +#else +#define DLL_ODDLPARSER_EXPORT TAG_DLL_IMPORT +#endif // OPENDDLPARSER_BUILD +#pragma warning(disable : 4251) +#else +#define DLL_ODDLPARSER_EXPORT +#endif // _WIN32 + +// Namespace declarations, override this to avoid any conflicts +#define BEGIN_ODDLPARSER_NS namespace ODDLParser { +#define END_ODDLPARSER_NS } // namespace ODDLParser +#define USE_ODDLPARSER_NS using namespace ODDLParser; + +BEGIN_ODDLPARSER_NS + +// We will use C++11 optional +#ifndef OPENDDL_NO_USE_CPP11 +// All C++11 constructs +#define nullptr nullptr +#define ddl_override override +#define ddl_final final +#define ddl_no_copy = delete +#else +// Fall-back for older compilers +#define nullptr NULL +#define ddl_override +#define ddl_final +#define ddl_no_copy +#endif // OPENDDL_NO_USE_CPP11 + +// Forward declarations +class DDLNode; +class Value; + +struct Name; +struct Identifier; +struct Reference; +struct Property; +struct DataArrayList; + +// Platform-specific typedefs +#ifdef _WIN32 +typedef signed __int64 int64_impl; +typedef unsigned __int64 uint64_impl; +#else +typedef int64_t int64_impl; +typedef uint64_t uint64_impl; +#endif + +// OpenDDL-specific data typedefs +using int8 = signed char; ///< Signed integer, 1 byte +using int16 = signed short; ///< Signed integer, 2 byte +using int32 = signed int; ///< Signed integer, 4 byte +using int64 = int64_impl; ///< Signed integer, 8 byte +using uint8 = unsigned char; ///< Unsigned integer, 1 byte +using uint16 = unsigned short ; ///< Unsigned integer, 2 byte +using uint32 = unsigned int; ///< Unsigned integer, 4 byte +using uint64 = uint64_impl ; ///< Unsigned integer, 8 byte + +/// @brief Stores a text. +/// +/// A text is stored in a simple character buffer. Texts buffer can be +/// greater than the number of stored characters in them. +struct DLL_ODDLPARSER_EXPORT Text { + size_t m_capacity; ///< The capacity of the text. + size_t m_len; ///< The length of the text. + char *m_buffer; ///< The buffer with the text. + + /// @brief The constructor with a given text buffer. + /// @param buffer [in] The buffer. + /// @param numChars [in] The number of characters in the buffer. + Text(const char *buffer, size_t numChars); + + /// @brief The destructor. + ~Text(); + + /// @brief Clears the text. + void clear(); + + /// @brief Set a new text. + /// @param buffer [in] The buffer. + /// @param numChars [in] The number of characters in the buffer. + void set(const char *buffer, size_t numChars); + + /// @brief The compare operator for std::strings. + bool operator==(const std::string &name) const; + + /// @brief The compare operator for Texts. + bool operator==(const Text &rhs) const; + +private: + Text(const Text &) ddl_no_copy; + Text &operator=(const Text &) ddl_no_copy; +}; + +/// @brief Description of the type of a name. +enum NameType { + GlobalName, ///< Name is global. + LocalName ///< Name is local. +}; + +/// @brief Stores an OpenDDL-specific name +struct DLL_ODDLPARSER_EXPORT Name { + NameType m_type; ///< The type of the name ( @see NameType ). + Text *m_id; ///< The id. + + /// @brief The constructor with the type and the id. + /// @param type [in] The name type. + /// @param id [in] The id. + Name(NameType type, Text *id); + Name(const Name &name); + /// @brief The destructor. + ~Name(); + +private: + Name &operator=(const Name &) ddl_no_copy; +}; + +/// @brief Stores a bundle of references. +struct DLL_ODDLPARSER_EXPORT Reference { + size_t m_numRefs; ///< The number of stored references. + Name **m_referencedName; ///< The reference names. + + /// @brief The default constructor. + Reference(); + Reference(const Reference &ref); + /// @brief The constructor with an array of ref names. + /// @param numrefs [in] The number of ref names. + /// @param names [in] The ref names. + Reference(size_t numrefs, Name **names); + + /// @brief The destructor. + ~Reference(); + + /// @brief Returns the size in bytes to store one deep reference copy. + /// @return The size on bytes. + size_t sizeInBytes(); + +private: + Reference &operator=(const Reference &) ddl_no_copy; +}; + +/// @brief Stores a property list. +struct DLL_ODDLPARSER_EXPORT Property { + Text *m_key; ///< The identifier / key of the property. + Value *m_value; ///< The value assigned to its key / id ( ddl_nullptr if none ). + Reference *m_ref; ///< References assigned to its key / id ( ddl_nullptr if none ). + Property *m_next; ///< The next property ( ddl_nullptr if none ). + + /// @brief The default constructor. + Property(); + + /// @brief The constructor for initialization. + /// @param id [in] The identifier + Property(Text *id); + + /// @brief The destructor. + ~Property(); + +private: + Property(const Property &) ddl_no_copy; + Property &operator=(const Property &) ddl_no_copy; +}; + +/// @brief Stores a data array list. +struct DLL_ODDLPARSER_EXPORT DataArrayList { + size_t m_numItems; ///< The number of items in the list. + Value *m_dataList; ///< The data list ( a Value ). + DataArrayList *m_next; ///< The next data array list ( ddl_nullptr if last ). + Reference *m_refs; + size_t m_numRefs; + + /// @brief The default constructor for initialization. + DataArrayList(); + + /// @brief The destructor. + ~DataArrayList(); + + /// @brief Gets the length of the array + size_t size(); + +private: + DataArrayList(const DataArrayList &) ddl_no_copy; + DataArrayList &operator=(const DataArrayList &) ddl_no_copy; +}; + +/// @brief Stores the context of a parsed OpenDDL declaration. +struct DLL_ODDLPARSER_EXPORT Context { + DDLNode *m_root; ///< The root node of the OpenDDL node tree. + + /// @brief Constructor for initialization. + Context(); + + /// @brief Destructor. + ~Context(); + + /// @brief Clears the whole node tree. + void clear(); + +private: + Context(const Context &) ddl_no_copy; + Context &operator=(const Context &) ddl_no_copy; +}; + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLExport.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLExport.h new file mode 100644 index 0000000..9452535 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLExport.h @@ -0,0 +1,80 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> +#include <openddlparser/OpenDDLStream.h> +#include <openddlparser/Value.h> + +BEGIN_ODDLPARSER_NS + +// Forward declarations +class IOStreamBase; + +//------------------------------------------------------------------------------------------------- +/// +/// @ingroup OpenDDLParser +/// @brief This class represents the OpenDDLExporter. +/// +//------------------------------------------------------------------------------------------------- +class DLL_ODDLPARSER_EXPORT OpenDDLExport { +public: + /// @brief The class constructor + OpenDDLExport(IOStreamBase *stream = nullptr); + + /// @brief The class destructor. + ~OpenDDLExport(); + + /// @brief Export the data of a parser context. + /// @param ctx [in] Pointer to the context. + /// @param filename [in] The filename for the export. + /// @return True in case of success, false in case of an error. + bool exportContext(Context *ctx, const std::string &filename); + + /// @brief Handles a node export. + /// @param node [in] The node to handle with. + /// @return True in case of success, false in case of an error. + bool handleNode(DDLNode *node); + + /// @brief Writes the statement to the stream. + /// @param statement [in] The content to write. + /// @return True in case of success, false in case of an error. + bool writeToStream(const std::string &statement); + +protected: + bool writeNode(DDLNode *node, std::string &statement); + bool writeNodeHeader(DDLNode *node, std::string &statement); + bool writeProperties(DDLNode *node, std::string &statement); + bool writeValueType(Value::ValueType type, size_t numItems, std::string &statement); + bool writeValue(Value *val, std::string &statement); + bool writeValueArray(DataArrayList *al, std::string &statement); + +private: + OpenDDLExport(const OpenDDLExport &) ddl_no_copy; + OpenDDLExport &operator=(const OpenDDLExport &) ddl_no_copy; + +private: + IOStreamBase *m_stream; +}; + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParser.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParser.h new file mode 100644 index 0000000..3fbb4b6 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParser.h @@ -0,0 +1,206 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/DDLNode.h> +#include <openddlparser/OpenDDLCommon.h> +#include <openddlparser/OpenDDLParserUtils.h> +#include <openddlparser/Value.h> + +#include <string> +#include <vector> +#include <functional> + +BEGIN_ODDLPARSER_NS + +class DDLNode; +class Value; + +struct Identifier; +struct Reference; +struct Property; + +template <class T> +inline bool isEmbeddedCommentOpenTag(T *in, T *end) { + if (in == '/' && in + 1 == '*') { + return true; + } + + return false; +} + +/// @brief Utility function to search for the next token or the end of the buffer. +/// @param in [in] The start position in the buffer. +/// @param end [in] The end position in the buffer. +/// @return Pointer showing to the next token or the end of the buffer. +/// @detail Will not increase buffer when already a valid buffer was found. +template <class T> +inline T *lookForNextToken(T *in, T *end) { + while ((in != end) && (isSpace(*in) || isNewLine(*in) || ',' == *in)) { + ++in; + } + return in; +} + +/// @brief Utility function to go for the next token or the end of the buffer. +/// @param in [in] The start position in the buffer. +/// @param end [in] The end position in the buffer. +/// @return Pointer showing to the next token or the end of the buffer. +/// @detail Will increase buffer by a minimum of one. +template <class T> +inline T *getNextToken(T *in, T *end) { + T *tmp(in); + in = lookForNextToken(in, end); + if (tmp == in) { + ++in; + } + return in; +} + +/// @brief Defines the log severity. +enum LogSeverity { + ddl_debug_msg = 0, ///< Debug message, for debugging + ddl_info_msg, ///< Info messages, normal mode + ddl_warn_msg, ///< Parser warnings + ddl_error_msg ///< Parser errors +}; + +DLL_ODDLPARSER_EXPORT const char *getTypeToken(Value::ValueType type); + +//------------------------------------------------------------------------------------------------- +/// @class OpenDDLParser +/// @ingroup OpenDDLParser + +/// +/// @brief This is the main API for the OpenDDL-parser. +/// +/// Use instances of this class to manage the parsing and handling of your parser contexts. +//------------------------------------------------------------------------------------------------- +class DLL_ODDLPARSER_EXPORT OpenDDLParser { +public: + /// @brief The log callback function. + typedef std::function<void (LogSeverity severity, const std::string &msg)> logCallback; + +public: + /// @brief The default class constructor. + OpenDDLParser(); + + /// @brief The class constructor. + /// @param buffer [in] The buffer + /// @param len [in] Size of the buffer + OpenDDLParser(const char *buffer, size_t len); + + /// @brief The class destructor. + ~OpenDDLParser(); + + /// @brief Setter for an own log callback function. + /// @param callback [in] The own callback. + void setLogCallback(logCallback callback); + + /// @brief Getter for the log callback. + /// @return The current log callback. + logCallback getLogCallback() const; + + /// @brief A default log callback that writes to a FILE. + /// @param destination [in] Output stream. NULL will use stderr. + /// @return A callback that you can pass to setLogCallback. + static logCallback StdLogCallback(FILE *destination = nullptr); + + /// @brief Assigns a new buffer to parse. + /// @param buffer [in] The buffer + /// @param len [in] Size of the buffer + void setBuffer(const char *buffer, size_t len); + + /// @brief Assigns a new buffer to parse. + /// @param buffer [in] The buffer as a std::vector. + void setBuffer(const std::vector<char> &buffer); + + /// @brief Returns the buffer pointer. + /// @return The buffer pointer. + const char *getBuffer() const; + + /// @brief Returns the size of the buffer. + /// @return The buffer size. + size_t getBufferSize() const; + + /// @brief Clears all parser data, including buffer and active context. + void clear(); + + bool validate(); + + /// @brief Starts the parsing of the OpenDDL-file. + /// @return True in case of success, false in case of an error. + /// @remark In case of errors check log. + bool parse(); + + + bool exportContext(Context *ctx, const std::string &filename); + + /// @brief Returns the root node. + /// @return The root node. + DDLNode *getRoot() const; + + /// @brief Returns the parser context, only available in case of a succeeded parsing. + /// @return Pointer to the active context or ddl_nullptr. + Context *getContext() const; + +public: // parser helpers + char *parseNextNode(char *current, char *end); + char *parseHeader(char *in, char *end); + char *parseStructure(char *in, char *end); + char *parseStructureBody(char *in, char *end, bool &error); + void pushNode(DDLNode *node); + DDLNode *popNode(); + DDLNode *top(); + static void normalizeBuffer(std::vector<char> &buffer); + static char *parseName(char *in, char *end, Name **name); + static char *parseIdentifier(char *in, char *end, Text **id); + static char *parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len); + static char *parseReference(char *in, char *end, std::vector<Name *> &names); + static char *parseBooleanLiteral(char *in, char *end, Value **boolean); + static char *parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType = Value::ValueType::ddl_int32); + static char *parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType = Value::ValueType::ddl_float); + static char *parseStringLiteral(char *in, char *end, Value **stringData); + static char *parseHexaLiteral(char *in, char *end, Value **data); + static char *parseProperty(char *in, char *end, Property **prop); + static char *parseDataList(char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs); + static char *parseDataArrayList(char *in, char *end, Value::ValueType type, DataArrayList **dataList); + static const char *getVersion(); + +private: + OpenDDLParser(const OpenDDLParser &) ddl_no_copy; + OpenDDLParser &operator=(const OpenDDLParser &) ddl_no_copy; + +private: + logCallback m_logCallback; + std::vector<char> m_buffer; + + typedef std::vector<DDLNode *> DDLNodeStack; + DDLNodeStack m_stack; + Context *m_context; + + /// @brief Callback for StdLogCallback(). Not meant to be called directly. + static void logToStream (FILE *, LogSeverity, const std::string &); +}; + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h new file mode 100644 index 0000000..42ad675 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h @@ -0,0 +1,503 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> + +BEGIN_ODDLPARSER_NS + +template <class T> +inline bool isUpperCase(T in) { + return (in >= 'A' && in <= 'Z'); +} + +template <class T> +inline bool isLowerCase(T in) { + return (in >= 'a' && in <= 'z'); +} + +template <class T> +inline bool isSpace(const T in) { + return (' ' == in || '\t' == in); +} + +template <class T> +inline bool isNewLine(const T in) { + return ('\n' == in || ('\r' == in)); +} + +template <class T> +inline bool isSeparator(T in) { + if (isSpace(in) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in) { + return true; + } + return false; +} + +static const unsigned char chartype_table[256] = { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 0-15 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 16-31 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 32-47 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, // 48-63 + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 64-79 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 80-95 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 96-111 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 112-127 + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // > 127 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +}; + +template <class T> +inline bool isNumeric(const T in) { + size_t idx = static_cast<size_t>(in); + return idx < sizeof(chartype_table) && (chartype_table[idx] == 1); +} + +template <class T> +inline bool isNotEndOfToken(T *in, T *end) { + return ('}' != *in && ',' != *in && !isSpace(*in) && ')' != *in && in != end); +} + +template <class T> +inline bool isInteger(T *in, T *end) { + if (in != end) { + if (*in == '-') { + ++in; + } + } + + bool result(false); + while (isNotEndOfToken(in, end)) { + result = isNumeric(*in); + if (!result) { + break; + } + ++in; + } + + return result; +} + +template <class T> +inline bool isFloat(T *in, T *end) { + if (in != end) { + if (*in == '-') { + ++in; + } + } + + // check for <1>.0f + bool result(false); + while (isNotEndOfToken(in, end)) { + if (*in == '.') { + result = true; + break; + } + result = isNumeric(*in); + if (!result) { + return false; + } + ++in; + } + + // check for 1<.>0f + if (*in == '.') { + ++in; + } else { + return false; + } + + // check for 1.<0>f + while (isNotEndOfToken(in, end)) { + result = isNumeric(*in); + if (!result) { + return false; + } + ++in; + } + + return result; +} + +template <class T> +inline bool isCharacter(const T in) { + return ((in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z')); +} + +template <class T> +inline bool isStringLiteral(const T in) { + return (in == '\"'); +} + +template <class T> +inline bool isHexLiteral(T *in, T *end) { + if (*in == '0') { + if (in + 1 != end) { + if (*(in + 1) == 'x' || *(in + 1) == 'X') { + return true; + } + } + } + + return false; +} + +template <class T> +inline bool isReference(T *in, T *end) { + if (*in == 'r') { + if (*(in + 1) == 'e') { + if (*(in + 2) == 'f') { + if ((in + 2) != end) { + return true; + } + } + } + } + + return false; +} + +template <class T> +inline bool isEndofLine(const T in) { + return ('\n' == in); +} + +template <class T> +inline static T *getNextSeparator(T *in, T *end) { + while (!isSeparator(*in) || in == end) { + ++in; + } + return in; +} + +static const int ErrorHex2Decimal = 9999999; + +inline int hex2Decimal(char in) { + if (isNumeric(in)) { + return (in - 48); + } + + char hexCodeLower('a'), hexCodeUpper('A'); + for (int i = 0; i < 16; i++) { + if (in == hexCodeLower + i || in == hexCodeUpper + i) { + return (i + 10); + } + } + + return ErrorHex2Decimal; +} + +template <class T> +inline bool isComment(T *in, T *end) { + if (*in == '/') { + if (in + 1 != end) { + if (*(in + 1) == '/') { + char *drive((in + 2)); + if ((isUpperCase<T>(*drive) || isLowerCase<T>(*drive)) && *(drive + 1) == '/') { + return false; + } else { + return true; + } + } + } + } + + return false; +} + +template <class T> +inline bool isCommentOpenTag(T *in, T *end) { + if (*in == '/') { + if (in + 1 != end) { + if (*(in + 1) == '*') { + return true; + } + } + } + + return false; +} + +template <class T> +inline bool isCommentCloseTag(T *in, T *end) { + if (*in == '*') { + if (in + 1 != end) { + if (*(in + 1) == '/') { + return true; + } + } + } + + return false; +} + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLStream.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLStream.h new file mode 100644 index 0000000..93bde5f --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/OpenDDLStream.h @@ -0,0 +1,89 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> + +BEGIN_ODDLPARSER_NS + +//------------------------------------------------------------------------------------------------- +/// @ingroup IOStreamBase +/// @brief This class represents the stream to write out. +//------------------------------------------------------------------------------------------------- +class DLL_ODDLPARSER_EXPORT StreamFormatterBase { +public: + /// @brief The class constructor. + StreamFormatterBase(); + + /// @brief The class destructor, virtual. + virtual ~StreamFormatterBase(); + + /// @brief Will format the string and return the new formatted result. + /// @param statement [in] The string to reformat. + /// @return The reformatted result. + virtual std::string format(const std::string &statement); +}; + +//------------------------------------------------------------------------------------------------- +/// @ingroup IOStreamBase +/// @brief This class represents the stream to write out. +//------------------------------------------------------------------------------------------------- +class DLL_ODDLPARSER_EXPORT IOStreamBase { +public: + /// @brief The class constructor with the formatter. + /// @param formatter [in] The formatter to use. + explicit IOStreamBase(StreamFormatterBase *formatter = nullptr); + + /// @brief The class destructor, virtual. + virtual ~IOStreamBase(); + + /// @brief Will open the stream. + /// @param name [in] The name for the stream. + /// @return true, if the stream was opened successfully, false if not. + virtual bool open(const std::string &name); + + /// @brief Will close the stream. + /// @return true, if the stream was closed successfully, false if not. + virtual bool close(); + + /// @brief Returns true, if the stream is open. + /// @return true, if the stream is open, false if not. + virtual bool isOpen() const; + + /// @brief Will read a string from the stream. + /// @param sizeToRead [in] The size to read in bytes. + /// @param statement [out] The read statements. + /// @return The bytes read from the stream. + virtual size_t read(size_t sizeToRead, std::string &statement); + + /// @brief Will write a string into the stream. + /// @param statement [in] The string to write. + /// @return The bytes written into the stream. + virtual size_t write(const std::string &statement); + +private: + StreamFormatterBase *m_formatter; + FILE *m_file; +}; + +END_ODDLPARSER_NS diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/TPoolAllocator.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/TPoolAllocator.h new file mode 100644 index 0000000..6076c73 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/TPoolAllocator.h @@ -0,0 +1,226 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2019 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> +#include <string> + +BEGIN_ODDLPARSER_NS + +//------------------------------------------------------------------------------------------------- +/// @class TPoolAllocator +/// @ingroup CPPCore +/// +/// @brief This class implements a simple pool-based allocation scheme. +/// Initially you have to define its size. Each allocation will be done from this initially created +/// pool. You have to release all pooled instances after the usage. +/// This allocation scheme is fast and does no call any new-calls during the lifetime of the +/// allocator. +//------------------------------------------------------------------------------------------------- +template <class T> +class TPoolAllocator { +public: + TPoolAllocator(); + TPoolAllocator(size_t numItems); + ~TPoolAllocator(); + T *alloc(); + void release(); + void reserve(size_t size); + void clear(); + size_t capacity() const; + size_t reservedMem() const; + size_t freeMem() const; + void dumpAllocations(std::string &allocs); + void resize(size_t growSize); + + CPPCORE_NONE_COPYING(TPoolAllocator) + +private: + struct Pool { + size_t m_poolsize; + T *m_pool; + size_t m_currentIdx; + Pool *m_next; + + Pool() : + m_poolsize(0u), m_pool(nullptr), m_currentIdx(0u), m_next(nullptr) { + // empty + } + + Pool(size_t numItems, Pool *prev) : + m_poolsize(numItems), m_pool(nullptr), m_currentIdx(0u), m_next(prev) { + m_pool = new T[m_poolsize]; + } + + ~Pool() { + delete[] m_pool; + m_pool = nullptr; + } + + CPPCORE_NONE_COPYING(Pool) + }; + + Pool *getFreePool() { + Pool *current(m_freeList); + if (nullptr != m_freeList) { + m_freeList = m_freeList->m_next; + } + return current; + } + + Pool *m_first; + Pool *m_current; + Pool *m_freeList; + size_t m_capacity; +}; + +template <class T> +inline TPoolAllocator<T>::TPoolAllocator() : + m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) { + // empty +} + +template <class T> +inline TPoolAllocator<T>::TPoolAllocator(size_t numItems) : + m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) { + m_first = new Pool(numItems); + m_capacity += numItems; + m_current = m_first; +} + +template <class T> +inline TPoolAllocator<T>::~TPoolAllocator() { + clear(); +} + +template <class T> +inline T *TPoolAllocator<T>::alloc() { + if (nullptr == m_current) { + return nullptr; + } + + if (m_current->m_currentIdx == m_current->m_poolsize) { + resize(m_current->m_poolsize); + } + + T *ptr(&m_current->m_pool[m_current->m_currentIdx]); + m_current->m_currentIdx++; + + return ptr; +} + +template <class T> +inline void TPoolAllocator<T>::release() { + if (nullptr == m_current) { + return; + } + + Pool *current(m_first); + while (nullptr != current) { + current->m_currentIdx = 0; + current = current->m_next; + } + m_freeList = m_first->m_next; + m_current = m_first; +} + +template <class T> +inline void TPoolAllocator<T>::reserve(size_t size) { + clear(); + + m_first = new Pool(size, nullptr); + m_current = m_first; + + m_current->m_pool = new T[size]; + m_current->m_poolsize = size; + + m_capacity = size; +} + +template <class T> +inline void TPoolAllocator<T>::clear() { + if (nullptr == m_current) { + return; + } + + Pool *next(m_first); + while (nullptr != next) { + Pool *current = next; + next = current->m_next; + delete current; + } + m_current = nullptr; + m_freeList = nullptr; +} + +template <class T> +inline size_t TPoolAllocator<T>::capacity() const { + return m_capacity; +} + +template <class T> +inline size_t TPoolAllocator<T>::reservedMem() const { + return m_capacity * sizeof(T); +} + +template <class T> +inline size_t TPoolAllocator<T>::freeMem() const { + if (nullptr == m_current) { + return 0L; + } + + return (m_current->m_poolsize - m_current->m_currentIdx); +} + +template <class T> +inline void TPoolAllocator<T>::dumpAllocations(std::string &allocs) { + allocs.clear(); + allocs += "Number allocations = "; + allocs += std::to_string(m_current->m_currentIdx); + allocs += "\n"; +} + +template <class T> +inline void TPoolAllocator<T>::resize(size_t growSize) { + if (nullptr != m_current) { + if (growSize < m_current->m_poolsize) { + return; + } + } + + if (nullptr == m_first) { + m_first = new Pool(growSize, nullptr); + m_current = m_first; + m_capacity += m_current->m_poolsize; + } else { + Pool *pool = getFreePool(); + if (nullptr == pool) { + pool = new Pool(growSize, nullptr); + m_capacity += growSize; + } + m_current->m_next = pool; + m_current = m_current->m_next; + } +} + +END_ODDLPARSER_NS
\ No newline at end of file diff --git a/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/Value.h b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/Value.h new file mode 100644 index 0000000..75af781 --- /dev/null +++ b/src/mesh/assimp-master/contrib/openddlparser/include/openddlparser/Value.h @@ -0,0 +1,273 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2020 Kim Kulling + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include <openddlparser/OpenDDLCommon.h> + +#include <string> + +BEGIN_ODDLPARSER_NS + +// Forward declarations +struct ValueAllocator; + +class IOStreamBase; + +///------------------------------------------------------------------------------------------------ +/// @brief This class implements a value. +/// +/// Values are used to store data types like boolean, integer, floats, double and many mode. To get +/// an overview please check the enum VylueType ( @see Value::ValueType ). +/// Values can be single items or lists of items. They are implemented as linked lists. +///------------------------------------------------------------------------------------------------ +class DLL_ODDLPARSER_EXPORT Value { + friend struct ValueAllocator; + +public: + /// @brief This class implements an iterator through a Value list. + /// + /// When getting a new value you need to know how to iterate through it. The Value::Iterator + /// will help you here: + /// @code + /// Value *val = node->getValue(); + /// Value::Iterator it( val ); + /// while( it.hasNext() ) { + /// Value v( it.getNext ); + /// } + /// @endcode + class DLL_ODDLPARSER_EXPORT Iterator { + public: + /// @brief The default class constructor. + Iterator(); + + /// @brief The class constructor with the start value. + /// @param start [in] The first value for iteration, + Iterator( Value *start ); + + Iterator( const Iterator &rhs ); + + /// @brief The class destructor. + ~Iterator(); + + /// @brief Will return true, if another value is in the list. + /// @return true if another value is there. + bool hasNext() const; + + /// @brief Returns the next item and moves the iterator to it. + /// @return The next value, is ddl_nullptr in case of being the last item. + Value *getNext(); + + /// @brief The post-increment operator. + const Iterator operator++( int ); + + /// @brief The pre-increment operator. + Iterator &operator++( ); + + /// @brief The compare operator. + /// @param rhs [in] The instance to compare. + /// @return true if equal. + bool operator == ( const Iterator &rhs ) const; + + /// @brief The * operator. + /// @return The instance or ddl_nullptr if end of list is reached. + Value *operator->( ) const; + + private: + Value *m_start; + Value *m_current; + + private: + Iterator &operator = ( const Iterator & ); + }; + + /// @brief This enum describes the data type stored in the value. + enum class ValueType { + ddl_none = -1, ///< Nothing specified + ddl_bool = 0, ///< A boolean type + ddl_int8, ///< Integer type, 8 bytes + ddl_int16, ///< Integer type, 16 bytes + ddl_int32, ///< Integer type, 32 bytes + ddl_int64, ///< Integer type, 64 bytes + ddl_unsigned_int8, ///< Unsigned integer type, 8 bytes + ddl_unsigned_int16, ///< Unsigned integer type, 16 bytes + ddl_unsigned_int32, ///< Unsigned integer type, 32 bytes + ddl_unsigned_int64, ///< Unsigned integer type, 64 bytes + ddl_half, ///< Half data type. + ddl_float, ///< float data type + ddl_double, ///< Double data type. + ddl_string, ///< String data type. + ddl_ref, ///< Reference, used to define references to other data definitions. + ddl_types_max ///< Upper limit. + }; + + /// @brief The class constructor. + /// @param type [in] The value type. + Value( ValueType type ); + + /// @brief The class destructor. + ~Value(); + + /// @brief Assigns a boolean to the value. + /// @param value [in9 The value. + void setBool( bool value ); + + /// @brief Returns the boolean value. + /// @return The boolean value. + bool getBool(); + + /// @brief Assigns a int8 to the value. + /// @param value [in] The value. + void setInt8( int8 value ); + + /// @brief Returns the int8 value. + /// @return The int8 value. + int8 getInt8(); + + /// @brief Assigns a int16 to the value. + /// @param value [in] The value. + void setInt16( int16 value ); + + /// @brief Returns the int16 value. + /// @return The int16 value. + int16 getInt16(); + + /// @brief Assigns a int32 to the value. + /// @param value [in] The value. + void setInt32( int32 value ); + + /// @brief Returns the int16 value. + /// @return The int32 value. + int32 getInt32(); + + /// @brief Assigns a int64 to the value. + /// @param value [in] The value. + void setInt64( int64 value ); + + /// @brief Returns the int16 value. + /// @return The int64 value. + int64 getInt64(); + + /// @brief Assigns a unsigned int8 to the value. + /// @param value [in] The value. + void setUnsignedInt8( uint8 value ); + + /// @brief Returns the unsigned int8 value. + /// @return The unsigned int8 value. + uint8 getUnsignedInt8() const; + + /// @brief Assigns a unsigned int16 to the value. + /// @param value [in] The value. + void setUnsignedInt16( uint16 value ); + + /// @brief Returns the unsigned int16 value. + /// @return The unsigned int16 value. + uint16 getUnsignedInt16() const; + + /// @brief Assigns a unsigned int32 to the value. + /// @param value [in] The value. + void setUnsignedInt32( uint32 value ); + + /// @brief Returns the unsigned int8 value. + /// @return The unsigned int32 value. + uint32 getUnsignedInt32() const; + + /// @brief Assigns a unsigned int64 to the value. + /// @param value [in] The value. + void setUnsignedInt64( uint64 value ); + + /// @brief Returns the unsigned int64 value. + /// @return The unsigned int64 value. + uint64 getUnsignedInt64() const; + + /// @brief Assigns a float to the value. + /// @param value [in] The value. + void setFloat( float value ); + + /// @brief Returns the float value. + /// @return The float value. + float getFloat() const; + + /// @brief Assigns a double to the value. + /// @param value [in] The value. + void setDouble( double value ); + + /// @brief Returns the double value. + /// @return The double value. + double getDouble() const; + + /// @brief Assigns a std::string to the value. + /// @param str [in] The value. + void setString( const std::string &str ); + + /// @brief Returns the std::string value. + /// @return The std::string value. + const char *getString() const; + + /// @brief Set the reference. + /// @param ref [in] Pointer showing to the reference. + void setRef( Reference *ref ); + + /// @brief Returns the pointer showing to the reference. + /// @return Pointer showing to the reference. + Reference *getRef() const; + + /// @brief Dumps the value. + /// @param stream [in] The stream to write in. + void dump( IOStreamBase &stream ); + + /// @brief Assigns the next value. + /// @param next [n] The next value. + void setNext( Value *next ); + + /// @brief Returns the next value. + /// @return The next value.s + Value *getNext() const; + + /// @brief Gets the length of the array. + /// @return The number of items in the array. + size_t size() const; + + ValueType m_type; + size_t m_size; + unsigned char *m_data; + Value *m_next; + +private: + Value &operator =( const Value & ) ddl_no_copy; + Value( const Value & ) ddl_no_copy; +}; + +///------------------------------------------------------------------------------------------------ +/// @brief This class implements the value allocator. +///------------------------------------------------------------------------------------------------ +struct DLL_ODDLPARSER_EXPORT ValueAllocator { + static Value *allocPrimData( Value::ValueType type, size_t len = 1 ); + static void releasePrimData( Value **data ); + +private: + ValueAllocator() ddl_no_copy; + ValueAllocator( const ValueAllocator & ) ddl_no_copy; + ValueAllocator &operator = ( const ValueAllocator & ) ddl_no_copy; +}; + +END_ODDLPARSER_NS |