path: root/src/mesh/assimp-master/code/AssetLib/Step/STEPFile.h

/*
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