switch to tinyobj and nanovg from assimp and cairo

1 files changed, 0 insertions, 971 deletions

diff --git a/libs/assimp/code/AssetLib/Step/STEPFile.h b/libs/assimp/code/AssetLib/Step/STEPFile.h
deleted file mode 100644
index e09faad..0000000
--- a/libs/assimp/code/AssetLib/Step/STEPFile.h
+++ /dev/null
@@ -1,971 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef INCLUDED_AI_STEPFILE_H
-#define INCLUDED_AI_STEPFILE_H
-
-#include <bitset>
-#include <map>
-#include <memory>
-#include <set>
-#include <typeinfo>
-#include <vector>
-
-#include "AssetLib/FBX/FBXDocument.h" //ObjectMap::value_type
-
-#include <assimp/DefaultLogger.hpp>
-
-#ifdef _MSC_VER
-#    pragma warning(push)
-#    pragma warning(disable : 4127 4456 4245 4512 )
-#endif // _MSC_VER
-
-//
-#if _MSC_VER > 1500 || (defined __GNUC___)
-#    define ASSIMP_STEP_USE_UNORDERED_MULTIMAP
-#else
-#    define step_unordered_map map
-#    define step_unordered_multimap multimap
-#endif
-
-#ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP
-#    include <unordered_map>
-#    if defined(_MSC_VER) && _MSC_VER <= 1600
-#        define step_unordered_map tr1::unordered_map
-#        define step_unordered_multimap tr1::unordered_multimap
-#    else
-#        define step_unordered_map unordered_map
-#        define step_unordered_multimap unordered_multimap
-#    endif
-#endif
-
-#include <assimp/LineSplitter.h>
-
-// uncomment this to have the loader evaluate all entities upon loading.
-// this is intended as stress test - by default, entities are evaluated
-// lazily and therefore not unless needed.
-
-//#define ASSIMP_IFC_TEST
-
-namespace Assimp {
-
-// ********************************************************************************
-// before things get complicated, this is the basic outline:
-
-namespace STEP {
-
-namespace EXPRESS {
-
-// base data types known by EXPRESS schemata - any custom data types will derive one of those
-class DataType;
-class UNSET; /*: public DataType */
-class ISDERIVED; /*: public DataType */
-//  class REAL;         /*: public DataType */
-class ENUM; /*: public DataType */
-//  class STRING;       /*: public DataType */
-//  class INTEGER;      /*: public DataType */
-class ENTITY; /*: public DataType */
-class LIST; /*: public DataType */
-//  class SELECT;       /*: public DataType */
-
-// a conversion schema is not exactly an EXPRESS schema, rather it
-// is a list of pointers to conversion functions to build up the
-// object tree from an input file.
-class ConversionSchema;
-} // namespace EXPRESS
-
-struct HeaderInfo;
-class Object;
-class LazyObject;
-class DB;
-
-typedef Object *(*ConvertObjectProc)(const DB &db, const EXPRESS::LIST &params);
-} // namespace STEP
-
-// ********************************************************************************
-
-namespace STEP {
-
-// -------------------------------------------------------------------------------
-/** Exception class used by the STEP loading & parsing code. It is typically
-     *  coupled with a line number. */
-// -------------------------------------------------------------------------------
-struct SyntaxError : DeadlyImportError {
-    enum : uint64_t {
-        LINE_NOT_SPECIFIED = 0xfffffffffffffffLL
-    };
-
-    SyntaxError(const std::string &s, uint64_t line = LINE_NOT_SPECIFIED);
-};
-
-// -------------------------------------------------------------------------------
-/** Exception class used by the STEP loading & parsing code when a type
-     *  error (i.e. an entity expects a string but receives a bool) occurs.
-     *  It is typically coupled with both an entity id and a line number.*/
-// -------------------------------------------------------------------------------
-struct TypeError : DeadlyImportError {
-    enum : uint64_t {
-        ENTITY_NOT_SPECIFIED = 0xffffffffffffffffUL,
-        ENTITY_NOT_SPECIFIED_32 = 0x00000000ffffffff
-    };
-
-    TypeError(const std::string &s, uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED);
-};
-
-// hack to make a given member template-dependent
-template <typename T, typename T2>
-T2 &Couple(T2 &in) {
-    return in;
-}
-
-namespace EXPRESS {
-
-// -------------------------------------------------------------------------------
-//** Base class for all STEP data types */
-// -------------------------------------------------------------------------------
-class DataType {
-public:
-    typedef std::shared_ptr<const DataType> Out;
-
-public:
-    virtual ~DataType() {
-    }
-
-public:
-    template <typename T>
-    const T &To() const {
-        return dynamic_cast<const T &>(*this);
-    }
-
-    template <typename T>
-    T &To() {
-        return dynamic_cast<T &>(*this);
-    }
-
-    template <typename T>
-    const T *ToPtr() const {
-        return dynamic_cast<const T *>(this);
-    }
-
-    template <typename T>
-    T *ToPtr() {
-        return dynamic_cast<T *>(this);
-    }
-
-    // utilities to deal with SELECT entities, which currently lack automatic
-    // conversion support.
-    template <typename T>
-    const T &ResolveSelect(const DB &db) const {
-        return Couple<T>(db).MustGetObject(To<EXPRESS::ENTITY>())->template To<T>();
-    }
-
-    template <typename T>
-    const T *ResolveSelectPtr(const DB &db) const {
-        const EXPRESS::ENTITY *e = ToPtr<EXPRESS::ENTITY>();
-        return e ? Couple<T>(db).MustGetObject(*e)->template ToPtr<T>() : (const T *)0;
-    }
-
-public:
-    /** parse a variable from a string and set 'inout' to the character
-             *  behind the last consumed character. An optional schema enables,
-             *  if specified, automatic conversion of custom data types.
-             *
-             *  @throw SyntaxError
-             */
-    static std::shared_ptr<const EXPRESS::DataType> Parse(const char *&inout,
-            uint64_t line = SyntaxError::LINE_NOT_SPECIFIED,
-            const EXPRESS::ConversionSchema *schema = NULL);
-
-public:
-};
-
-typedef DataType SELECT;
-typedef DataType LOGICAL;
-
-// -------------------------------------------------------------------------------
-/** Sentinel class to represent explicitly unset (optional) fields ($) */
-// -------------------------------------------------------------------------------
-class UNSET : public DataType {
-public:
-private:
-};
-
-// -------------------------------------------------------------------------------
-/** Sentinel class to represent explicitly derived fields (*) */
-// -------------------------------------------------------------------------------
-class ISDERIVED : public DataType {
-public:
-private:
-};
-
-// -------------------------------------------------------------------------------
-/** Shared implementation for some of the primitive data type, i.e. int, float */
-// -------------------------------------------------------------------------------
-template <typename T>
-class PrimitiveDataType : public DataType {
-public:
-    // This is the type that will cd ultimatively be used to
-    // expose this data type to the user.
-    typedef T Out;
-
-    PrimitiveDataType() {}
-    PrimitiveDataType(const T &val) :
-            val(val) {}
-
-    PrimitiveDataType(const PrimitiveDataType &o) {
-        (*this) = o;
-    }
-
-    operator const T &() const {
-        return val;
-    }
-
-    PrimitiveDataType &operator=(const PrimitiveDataType &o) {
-        val = o.val;
-        return *this;
-    }
-
-protected:
-    T val;
-};
-
-typedef PrimitiveDataType<int64_t> INTEGER;
-typedef PrimitiveDataType<double> REAL;
-typedef PrimitiveDataType<double> NUMBER;
-typedef PrimitiveDataType<std::string> STRING;
-
-// -------------------------------------------------------------------------------
-/** Generic base class for all enumerated types */
-// -------------------------------------------------------------------------------
-class ENUMERATION : public STRING {
-public:
-    ENUMERATION(const std::string &val) :
-            STRING(val) {}
-
-private:
-};
-
-typedef ENUMERATION BOOLEAN;
-
-// -------------------------------------------------------------------------------
-/** This is just a reference to an entity/object somewhere else */
-// -------------------------------------------------------------------------------
-class ENTITY : public PrimitiveDataType<uint64_t> {
-public:
-    ENTITY(uint64_t val) :
-            PrimitiveDataType<uint64_t>(val) {
-        ai_assert(val != 0);
-    }
-
-    ENTITY() :
-            PrimitiveDataType<uint64_t>(TypeError::ENTITY_NOT_SPECIFIED) {
-        // empty
-    }
-
-private:
-};
-
-// -------------------------------------------------------------------------------
-/** Wrap any STEP aggregate: LIST, SET, ... */
-// -------------------------------------------------------------------------------
-class LIST : public DataType {
-public:
-    // access a particular list index, throw std::range_error for wrong indices
-    std::shared_ptr<const DataType> operator[](size_t index) const {
-        return members[index];
-    }
-
-    size_t GetSize() const {
-        return members.size();
-    }
-
-public:
-    /** @see DaraType::Parse */
-    static std::shared_ptr<const EXPRESS::LIST> Parse(const char *&inout,
-            uint64_t line = SyntaxError::LINE_NOT_SPECIFIED,
-            const EXPRESS::ConversionSchema *schema = NULL);
-
-private:
-    typedef std::vector<std::shared_ptr<const DataType>> MemberList;
-    MemberList members;
-};
-
-class BINARY : public PrimitiveDataType<uint32_t> {
-public:
-    BINARY(uint32_t val) :
-            PrimitiveDataType<uint32_t>(val) {
-        // empty
-    }
-
-    BINARY() :
-            PrimitiveDataType<uint32_t>(TypeError::ENTITY_NOT_SPECIFIED_32) {
-        // empty
-    }
-};
-
-// -------------------------------------------------------------------------------
-/* Not exactly a full EXPRESS schema but rather a list of conversion functions
-         * to extract valid C++ objects out of a STEP file. Those conversion functions
-         * may, however, perform further schema validations. */
-// -------------------------------------------------------------------------------
-class ConversionSchema {
-public:
-    struct SchemaEntry {
-        SchemaEntry(const char *name, ConvertObjectProc func) :
-                mName(name), mFunc(func) {
-            // empty
-        }
-
-        const char *mName;
-        ConvertObjectProc mFunc;
-    };
-
-    typedef std::map<std::string, ConvertObjectProc> ConverterMap;
-
-    template <size_t N>
-    explicit ConversionSchema(const SchemaEntry (&schemas)[N]) {
-        *this = schemas;
-    }
-
-    ConversionSchema() {
-    }
-
-    ConvertObjectProc GetConverterProc(const std::string &name) const {
-        ConverterMap::const_iterator it = converters.find(name);
-        return it == converters.end() ? nullptr : (*it).second;
-    }
-
-    bool IsKnownToken(const std::string &name) const {
-        return converters.find(name) != converters.end();
-    }
-
-    const char *GetStaticStringForToken(const std::string &token) const {
-        ConverterMap::const_iterator it = converters.find(token);
-        return it == converters.end() ? nullptr : (*it).first.c_str();
-    }
-
-    template <size_t N>
-    const ConversionSchema &operator=(const SchemaEntry (&schemas)[N]) {
-        for (size_t i = 0; i < N; ++i) {
-            const SchemaEntry &schema = schemas[i];
-            converters[schema.mName] = schema.mFunc;
-        }
-        return *this;
-    }
-
-private:
-    ConverterMap converters;
-};
-} // namespace EXPRESS
-
-// ------------------------------------------------------------------------------
-/** Bundle all the relevant info from a STEP header, parts of which may later
-     *  be plainly dumped to the logfile, whereas others may help the caller pick an
-     *  appropriate loading strategy.*/
-// ------------------------------------------------------------------------------
-struct HeaderInfo {
-    std::string timestamp;
-    std::string app;
-    std::string fileSchema;
-};
-
-// ------------------------------------------------------------------------------
-/** Base class for all concrete object instances */
-// ------------------------------------------------------------------------------
-class Object {
-public:
-    Object(const char *classname = "unknown") :
-            id(0), classname(classname) {
-        // empty
-    }
-
-    virtual ~Object() {
-        // empty
-    }
-
-    // utilities to simplify casting to concrete types
-    template <typename T>
-    const T &To() const {
-        return dynamic_cast<const T &>(*this);
-    }
-
-    template <typename T>
-    T &To() {
-        return dynamic_cast<T &>(*this);
-    }
-
-    template <typename T>
-    const T *ToPtr() const {
-        return dynamic_cast<const T *>(this);
-    }
-
-    template <typename T>
-    T *ToPtr() {
-        return dynamic_cast<T *>(this);
-    }
-
-    uint64_t GetID() const {
-        return id;
-    }
-
-    std::string GetClassName() const {
-        return classname;
-    }
-
-    void SetID(uint64_t newval) {
-        id = newval;
-    }
-
-private:
-    uint64_t id;
-    const char *const classname;
-};
-
-template <typename T>
-size_t GenericFill(const STEP::DB &db, const EXPRESS::LIST &params, T *in);
-// (intentionally undefined)
-
-// ------------------------------------------------------------------------------
-/** CRTP shared base class for use by concrete entity implementation classes */
-// ------------------------------------------------------------------------------
-template <typename TDerived, size_t arg_count>
-struct ObjectHelper : virtual Object {
-    ObjectHelper() :
-            aux_is_derived(0) {
-        // empty
-    }
-
-    static Object *Construct(const STEP::DB &db, const EXPRESS::LIST &params) {
-        // make sure we don't leak if Fill() throws an exception
-        std::unique_ptr<TDerived> impl(new TDerived());
-
-        // GenericFill<T> is undefined so we need to have a specialization
-        const size_t num_args = GenericFill<TDerived>(db, params, &*impl);
-        (void)num_args;
-
-        // the following check is commented because it will always trigger if
-        // parts of the entities are generated with dummy wrapper code.
-        // This is currently done to reduce the size of the loader
-        // code.
-        //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") {
-        //  DefaultLogger::get()->debug("STEP: not all parameters consumed");
-        //}
-        return impl.release();
-    }
-
-    // note that this member always exists multiple times within the hierarchy
-    // of an individual object, so any access to it must be disambiguated.
-    std::bitset<arg_count> aux_is_derived;
-};
-
-// ------------------------------------------------------------------------------
-/** Class template used to represent OPTIONAL data members in the converted schema */
-// ------------------------------------------------------------------------------
-template <typename T>
-struct Maybe {
-    Maybe() :
-            have() {
-        // empty
-    }
-
-    explicit Maybe(const T &ptr) :
-            ptr(ptr), have(true) {
-        // empty
-    }
-
-    void flag_invalid() {
-        have = false;
-    }
-
-    void flag_valid() {
-        have = true;
-    }
-
-    bool operator!() const {
-        return !have;
-    }
-
-    operator bool() const {
-        return have;
-    }
-
-    operator const T &() const {
-        return Get();
-    }
-
-    const T &Get() const {
-        ai_assert(have);
-        return ptr;
-    }
-
-    Maybe &operator=(const T &_ptr) {
-        ptr = _ptr;
-        have = true;
-        return *this;
-    }
-
-private:
-    template <typename T2>
-    friend struct InternGenericConvert;
-
-    operator T &() {
-        return ptr;
-    }
-
-    T ptr;
-    bool have;
-};
-
-// ------------------------------------------------------------------------------
-/** A LazyObject is created when needed. Before this happens, we just keep
-       the text line that contains the object definition. */
-// -------------------------------------------------------------------------------
-class LazyObject {
-    friend class DB;
-
-public:
-    LazyObject(DB &db, uint64_t id, uint64_t line, const char *type, const char *args);
-    ~LazyObject();
-
-    Object &operator*() {
-        if (!obj) {
-            LazyInit();
-            ai_assert(obj);
-        }
-        return *obj;
-    }
-
-    const Object &operator*() const {
-        if (!obj) {
-            LazyInit();
-            ai_assert(obj);
-        }
-        return *obj;
-    }
-
-    template <typename T>
-    const T &To() const {
-        return dynamic_cast<const T &>(**this);
-    }
-
-    template <typename T>
-    T &To() {
-        return dynamic_cast<T &>(**this);
-    }
-
-    template <typename T>
-    const T *ToPtr() const {
-        return dynamic_cast<const T *>(&**this);
-    }
-
-    template <typename T>
-    T *ToPtr() {
-        return dynamic_cast<T *>(&**this);
-    }
-
-    Object *operator->() {
-        return &**this;
-    }
-
-    const Object *operator->() const {
-        return &**this;
-    }
-
-    bool operator==(const std::string &atype) const {
-        return type == atype;
-    }
-
-    bool operator!=(const std::string &atype) const {
-        return type != atype;
-    }
-
-    uint64_t GetID() const {
-        return id;
-    }
-
-private:
-    void LazyInit() const;
-
-private:
-    mutable uint64_t id;
-    const char *const type;
-    DB &db;
-    mutable const char *args;
-    mutable Object *obj;
-};
-
-template <typename T>
-inline bool operator==(const std::shared_ptr<LazyObject> &lo, T whatever) {
-    return *lo == whatever; // XXX use std::forward if we have 0x
-}
-
-template <typename T>
-inline bool operator==(const std::pair<uint64_t, std::shared_ptr<LazyObject>> &lo, T whatever) {
-    return *(lo.second) == whatever; // XXX use std::forward if we have 0x
-}
-
-// ------------------------------------------------------------------------------
-/** Class template used to represent lazily evaluated object references in the converted schema */
-// ------------------------------------------------------------------------------
-template <typename T>
-struct Lazy {
-    typedef Lazy Out;
-    Lazy(const LazyObject *obj = nullptr) :
-            obj(obj) {
-        // empty
-    }
-
-    operator const T *() const {
-        return obj->ToPtr<T>();
-    }
-
-    operator const T &() const {
-        return obj->To<T>();
-    }
-
-    const T &operator*() const {
-        return obj->To<T>();
-    }
-
-    const T *operator->() const {
-        return &obj->To<T>();
-    }
-
-    const LazyObject *obj;
-};
-
-// ------------------------------------------------------------------------------
-/** Class template used to represent LIST and SET data members in the converted schema */
-// ------------------------------------------------------------------------------
-template <typename T, uint64_t min_cnt, uint64_t max_cnt = 0uL>
-struct ListOf : public std::vector<typename T::Out> {
-    typedef typename T::Out OutScalar;
-    typedef ListOf Out;
-
-    ListOf() {
-        static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
-    }
-};
-
-// ------------------------------------------------------------------------------
-template <typename TOut>
-struct PickBaseType {
-    typedef EXPRESS::PrimitiveDataType<TOut> Type;
-};
-
-template <typename TOut>
-struct PickBaseType<Lazy<TOut>> {
-    typedef EXPRESS::ENTITY Type;
-};
-
-template <>
-struct PickBaseType<std::shared_ptr<const EXPRESS::DataType>>;
-
-// ------------------------------------------------------------------------------
-template <typename T>
-struct InternGenericConvert {
-    void operator()(T &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
-        try {
-            out = dynamic_cast<const typename PickBaseType<T>::Type &>(*in);
-        } catch (std::bad_cast &) {
-            throw TypeError("type error reading literal field");
-        }
-    }
-};
-
-template <>
-struct InternGenericConvert<std::shared_ptr<const EXPRESS::DataType>> {
-    void operator()(std::shared_ptr<const EXPRESS::DataType> &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB & /*db*/) {
-        out = in;
-    }
-};
-
-template <typename T>
-struct InternGenericConvert<Maybe<T>> {
-    void operator()(Maybe<T> &out, const std::shared_ptr<const EXPRESS::DataType> &in, const STEP::DB &db) {
-        GenericConvert((T &)out, in, db);
-        out.flag_valid();
-    }
-};
-
-#if _MSC_VER > 1920
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif // _WIN32
-
-template <typename T, uint64_t min_cnt, uint64_t max_cnt>
-struct InternGenericConvertList {
-    void operator()(ListOf<T, min_cnt, max_cnt> &out, const std::shared_ptr<const EXPRESS::DataType> &inp_base, const STEP::DB &db) {
-
-        const EXPRESS::LIST *inp = dynamic_cast<const EXPRESS::LIST *>(inp_base.get());
-        if (!inp) {
-            throw TypeError("type error reading aggregate");
-        }
-
-        // XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended?
-        const size_t len = inp->GetSize();
-        if (0 != max_cnt && len > max_cnt) {
-            ASSIMP_LOG_WARN("too many aggregate elements");
-        } else if (len < min_cnt) {
-            ASSIMP_LOG_WARN("too few aggregate elements");
-        }
-
-        out.reserve(inp->GetSize());
-        for (size_t i = 0; i < inp->GetSize(); ++i) {
-
-            out.push_back(typename ListOf<T, min_cnt, max_cnt>::OutScalar());
-            try {
-                GenericConvert(out.back(), (*inp)[i], db);
-            } catch (const TypeError &t) {
-                throw TypeError(t.what() + std::string(" of aggregate"));
-            }
-        }
-    }
-};
-
-template <typename T>
-struct InternGenericConvert<Lazy<T>> {
-    void operator()(Lazy<T> &out, const std::shared_ptr<const EXPRESS::DataType> &in_base, const STEP::DB &db) {
-        const EXPRESS::ENTITY *in = dynamic_cast<const EXPRESS::ENTITY *>(in_base.get());
-        if (!in) {
-            throw TypeError("type error reading entity");
-        }
-        out = Couple<T>(db).GetObject(*in);
-    }
-};
-
-template <typename T1>
-inline void GenericConvert(T1 &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
-    return InternGenericConvert<T1>()(a, b, db);
-}
-
-template <typename T1, uint64_t N1, uint64_t N2>
-inline void GenericConvert(ListOf<T1, N1, N2> &a, const std::shared_ptr<const EXPRESS::DataType> &b, const STEP::DB &db) {
-    return InternGenericConvertList<T1, N1, N2>()(a, b, db);
-}
-
-// ------------------------------------------------------------------------------
-/** Lightweight manager class that holds the map of all objects in a
-     *  STEP file. DB's are exclusively maintained by the functions in
-     *  STEPFileReader.h*/
-// -------------------------------------------------------------------------------
-class DB {
-    friend DB *ReadFileHeader(std::shared_ptr<IOStream> stream);
-    friend void ReadFile(DB &db, const EXPRESS::ConversionSchema &scheme,
-            const char *const *types_to_track, size_t len,
-            const char *const *inverse_indices_to_track, size_t len2);
-
-    friend class LazyObject;
-
-public:
-    // objects indexed by ID - this can grow pretty large (i.e some hundred million
-    // entries), so use raw pointers to avoid *any* overhead.
-    typedef std::map<uint64_t, const LazyObject *> ObjectMap;
-
-    // objects indexed by their declarative type, but only for those that we truly want
-    typedef std::set<const LazyObject *> ObjectSet;
-    typedef std::map<std::string, ObjectSet> ObjectMapByType;
-
-    // list of types for which to keep inverse indices for all references
-    // that the respective objects keep.
-    // the list keeps pointers to strings in static storage
-    typedef std::set<const char *> InverseWhitelist;
-
-    // references - for each object id the ids of all objects which reference it
-    // this is used to simulate STEP inverse indices for selected types.
-    typedef std::step_unordered_multimap<uint64_t, uint64_t> RefMap;
-    typedef std::pair<RefMap::const_iterator, RefMap::const_iterator> RefMapRange;
-
-private:
-    DB(const std::shared_ptr<StreamReaderLE> &reader) :
-            reader(reader), splitter(*reader, true, true), evaluated_count(), schema(nullptr) {}
-
-public:
-    ~DB() {
-        for (ObjectMap::value_type &o : objects) {
-            delete o.second;
-        }
-    }
-
-    uint64_t GetObjectCount() const {
-        return objects.size();
-    }
-
-    uint64_t GetEvaluatedObjectCount() const {
-        return evaluated_count;
-    }
-
-    const HeaderInfo &GetHeader() const {
-        return header;
-    }
-
-    const EXPRESS::ConversionSchema &GetSchema() const {
-        return *schema;
-    }
-
-    const ObjectMap &GetObjects() const {
-        return objects;
-    }
-
-    const ObjectMapByType &GetObjectsByType() const {
-        return objects_bytype;
-    }
-
-    const RefMap &GetRefs() const {
-        return refs;
-    }
-
-    bool KeepInverseIndicesForType(const char *const type) const {
-        return inv_whitelist.find(type) != inv_whitelist.end();
-    }
-
-    // get the yet unevaluated object record with a given id
-    const LazyObject *GetObject(uint64_t id) const {
-        const ObjectMap::const_iterator it = objects.find(id);
-        if (it != objects.end()) {
-            return (*it).second;
-        }
-        return nullptr;
-    }
-
-    // get an arbitrary object out of the soup with the only restriction being its type.
-    const LazyObject *GetObject(const std::string &type) const {
-        const ObjectMapByType::const_iterator it = objects_bytype.find(type);
-        if (it != objects_bytype.end() && (*it).second.size()) {
-            return *(*it).second.begin();
-        }
-        return NULL;
-    }
-
-    // same, but raise an exception if the object doesn't exist and return a reference
-    const LazyObject &MustGetObject(uint64_t id) const {
-        const LazyObject *o = GetObject(id);
-        if (!o) {
-            throw TypeError("requested entity is not present", id);
-        }
-        return *o;
-    }
-
-    const LazyObject &MustGetObject(const std::string &type) const {
-        const LazyObject *o = GetObject(type);
-        if (!o) {
-            throw TypeError("requested entity of type " + type + "is not present");
-        }
-        return *o;
-    }
-
-#ifdef ASSIMP_IFC_TEST
-
-    // evaluate *all* entities in the file. this is a power test for the loader
-    void EvaluateAll() {
-        for (ObjectMap::value_type &e : objects) {
-            **e.second;
-        }
-        ai_assert(evaluated_count == objects.size());
-    }
-
-#endif
-
-private:
-    // full access only offered to close friends - they should
-    // use the provided getters rather than messing around with
-    // the members directly.
-    LineSplitter &GetSplitter() {
-        return splitter;
-    }
-
-    void InternInsert(const LazyObject *lz) {
-        objects[lz->GetID()] = lz;
-
-        const ObjectMapByType::iterator it = objects_bytype.find(lz->type);
-        if (it != objects_bytype.end()) {
-            (*it).second.insert(lz);
-        }
-    }
-
-    void SetSchema(const EXPRESS::ConversionSchema &_schema) {
-        schema = &_schema;
-    }
-
-    void SetTypesToTrack(const char *const *types, size_t N) {
-        for (size_t i = 0; i < N; ++i) {
-            objects_bytype[types[i]] = ObjectSet();
-        }
-    }
-
-    void SetInverseIndicesToTrack(const char *const *types, size_t N) {
-        for (size_t i = 0; i < N; ++i) {
-            const char *const sz = schema->GetStaticStringForToken(types[i]);
-            ai_assert(sz);
-            inv_whitelist.insert(sz);
-        }
-    }
-
-    HeaderInfo &GetHeader() {
-        return header;
-    }
-
-    void MarkRef(uint64_t who, uint64_t by_whom) {
-        refs.insert(std::make_pair(who, by_whom));
-    }
-
-private:
-    HeaderInfo header;
-    ObjectMap objects;
-    ObjectMapByType objects_bytype;
-    RefMap refs;
-    InverseWhitelist inv_whitelist;
-    std::shared_ptr<StreamReaderLE> reader;
-    LineSplitter splitter;
-    uint64_t evaluated_count;
-    const EXPRESS::ConversionSchema *schema;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-} // namespace STEP
-
-} // namespace Assimp
-
-#endif // INCLUDED_AI_STEPFILE_H