diff options
Diffstat (limited to 'NvCloth/samples/external/assimp-4.1.0/code/STEPFile.h')
| -rw-r--r-- | NvCloth/samples/external/assimp-4.1.0/code/STEPFile.h | 1019 |
1 files changed, 1019 insertions, 0 deletions
diff --git a/NvCloth/samples/external/assimp-4.1.0/code/STEPFile.h b/NvCloth/samples/external/assimp-4.1.0/code/STEPFile.h new file mode 100644 index 0000000..8a30beb --- /dev/null +++ b/NvCloth/samples/external/assimp-4.1.0/code/STEPFile.h @@ -0,0 +1,1019 @@ +/* +Open Asset Import Library (assimp) +---------------------------------------------------------------------- + +Copyright (c) 2006-2017, 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 <memory> +#include <typeinfo> +#include <vector> +#include <map> +#include <set> + +#include "FBXDocument.h" //ObjectMap::value_type +#include <assimp/DefaultLogger.hpp> + +// +#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 _MSC_VER > 1600 +# define step_unordered_map unordered_map +# define step_unordered_multimap unordered_multimap +# else +# define step_unordered_map tr1::unordered_map +# define step_unordered_multimap tr1::unordered_multimap +# endif +#endif + +#include "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; + } + + struct HeaderInfo; + class Object; + class LazyObject; + class DB; + + + typedef Object* (*ConvertObjectProc)(const DB& db, const EXPRESS::LIST& params); +} + +// ******************************************************************************** + +namespace STEP { + + // ------------------------------------------------------------------------------- + /** Exception class used by the STEP loading & parsing code. It is typically + * coupled with a line number. */ + // ------------------------------------------------------------------------------- + struct SyntaxError : DeadlyImportError { + enum { + LINE_NOT_SPECIFIED = 0xffffffffffffffffLL + }; + + 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 { + ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL + }; + + 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; + + public: + + PrimitiveDataType() {} + PrimitiveDataType(const T& val) + : val(val) + {} + + PrimitiveDataType(const PrimitiveDataType& o) { + (*this) = o; + } + + + public: + + 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) + { + } + + 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; + }; + + + // ------------------------------------------------------------------------------- + /* 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) + : name(name) + , func(func) + {} + + const char* name; + ConvertObjectProc func; + }; + + typedef std::map<std::string,ConvertObjectProc> ConverterMap; + + public: + + template <size_t N> + explicit ConversionSchema( const SchemaEntry (& schemas)[N]) { + *this = schemas; + } + + ConversionSchema() {} + + public: + + ConvertObjectProc GetConverterProc(const std::string& name) const { + ConverterMap::const_iterator it = converters.find(name); + return it == converters.end() ? NULL : (*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() ? NULL : (*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.name] = schema.func; + } + return *this; + } + + private: + + ConverterMap converters; + }; + } + + + + // ------------------------------------------------------------------------------ + /** 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 + } + + public: + + // 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); + } + + public: + 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) {} + + 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() {} + explicit Maybe(const T& ptr) : ptr(ptr), have(true) { + } + + + 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(); + + public: + + 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==( 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 = NULL) : obj(obj) { + } + + 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(); + } + }; + + 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? + if (max_cnt && inp->GetSize() > max_cnt) { + DefaultLogger::get()->warn("too many aggregate elements"); + } + else if (inp->GetSize() < min_cnt) { + DefaultLogger::get()->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(std::shared_ptr<StreamReaderLE> reader) + : reader(reader) + , splitter(*reader,true,true) + , evaluated_count() + , schema( NULL ) + {} + + public: + + ~DB() { + for(ObjectMap::value_type& o : objects) { + delete o.second; + } + } + + public: + + 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 NULL; + } + + + // 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; + }; + +} + +} // end Assimp + +#endif // INCLUDED_AI_STEPFILE_H |