tarion/Engine2026
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

new stuff

Browse source
This commit is contained in:
Tarion 2026-07-03 03:41:25 +02:00
parent 8998bc3936
commit 64c8492e5c
No known key found for this signature in database
6907 changed files with 3401899 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

173
assimp/contrib/openddlparser/include/openddlparser/DDLNode.h Normal file
View file

@ -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

245
assimp/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h Normal file
View file

@ -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 <cstdio>
#include <cstring>
#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

80
assimp/contrib/openddlparser/include/openddlparser/OpenDDLExport.h Normal file
View file

@ -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

197
assimp/contrib/openddlparser/include/openddlparser/OpenDDLParser.h Normal file
View file

@ -0,0 +1,197 @@
/*-----------------------------------------------------------------------------------------------
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;
/// @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

509
assimp/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h Normal file
View file

@ -0,0 +1,509 @@
/*-----------------------------------------------------------------------------------------------
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;
}
const size_t CharTableSize = 256;
static const unsigned char chartype_table[CharTableSize] = {
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) {
if (static_cast<size_t>(in) >= CharTableSize) {
return '\0';
}
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 (in != end && !isSeparator(*in)) {
++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

89
assimp/contrib/openddlparser/include/openddlparser/OpenDDLStream.h Normal file
View file

@ -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

226
assimp/contrib/openddlparser/include/openddlparser/TPoolAllocator.h Normal file
View file

@ -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

273
assimp/contrib/openddlparser/include/openddlparser/Value.h Normal file
View file

@ -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