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

216
assimp/contrib/openddlparser/CMakeLists.txt Normal file
View file

@ -0,0 +1,216 @@
CMAKE_MINIMUM_REQUIRED( VERSION 3.8 )
PROJECT( OpenDDL-Parser )
# read version number from cpp file of the form: static const char *Version = "0.4.0";
file ( READ code/OpenDDLParser.cpp _ver )
string( REGEX MATCH "static const char [*]Version[ ]*=[ ]*\"[^\"]*\"" _ver_line "${_ver}" )
string( REGEX MATCH "[0-9]+\.[0-9]+\.[0-9]+" openddlparser_VERSION "${_ver_line}" )
SET ( PROJECT_VERSION "${openddlparser_VERSION}" )
if ( "${PROJECT_VERSION}" STREQUAL "" )
message( FATAL_ERROR "Cannot find 'static const char *Version' in 'code/OpenDDLParser.cpp'" )
endif()
message(STATUS "openddlparser_VERSION: ${openddlparser_VERSION}")
option( DDL_DEBUG_OUTPUT "Set to ON to use output debug texts" OFF )
option( DDL_STATIC_LIBRARY "Deprecated, use BUILD_SHARED_LIBS instead." ON )
# for backwards compatibility use DDL_STATIC_LIBRARY as initial value for cmake variable BUILD_SHARED_LIBS
# https://cmake.org/cmake/help/latest/variable/BUILD_SHARED_LIBS.html
if ( DDL_STATIC_LIBRARY )
message("Building shared lib.")
set ( build_shared_libs_default OFF )
else()
message("Building static lib.")
set ( build_shared_libs_default ON )
endif()
option( DDL_BUILD_SHARED_LIBS "Set to ON to build shared libary of OpenDDL Parser." ${build_shared_libs_default} )
option( COVERALLS "Generate coveralls data" OFF )
option( DDL_DOCUMENTATION "Set to ON to opt in generating API documentation with Doxygen" OFF )
option( DDL_BUILD_TESTS "Set to OFF to not build tests by default" ON )
option( DDL_BUILD_PARSER_DEMO "Set to OFF to opt out building parser demo" ON )
if (MSVC)
add_definitions(
-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING
-DGTEST_HAS_TR1_TUPLE=0
-D_CRT_SECURE_NO_WARNINGS
)
endif()
add_definitions( -D_VARIADIC_MAX=10 )
add_definitions( -DGTEST_HAS_PTHREAD=0 )
if ( DDL_DEBUG_OUTPUT )
message("Enable debug output.")
add_definitions( -DDDL_DEBUG_HEADER_NAME)
endif()
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib )
SET( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib )
SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin )
if (MSVC)
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc" ) # Force to always compile with W4
if( CMAKE_CXX_FLAGS MATCHES "/W[0-4]" )
string( REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" )
else()
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4" )
endif()
elseif( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX )
# Update if necessary
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic ${OPENDDL_CXXFLAGS}")
elseif ( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic ${OPENDDL_CXXFLAGS} -Wwrite-strings")
endif()
if (COVERALLS)
include(Coveralls)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
message("Enable coveralls.")
endif()
# Include the doc component.
if(DDL_DOCUMENTATION)
message("Generate doxygen documentation.")
find_package(Doxygen REQUIRED)
CONFIGURE_FILE( doc/openddlparser_doc.in doc/doxygenfile @ONLY )
add_custom_target(doc ALL
${DOXYGEN_EXECUTABLE} doc/doxygenfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating API documentation with Doxygen" VERBATIM )
endif()
SET ( openddlparser_headers
include/openddlparser/OpenDDLCommon.h
include/openddlparser/OpenDDLExport.h
include/openddlparser/OpenDDLParser.h
include/openddlparser/OpenDDLParserUtils.h
include/openddlparser/OpenDDLStream.h
include/openddlparser/DDLNode.h
include/openddlparser/Value.h
include/openddlparser/TPoolAllocator.h
)
SET ( openddlparser_src
code/OpenDDLCommon.cpp
code/OpenDDLExport.cpp
code/OpenDDLParser.cpp
code/OpenDDLStream.cpp
code/DDLNode.cpp
code/Value.cpp
)
SOURCE_GROUP( code FILES ${openddlparser_src} )
ADD_LIBRARY( openddlparser ${openddlparser_src})
target_include_directories(openddlparser PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
target_compile_features(openddlparser PUBLIC cxx_std_11)
if(DDL_BUILD_SHARED_LIBS)
set_target_properties(openddlparser PROPERTIES
CXX_VISIBILITY_PRESET hidden
VISIBILITY_INLINES_HIDDEN TRUE
)
else()
target_compile_definitions(openddlparser PUBLIC OPENDDL_STATIC_LIBARY)
endif()
set_target_properties( openddlparser PROPERTIES PUBLIC_HEADER "${openddlparser_headers}")
if (DDL_BUILD_TESTS)
find_package(Threads REQUIRED)
SET ( GTEST_PATH contrib/gtest-1.7.0 )
SET ( gtest_src
${GTEST_PATH}/src/gtest-death-test.cc
${GTEST_PATH}/src/gtest-filepath.cc
${GTEST_PATH}/src/gtest-port.cc
${GTEST_PATH}/src/gtest-printers.cc
${GTEST_PATH}/src/gtest-test-part.cc
${GTEST_PATH}/src/gtest-typed-test.cc
${GTEST_PATH}/src/gtest.cc
)
SET( openddlparser_unittest_src
test/DDLNodeTest.cpp
test/OpenDDLCommonTest.cpp
test/OpenDDLExportTest.cpp
test/OpenDDLParserTest.cpp
test/OpenDDLParserUtilsTest.cpp
test/OpenDDLStreamTest.cpp
test/OpenDDLIntegrationTest.cpp
test/ValueTest.cpp
test/OpenDDLDefectsTest.cpp
test/OssFuzzTest.cpp
test/main.cpp
)
SOURCE_GROUP( code FILES ${openddlparser_unittest_src} )
SOURCE_GROUP( gtest FILES ${gtest_src} )
ADD_EXECUTABLE( openddlparser_unittest
${gtest_src}
${openddlparser_unittest_src}
)
target_include_directories(openddlparser_unittest
PRIVATE
${GTEST_PATH}
${GTEST_PATH}/include
)
target_link_libraries(openddlparser_unittest openddlparser Threads::Threads)
target_compile_features(openddlparser_unittest PRIVATE cxx_std_11)
target_compile_definitions(openddlparser_unittest PRIVATE OPENDDL_TEST_DATA="${PROJECT_SOURCE_DIR}/test/TestData")
endif ()
if (DDL_BUILD_PARSER_DEMO)
SET( openddlparser_demo_src
demo/main.cpp
)
if (COVERALLS)
set(COVERAGE_SRCS ${gtest_src} ${openddlparser_unittest_src} )
# Create the coveralls target.
coveralls_setup(
"${COVERAGE_SRCS}" # The source files.
ON # If we should upload.
"${PROJECT_SOURCE_DIR}/cmake/") # (Optional) Alternate project cmake module path.
endif()
ADD_EXECUTABLE( openddlparser_demo
${openddlparser_demo_src}
)
target_link_libraries( openddlparser_demo openddlparser )
target_compile_features(openddlparser_demo PRIVATE cxx_std_11)
endif ()
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
install(TARGETS openddlparser
EXPORT openddlparser-targets
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/openddlparser")
export(EXPORT openddlparser-targets
FILE openddlparser-config.cmake
NAMESPACE openddlparser::)
install(EXPORT openddlparser-targets
FILE openddlparser-config.cmake
NAMESPACE openddlparser::
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/openddlparser")
write_basic_package_version_file(
"${CMAKE_BINARY_DIR}/openddlparser-config-version.cmake"
COMPATIBILITY SameMajorVersion)
install(
FILES "${CMAKE_BINARY_DIR}/openddlparser-config-version.cmake"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/openddlparser")

19
assimp/contrib/openddlparser/CREDITS Normal file
View file

@ -0,0 +1,19 @@
===============================================================
OpenDDL-Parser
Developers and Contributors
===============================================================
- Kim Kulling ( kimmi ):
Founder
- Fredrik Hansson ( FredrikHson ):
Improvements value interface, serveral bugfixes.
- Henry Read ( henrya2 ):
Static build option, Interface improvements
- (wise86-android)
fix several mem-leaks
- Paul Holland ( pkholland ):
Bugfixes.

22
assimp/contrib/openddlparser/LICENSE Normal file
View file

@ -0,0 +1,22 @@
The MIT License (MIT)
Copyright (c) 2014 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.

141
assimp/contrib/openddlparser/README.md Normal file
View file

@ -0,0 +1,141 @@
The OpenDDL-Parser
==================
The OpenDDL-Parser is a small and easy to use library for OpenDDL-file-format-parsing. OpenDDL is the shortcut for Open Data Description Language, a data-declaration language introduced by Eric Lengyel. Please check http://openddl.org/ if you want to learn more about it.
Build status
============
Linux build status: [![Build Status](https://travis-ci.com/kimkulling/openddl-parser.svg?branch=master)](https://travis-ci.com/kimkulling/openddl-parser)
Current coverity check status:
<a href="https://scan.coverity.com/projects/5606">
<img alt="Coverity Scan Build Status"
src="https://scan.coverity.com/projects/5606/badge.svg"/>
</a>
Current test coverage:[![Coverage Status](https://coveralls.io/repos/github/kimkulling/openddl-parser/badge.svg?branch=master)](https://coveralls.io/github/kimkulling/openddl-parser?branch=cpp_coveralls)
Get the source code
===================
You can get the code from our git repository, which is located at GitHub. You can clone the repository with the following command:
> git clone https://github.com/kimkulling/openddl-parser.git
Building the source from the GitHub-Repo
========================================
To build the library you need to install cmake first ( see http://www.cmake.org/ for more information ). Make also sure that a compiler tool-chain is installed on your machine.
After installing it you can open a console and enter:
> cmake CMakeLists.txt
This command will generate a build environment for your preferred build tool ( for Visual-Studio-users the project files will be generated, for gcc-users the makefiles will be generated ).
When using an IDE open the IDE and run the build. When using GNU-make type in your console:
> make
and that's all.
When using Visual Studio CMake will generate you a solution for ythe library. Just build it there.
Use the library
===============
To use the OpenDDL-parser you need to build the lib first. Now add the
> <Repo-folder>/include
to your include-path and the
> <Repo-folder>/lib
to your lib-folder. Link the openddl.lib to your application.
Here is a small example how to use the lib:
```cpp
#include <iostream>
#include <cassert>
#include <openddlparser/OpenDDLParser.h>
USE_ODDLPARSER_NS;
int main( int argc, char *argv[] ) {
if( argc < 3 ) {
return Error;
}
char *filename( nullptr );
if( 0 == strncmp( FileOption, argv[1], strlen( FileOption ) ) ) {
filename = argv[ 2 ];
}
std::cout << "file to import: " << filename << std::endl;
if( nullptr == filename ) {
std::cerr << "Invalid filename." << std::endl;
return Error;
}
FILE *fileStream = fopen( filename, "r+" );
if( NULL == filename ) {
std::cerr << "Cannot open file " << filename << std::endl;
return Error;
}
// obtain file size:
fseek( fileStream, 0, SEEK_END );
const size_t size = ftell( fileStream );
rewind( fileStream );
if( size > 0 ) {
char *buffer = new char[ size ];
const size_t readSize = fread( buffer, sizeof( char ), size, fileStream );
assert( readSize == size );
// Set the memory buffer
OpenDDLParser theParser;
theParser.setBuffer( buffer, size );
if( !theParser.parse() ) {
std::cerr << "Error while parsing file " << filename << "." << std::endl;
return Error;
}
}
return 0;
}
```
How to access the imported data
===============================
The data is organized as a tree. You can get the root-node of the tree with the following code:
```cpp
OpenDDLParser theParser;
theParser.setBuffer( buffer, size );
const bool result( theParser.parse() );
if ( result ) {
DDLNode *root = theParser.getRoot();
DDLNode::DllNodeList children = root->getChildNodeList();
for ( size_t i=0; i<children.size(); i++ ) {
DDLNode *child = children[ i ];
Property *prop = child->getProperty(); // to get properties
std::string type = child->getType(); // to get the node type
Value *values = child->getValue(); // to get the data;
// to loop through all values
while ( values != ddl_nullptr ) {
int current = values->getInt32();
values = value->getNext();
}
}
}
```
The node instance called root contains the data.
All data lists are organized as linked lists.
Reference documentation
=======================
Please check http://kimkulling.github.io/openddl-parser/doxygen_html/index.html.
Projects using OpenDDL-Parser
=============================
- Asset Importer Lib: https://github.com/assimp/assimp .

227
assimp/contrib/openddlparser/code/DDLNode.cpp Normal file
View file

@ -0,0 +1,227 @@
/*-----------------------------------------------------------------------------------------------
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.
-----------------------------------------------------------------------------------------------*/
#include <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLParser.h>
#include <openddlparser/OpenDDLStream.h>
#include <algorithm>
BEGIN_ODDLPARSER_NS
DDLNode::DllNodeList DDLNode::s_allocatedNodes;
template <class T>
inline static void releaseDataType(T *ptr) {
if (nullptr == ptr) {
return;
}
T *current(nullptr);
while (ptr) {
current = ptr;
ptr = ptr->m_next;
delete current;
}
}
static void releaseReferencedNames(Reference *ref) {
if (nullptr == ref) {
return;
}
delete ref;
}
DDLNode::DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent) :
m_type(type),
m_name(name),
m_parent(parent),
m_children(),
m_properties(nullptr),
m_value(nullptr),
m_dtArrayList(nullptr),
m_references(nullptr),
m_idx(idx) {
if (m_parent) {
m_parent->m_children.push_back(this);
}
}
DDLNode::~DDLNode() {
delete m_properties;
delete m_value;
releaseReferencedNames(m_references);
delete m_dtArrayList;
m_dtArrayList = nullptr;
if (s_allocatedNodes[m_idx] == this) {
s_allocatedNodes[m_idx] = nullptr;
}
for (size_t i = 0; i < m_children.size(); i++) {
delete m_children[i];
}
}
void DDLNode::attachParent(DDLNode *parent) {
if (m_parent == parent) {
return;
}
m_parent = parent;
if (nullptr != m_parent) {
m_parent->m_children.push_back(this);
}
}
void DDLNode::detachParent() {
if (nullptr != m_parent) {
DDLNodeIt it = std::find(m_parent->m_children.begin(), m_parent->m_children.end(), this);
if (m_parent->m_children.end() != it) {
m_parent->m_children.erase(it);
}
m_parent = nullptr;
}
}
DDLNode *DDLNode::getParent() const {
return m_parent;
}
const DDLNode::DllNodeList &DDLNode::getChildNodeList() const {
return m_children;
}
void DDLNode::setType(const std::string &type) {
m_type = type;
}
const std::string &DDLNode::getType() const {
return m_type;
}
void DDLNode::setName(const std::string &name) {
m_name = name;
}
const std::string &DDLNode::getName() const {
return m_name;
}
void DDLNode::setProperties(Property *prop) {
if (m_properties != nullptr)
delete m_properties;
m_properties = prop;
}
Property *DDLNode::getProperties() const {
return m_properties;
}
bool DDLNode::hasProperty(const std::string &name) {
const Property *prop(findPropertyByName(name));
return (nullptr != prop);
}
bool DDLNode::hasProperties() const {
return (nullptr != m_properties);
}
Property *DDLNode::findPropertyByName(const std::string &name) {
if (name.empty()) {
return nullptr;
}
if (nullptr == m_properties) {
return nullptr;
}
Property *current(m_properties);
while (nullptr != current) {
int res = strncmp(current->m_key->m_buffer, name.c_str(), name.size());
if (0 == res) {
return current;
}
current = current->m_next;
}
return nullptr;
}
void DDLNode::setValue(Value *val) {
m_value = val;
}
Value *DDLNode::getValue() const {
return m_value;
}
void DDLNode::setDataArrayList(DataArrayList *dtArrayList) {
m_dtArrayList = dtArrayList;
}
DataArrayList *DDLNode::getDataArrayList() const {
return m_dtArrayList;
}
void DDLNode::setReferences(Reference *refs) {
m_references = refs;
}
Reference *DDLNode::getReferences() const {
return m_references;
}
void DDLNode::dump(IOStreamBase &stream) {
if (!stream.isOpen()) {
return;
}
const std::string &type = this->getType();
stream.write("type = " + type);
Value::Iterator it(getValue());
while (it.hasNext()) {
Value *v = it.getNext();
v->dump(stream);
}
}
DDLNode *DDLNode::create(const std::string &type, const std::string &name, DDLNode *parent) {
const size_t idx(s_allocatedNodes.size());
DDLNode *node = new DDLNode(type, name, idx, parent);
s_allocatedNodes.push_back(node);
return node;
}
void DDLNode::releaseNodes() {
if (s_allocatedNodes.size() > 0) {
for (DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++) {
if (*it) {
delete *it;
}
}
s_allocatedNodes.clear();
}
}
END_ODDLPARSER_NS

200
assimp/contrib/openddlparser/code/OpenDDLCommon.cpp Normal file
View file

@ -0,0 +1,200 @@
/*-----------------------------------------------------------------------------------------------
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.
-----------------------------------------------------------------------------------------------*/
#include <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLCommon.h>
#include <openddlparser/Value.h>
BEGIN_ODDLPARSER_NS
Text::Text(const char *buffer, size_t numChars) :
m_capacity(0),
m_len(0),
m_buffer(nullptr) {
set(buffer, numChars);
}
Text::~Text() {
clear();
}
void Text::clear() {
delete[] m_buffer;
m_buffer = nullptr;
m_capacity = 0;
m_len = 0;
}
void Text::set(const char *buffer, size_t numChars) {
clear();
if (numChars > 0) {
m_len = numChars;
m_capacity = m_len + 1;
m_buffer = new char[m_capacity];
strncpy(m_buffer, buffer, numChars);
m_buffer[numChars] = '\0';
}
}
bool Text::operator==(const std::string &name) const {
if (m_len != name.size()) {
return false;
}
const int res(strncmp(m_buffer, name.c_str(), name.size()));
return (0 == res);
}
bool Text::operator==(const Text &rhs) const {
if (m_len != rhs.m_len) {
return false;
}
const int res(strncmp(m_buffer, rhs.m_buffer, m_len));
return (0 == res);
}
Name::Name(NameType type, Text *id) :
m_type(type), m_id(id) {
// empty
}
Name::~Name() {
delete m_id;
m_id = nullptr;
}
Name::Name(const Name &name) {
m_type = name.m_type;
m_id = new Text(name.m_id->m_buffer, name.m_id->m_len);
}
Reference::Reference() :
m_numRefs(0), m_referencedName(nullptr) {
// empty
}
Reference::Reference(size_t numrefs, Name **names) :
m_numRefs(numrefs), m_referencedName(nullptr) {
if (numrefs > 0) {
m_referencedName = new Name *[numrefs];
for (size_t i = 0; i < numrefs; i++) {
m_referencedName[i] = names[i];
}
}
}
Reference::Reference(const Reference &ref) {
m_numRefs = ref.m_numRefs;
if (m_numRefs != 0) {
m_referencedName = new Name *[m_numRefs];
for (size_t i = 0; i < m_numRefs; i++) {
m_referencedName[i] = new Name(*ref.m_referencedName[i]);
}
}
}
Reference::~Reference() {
for (size_t i = 0; i < m_numRefs; i++) {
delete m_referencedName[i];
}
m_numRefs = 0;
delete[] m_referencedName;
m_referencedName = nullptr;
}
size_t Reference::sizeInBytes() {
if (0 == m_numRefs) {
return 0;
}
size_t size(0);
for (size_t i = 0; i < m_numRefs; i++) {
Name *name(m_referencedName[i]);
if (nullptr != name) {
size += name->m_id->m_len;
}
}
return size;
}
Property::Property(Text *id) :
m_key(id), m_value(nullptr), m_ref(nullptr), m_next(nullptr) {
// empty
}
Property::~Property() {
delete m_key;
if (m_value != nullptr)
delete m_value;
if (m_ref != nullptr)
delete (m_ref);
if (m_next != nullptr)
delete m_next;
}
DataArrayList::DataArrayList() :
m_numItems(0), m_dataList(nullptr), m_next(nullptr), m_refs(nullptr), m_numRefs(0) {
// empty
}
DataArrayList::~DataArrayList() {
delete m_dataList;
if (m_next != nullptr)
delete m_next;
if (m_refs != nullptr)
delete m_refs;
}
size_t DataArrayList::size() {
size_t result(0);
if (nullptr == m_next) {
if (m_dataList != nullptr) {
result = 1;
}
return result;
}
DataArrayList *n(m_next);
while (nullptr != n) {
result++;
n = n->m_next;
}
return result;
}
Context::Context() :
m_root(nullptr) {
// empty
}
Context::~Context() {
clear();
}
void Context::clear() {
delete m_root;
m_root = nullptr;
}
END_ODDLPARSER_NS

362
assimp/contrib/openddlparser/code/OpenDDLExport.cpp Normal file
View file

@ -0,0 +1,362 @@
/*-----------------------------------------------------------------------------------------------
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.
-----------------------------------------------------------------------------------------------*/
#include <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLExport.h>
#include <openddlparser/OpenDDLParser.h>
#include <openddlparser/Value.h>
#include <sstream>
BEGIN_ODDLPARSER_NS
struct DDLNodeIterator {
const DDLNode::DllNodeList &m_childs;
size_t m_idx;
DDLNodeIterator(const DDLNode::DllNodeList &childs) :
m_childs(childs), m_idx(0) {
// empty
}
~DDLNodeIterator() {
// empty
}
bool getNext(DDLNode **node) {
if (m_childs.size() > (m_idx + 1)) {
m_idx++;
*node = m_childs[m_idx];
return true;
}
return false;
}
private:
DDLNodeIterator() ddl_no_copy;
DDLNodeIterator &operator=(const DDLNodeIterator &) ddl_no_copy;
};
static void writeLineEnd(std::string &statement) {
statement += "\n";
}
OpenDDLExport::OpenDDLExport(IOStreamBase *stream) :
m_stream(stream) {
if (nullptr == m_stream) {
m_stream = new IOStreamBase();
}
}
OpenDDLExport::~OpenDDLExport() {
if (nullptr != m_stream) {
m_stream->close();
}
delete m_stream;
}
bool OpenDDLExport::exportContext(Context *ctx, const std::string &filename) {
if (nullptr == ctx) {
return false;
}
DDLNode *root(ctx->m_root);
if (nullptr == root) {
return true;
}
if (!filename.empty()) {
if (!m_stream->open(filename)) {
return false;
}
}
const bool retValue(handleNode(root));
return retValue;
}
bool OpenDDLExport::handleNode(DDLNode *node) {
if (nullptr == node) {
return true;
}
const DDLNode::DllNodeList &childs = node->getChildNodeList();
if (childs.empty()) {
return true;
}
DDLNode *current(nullptr);
DDLNodeIterator it(childs);
std::string statement;
bool success(true);
while (it.getNext(&current)) {
if (nullptr != current) {
success |= writeNode(current, statement);
if (!handleNode(current)) {
success = false;
}
}
}
return success;
}
bool OpenDDLExport::writeToStream(const std::string &statement) {
if (nullptr == m_stream) {
return false;
}
if (!statement.empty()) {
m_stream->write(statement);
}
return true;
}
bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) {
bool success(true);
writeNodeHeader(node, statement);
if (node->hasProperties()) {
success = writeProperties(node, statement);
}
writeLineEnd(statement);
statement = "}";
DataArrayList *al(node->getDataArrayList());
if (nullptr != al) {
writeValueType(al->m_dataList->m_type, al->m_numItems, statement);
writeValueArray(al, statement);
}
Value *v(node->getValue());
if (nullptr != v) {
writeValueType(v->m_type, 1, statement);
statement = "{";
writeLineEnd(statement);
writeValue(v, statement);
statement = "}";
writeLineEnd(statement);
}
statement = "}";
writeLineEnd(statement);
writeToStream(statement);
return success;
}
bool OpenDDLExport::writeNodeHeader(DDLNode *node, std::string &statement) {
if (nullptr == node) {
return false;
}
statement += node->getType();
const std::string &name(node->getName());
if (!name.empty()) {
statement += " ";
statement += "$";
statement += name;
}
return true;
}
bool OpenDDLExport::writeProperties(DDLNode *node, std::string &statement) {
if (nullptr == node) {
return false;
}
Property *prop(node->getProperties());
// if no properties are there, return
if (nullptr == prop) {
return true;
}
if (nullptr != prop) {
// for instance (attrib = "position", bla=2)
statement += "(";
bool first(true);
while (nullptr != prop) {
if (!first) {
statement += ", ";
} else {
first = false;
}
statement += std::string(prop->m_key->m_buffer);
statement += " = ";
writeValue(prop->m_value, statement);
prop = prop->m_next;
}
statement += ")";
}
return true;
}
bool OpenDDLExport::writeValueType(Value::ValueType type, size_t numItems, std::string &statement) {
if (Value::ValueType::ddl_types_max == type) {
return false;
}
const std::string typeStr(getTypeToken(type));
statement += typeStr;
// if we have an array to write
if (numItems > 1) {
statement += "[";
char buffer[256];
::memset(buffer, '\0', 256 * sizeof(char));
snprintf(buffer, sizeof(buffer), "%d", static_cast<int>(numItems));
statement += buffer;
statement += "]";
}
return true;
}
bool OpenDDLExport::writeValue(Value *val, std::string &statement) {
if (nullptr == val) {
return false;
}
switch (val->m_type) {
case Value::ValueType::ddl_bool:
if (true == val->getBool()) {
statement += "true";
} else {
statement += "false";
}
break;
case Value::ValueType::ddl_int8 : {
std::stringstream stream;
const int i = static_cast<int>(val->getInt8());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_int16: {
std::stringstream stream;
char buffer[256];
::memset(buffer, '\0', 256 * sizeof(char));
snprintf(buffer, sizeof(buffer), "%d", val->getInt16());
statement += buffer;
} break;
case Value::ValueType::ddl_int32: {
std::stringstream stream;
char buffer[256];
::memset(buffer, '\0', 256 * sizeof(char));
const int i = static_cast<int>(val->getInt32());
snprintf(buffer, sizeof(buffer), "%d", i);
statement += buffer;
} break;
case Value::ValueType::ddl_int64: {
std::stringstream stream;
const int i = static_cast<int>(val->getInt64());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_unsigned_int8: {
std::stringstream stream;
const int i = static_cast<unsigned int>(val->getUnsignedInt8());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_unsigned_int16: {
std::stringstream stream;
const int i = static_cast<unsigned int>(val->getUnsignedInt16());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_unsigned_int32: {
std::stringstream stream;
const int i = static_cast<unsigned int>(val->getUnsignedInt32());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_unsigned_int64: {
std::stringstream stream;
const int i = static_cast<unsigned int>(val->getUnsignedInt64());
stream << i;
statement += stream.str();
} break;
case Value::ValueType::ddl_half:
break;
case Value::ValueType::ddl_float: {
std::stringstream stream;
stream << val->getFloat();
statement += stream.str();
} break;
case Value::ValueType::ddl_double: {
std::stringstream stream;
stream << val->getDouble();
statement += stream.str();
} break;
case Value::ValueType::ddl_string: {
std::stringstream stream;
stream << val->getString();
statement += "\"";
statement += stream.str();
statement += "\"";
} break;
case Value::ValueType::ddl_ref:
break;
case Value::ValueType::ddl_none:
case Value::ValueType::ddl_types_max:
default:
break;
}
return true;
}
bool OpenDDLExport::writeValueArray(DataArrayList *al, std::string &statement) {
if (nullptr == al) {
return false;
}
if (0 == al->m_numItems) {
return true;
}
DataArrayList *nextDataArrayList = al;
Value *nextValue(nextDataArrayList->m_dataList);
while (nullptr != nextDataArrayList) {
if (nullptr != nextDataArrayList) {
statement += "{ ";
nextValue = nextDataArrayList->m_dataList;
size_t idx(0);
while (nullptr != nextValue) {
if (idx > 0) {
statement += ", ";
}
writeValue(nextValue, statement);
nextValue = nextValue->m_next;
idx++;
}
statement += " }";
}
nextDataArrayList = nextDataArrayList->m_next;
}
return true;
}
END_ODDLPARSER_NS

1058
assimp/contrib/openddlparser/code/OpenDDLParser.cpp Normal file
View file

File diff suppressed because it is too large Load diff

96
assimp/contrib/openddlparser/code/OpenDDLStream.cpp Normal file
View file

@ -0,0 +1,96 @@
/*-----------------------------------------------------------------------------------------------
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.
-----------------------------------------------------------------------------------------------*/
#include <openddlparser/OpenDDLStream.h>
BEGIN_ODDLPARSER_NS
StreamFormatterBase::StreamFormatterBase() {
// empty
}
StreamFormatterBase::~StreamFormatterBase() {
// empty
}
std::string StreamFormatterBase::format(const std::string &statement) {
std::string tmp(statement);
return tmp;
}
IOStreamBase::IOStreamBase(StreamFormatterBase *formatter) :
m_formatter(formatter),
m_file(nullptr) {
if (nullptr == m_formatter) {
m_formatter = new StreamFormatterBase;
}
}
IOStreamBase::~IOStreamBase() {
delete m_formatter;
m_formatter = nullptr;
}
bool IOStreamBase::open(const std::string &name) {
m_file = ::fopen(name.c_str(), "a");
if (m_file == nullptr) {
return false;
}
return true;
}
bool IOStreamBase::close() {
if (nullptr == m_file) {
return false;
}
::fclose(m_file);
m_file = nullptr;
return true;
}
bool IOStreamBase::isOpen() const {
return (nullptr != m_file);
}
size_t IOStreamBase::read(size_t sizeToRead, std::string &statement) {
if (nullptr == m_file) {
return 0;
}
statement.resize(sizeToRead);
const size_t readBytes = ::fread(&statement[0], 1, sizeToRead, m_file);
return readBytes;
}
size_t IOStreamBase::write(const std::string &statement) {
if (nullptr == m_file) {
return 0;
}
std::string formatStatement = m_formatter->format(statement);
return ::fwrite(formatStatement.c_str(), sizeof(char), formatStatement.size(), m_file);
}
END_ODDLPARSER_NS

438
assimp/contrib/openddlparser/code/Value.cpp Normal file
View file

@ -0,0 +1,438 @@
/*-----------------------------------------------------------------------------------------------
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.
-----------------------------------------------------------------------------------------------*/
#include <openddlparser/OpenDDLStream.h>
#include <openddlparser/Value.h>
#include <cassert>
BEGIN_ODDLPARSER_NS
static Value::Iterator end(nullptr);
Value::Iterator::Iterator() :
m_start(nullptr),
m_current(nullptr) {
// empty
}
Value::Iterator::Iterator(Value *start) :
m_start(start),
m_current(start) {
// empty
}
Value::Iterator::Iterator(const Iterator &rhs) :
m_start(rhs.m_start),
m_current(rhs.m_current) {
// empty
}
Value::Iterator::~Iterator() {
// empty
}
bool Value::Iterator::hasNext() const {
if (nullptr == m_current) {
return false;
}
return (nullptr != m_current->getNext());
}
Value *Value::Iterator::getNext() {
if (!hasNext()) {
return nullptr;
}
Value *v(m_current->getNext());
m_current = v;
return v;
}
const Value::Iterator Value::Iterator::operator++(int) {
if (nullptr == m_current) {
return end;
}
m_current = m_current->getNext();
Iterator inst(m_current);
return inst;
}
Value::Iterator &Value::Iterator::operator++() {
if (nullptr == m_current) {
return end;
}
m_current = m_current->getNext();
return *this;
}
bool Value::Iterator::operator==(const Iterator &rhs) const {
return (m_current == rhs.m_current);
}
Value *Value::Iterator::operator->() const {
if (nullptr == m_current) {
return nullptr;
}
return m_current;
}
Value::Value(ValueType type) :
m_type(type),
m_size(0),
m_data(nullptr),
m_next(nullptr) {
// empty
}
Value::~Value() {
if (m_data != nullptr) {
if (m_type == ValueType::ddl_ref) {
Reference *tmp = (Reference *)m_data;
if (tmp != nullptr) {
delete tmp;
}
} else {
delete[] m_data;
}
}
delete m_next;
}
void Value::setBool(bool value) {
assert(ValueType::ddl_bool == m_type);
::memcpy(m_data, &value, m_size);
}
bool Value::getBool() {
assert(ValueType::ddl_bool == m_type);
return (*m_data == 1);
}
void Value::setInt8(int8 value) {
assert(ValueType::ddl_int8 == m_type);
::memcpy(m_data, &value, m_size);
}
int8 Value::getInt8() {
assert(ValueType::ddl_int8 == m_type);
return (int8)(*m_data);
}
void Value::setInt16(int16 value) {
assert(ValueType::ddl_int16 == m_type);
::memcpy(m_data, &value, m_size);
}
int16 Value::getInt16() {
assert(ValueType::ddl_int16 == m_type);
int16 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setInt32(int32 value) {
assert(ValueType::ddl_int32 == m_type);
::memcpy(m_data, &value, m_size);
}
int32 Value::getInt32() {
assert(ValueType::ddl_int32 == m_type);
int32 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setInt64(int64 value) {
assert(ValueType::ddl_int64 == m_type);
::memcpy(m_data, &value, m_size);
}
int64 Value::getInt64() {
assert(ValueType::ddl_int64 == m_type);
int64 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setUnsignedInt8(uint8 value) {
assert(ValueType::ddl_unsigned_int8 == m_type);
::memcpy(m_data, &value, m_size);
}
uint8 Value::getUnsignedInt8() const {
assert(ValueType::ddl_unsigned_int8 == m_type);
uint8 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setUnsignedInt16(uint16 value) {
assert(ValueType::ddl_unsigned_int16 == m_type);
::memcpy(m_data, &value, m_size);
}
uint16 Value::getUnsignedInt16() const {
assert(ValueType::ddl_unsigned_int16 == m_type);
uint16 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setUnsignedInt32(uint32 value) {
assert(ValueType::ddl_unsigned_int32 == m_type);
::memcpy(m_data, &value, m_size);
}
uint32 Value::getUnsignedInt32() const {
assert(ValueType::ddl_unsigned_int32 == m_type);
uint32 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setUnsignedInt64(uint64 value) {
assert(ValueType::ddl_unsigned_int64 == m_type);
::memcpy(m_data, &value, m_size);
}
uint64 Value::getUnsignedInt64() const {
assert(ValueType::ddl_unsigned_int64 == m_type);
uint64 i;
::memcpy(&i, m_data, m_size);
return i;
}
void Value::setFloat(float value) {
assert(ValueType::ddl_float == m_type);
::memcpy(m_data, &value, m_size);
}
float Value::getFloat() const {
if (m_type == ValueType::ddl_float) {
float v;
::memcpy(&v, m_data, m_size);
return (float)v;
} else {
float tmp;
::memcpy(&tmp, m_data, 4);
return (float)tmp;
}
}
void Value::setDouble(double value) {
assert(ValueType::ddl_double == m_type);
::memcpy(m_data, &value, m_size);
}
double Value::getDouble() const {
if (m_type == ValueType::ddl_double) {
double v;
::memcpy(&v, m_data, m_size);
return (float)v;
} else {
double tmp;
::memcpy(&tmp, m_data, 4);
return (double)tmp;
}
}
void Value::setString(const std::string &str) {
assert(ValueType::ddl_string == m_type);
::memcpy(m_data, str.c_str(), str.size());
m_data[str.size()] = '\0';
}
const char *Value::getString() const {
assert(ValueType::ddl_string == m_type);
return (const char *)m_data;
}
void Value::setRef(Reference *ref) {
assert(ValueType::ddl_ref == m_type);
if (nullptr != ref) {
const size_t sizeInBytes(ref->sizeInBytes());
if (sizeInBytes > 0) {
if (nullptr != m_data) {
delete[] m_data;
}
m_data = (unsigned char *)new Reference(*ref);
}
}
}
Reference *Value::getRef() const {
assert(ValueType::ddl_ref == m_type);
return (Reference *)m_data;
}
void Value::dump(IOStreamBase &stream) {
switch (m_type) {
case ValueType::ddl_none:
stream.write("None\n");
break;
case ValueType::ddl_bool:
stream.write(std::to_string(getBool()) + "\n");
break;
case ValueType::ddl_int8:
stream.write(std::to_string(getInt8()) + "\n");
break;
case ValueType::ddl_int16:
stream.write(std::to_string(getInt16()) + "\n");
break;
case ValueType::ddl_int32:
stream.write(std::to_string(getInt32()) + "\n");
break;
case ValueType::ddl_int64:
stream.write(std::to_string(getInt64()) + "\n");
break;
case ValueType::ddl_unsigned_int8:
stream.write("Not supported\n");
break;
case ValueType::ddl_unsigned_int16:
stream.write("Not supported\n");
break;
case ValueType::ddl_unsigned_int32:
stream.write("Not supported\n");
break;
case ValueType::ddl_unsigned_int64:
stream.write("Not supported\n");
break;
case ValueType::ddl_half:
stream.write("Not supported\n");
break;
case ValueType::ddl_float:
stream.write(std::to_string(getFloat()) + "\n");
break;
case ValueType::ddl_double:
stream.write(std::to_string(getDouble()) + "\n");
break;
case ValueType::ddl_string:
stream.write(std::string(getString()) + "\n");
break;
case ValueType::ddl_ref:
stream.write("Not supported\n");
break;
default:
break;
}
}
void Value::setNext(Value *next) {
m_next = next;
}
Value *Value::getNext() const {
return m_next;
}
size_t Value::size() const {
size_t result = 1;
Value *n = m_next;
while (n != nullptr) {
result++;
n = n->m_next;
}
return result;
}
Value *ValueAllocator::allocPrimData(Value::ValueType type, size_t len) {
if (type == Value::ValueType::ddl_none || Value::ValueType::ddl_types_max == type) {
return nullptr;
}
Value *data = new Value(type);
switch (type) {
case Value::ValueType::ddl_bool:
data->m_size = sizeof(bool);
break;
case Value::ValueType::ddl_int8:
data->m_size = sizeof(int8);
break;
case Value::ValueType::ddl_int16:
data->m_size = sizeof(int16);
break;
case Value::ValueType::ddl_int32:
data->m_size = sizeof(int32);
break;
case Value::ValueType::ddl_int64:
data->m_size = sizeof(int64);
break;
case Value::ValueType::ddl_unsigned_int8:
data->m_size = sizeof(uint8);
break;
case Value::ValueType::ddl_unsigned_int16:
data->m_size = sizeof(uint16);
break;
case Value::ValueType::ddl_unsigned_int32:
data->m_size = sizeof(uint32);
break;
case Value::ValueType::ddl_unsigned_int64:
data->m_size = sizeof(uint64);
break;
case Value::ValueType::ddl_half:
data->m_size = sizeof(short);
break;
case Value::ValueType::ddl_float:
data->m_size = sizeof(float);
break;
case Value::ValueType::ddl_double:
data->m_size = sizeof(double);
break;
case Value::ValueType::ddl_string:
data->m_size = sizeof(char) * (len + 1);
break;
case Value::ValueType::ddl_ref:
data->m_size = 0;
break;
case Value::ValueType::ddl_none:
case Value::ValueType::ddl_types_max:
default:
break;
}
if (data->m_size) {
data->m_data = new unsigned char[data->m_size];
::memset(data->m_data, 0, data->m_size);
}
return data;
}
void ValueAllocator::releasePrimData(Value **data) {
if (!data) {
return;
}
delete *data;
*data = nullptr;
}
END_ODDLPARSER_NS

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