.. _program_listing_file_src_ifcparse_IfcParse.h: Program Listing for File IfcParse.h =================================== |exhale_lsh| :ref:`Return to documentation for file ` (``src/ifcparse/IfcParse.h``) .. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS .. code-block:: cpp /******************************************************************************** * * * This file is part of IfcOpenShell. * * * * IfcOpenShell is free software: you can redistribute it and/or modify * * it under the terms of the Lesser GNU General Public License as published by * * the Free Software Foundation, either version 3.0 of the License, or * * (at your option) any later version. * * * * IfcOpenShell is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * Lesser GNU General Public License for more details. * * * * You should have received a copy of the Lesser GNU General Public License * * along with this program. If not, see . * * * ********************************************************************************/ /******************************************************************************** * * * This file provides functions for loading an IFC file into memory and access * * its entities either by ID, by an IfcSchema::Type or by reference * * * ********************************************************************************/ #ifndef IFCPARSE_H #define IFCPARSE_H #define IFCOPENSHELL_VERSION "0.6.0b0" #include #include #include #include #include #include #include #include #include #include "ifc_parse_api.h" #include "../ifcparse/IfcCharacterDecoder.h" #include "../ifcparse/IfcBaseClass.h" #include "../ifcparse/IfcLogger.h" #include "../ifcparse/Argument.h" #include "../ifcparse/IfcSpfStream.h" #if defined(__clang__) # define my_thread_local thread_local #elif defined(__GNUC__) # define my_thread_local __thread #elif __STDC_VERSION__ >= 201112L # define my_thread_local _Thread_local #elif defined(_MSC_VER) # define my_thread_local __declspec(thread) #else # error Cannot define thread_local #endif namespace IfcParse { class IfcFile; class IfcSpfLexer; enum TokenType { Token_NONE, Token_STRING, Token_IDENTIFIER, Token_OPERATOR, Token_ENUMERATION, Token_KEYWORD, Token_INT, Token_BOOL, Token_FLOAT, Token_BINARY }; struct Token { IfcSpfLexer* lexer; //TODO: remove it from here unsigned startPos; TokenType type; union { bool value_bool; //types: BOOL char value_char; //types: OPERATOR int value_int; //types: INT, IDENTIFIER double value_double; //types: FLOAT }; Token() : lexer(0), startPos(0), type(Token_NONE) {} Token(IfcSpfLexer* _lexer, unsigned _startPos, unsigned /*_endPos*/, TokenType _type) : lexer(_lexer), startPos(_startPos), type(_type) {} }; class IFC_PARSE_API TokenFunc { private: static bool startsWith(const Token& t, char c); public: // static unsigned int Offset(const Token& t); static bool isString(const Token& t); static bool isIdentifier(const Token& t); static bool isOperator(const Token& t); static bool isOperator(const Token& t, char op); static bool isEnumeration(const Token& t); static bool isKeyword(const Token& t); static bool isInt(const Token& t); static bool isBool(const Token& t); static bool isFloat(const Token& t); static bool isBinary(const Token& t); static int asInt(const Token& t); static int asIdentifier(const Token& t); static bool asBool(const Token& t); static double asFloat(const Token& t); static std::string asString(const Token& t); static const std::string &asStringRef(const Token& t); static boost::dynamic_bitset<> asBinary(const Token& t); static std::string toString(const Token& t); }; // // Functions for creating Tokens from an arbitary file offset // The first 4 bits are reserved for Tokens of type ()=,;$* // Token OperatorTokenPtr(IfcSpfLexer* tokens, unsigned start, unsigned end); Token GeneralTokenPtr(IfcSpfLexer* tokens, unsigned start, unsigned end); Token NoneTokenPtr(); class IFC_PARSE_API IfcSpfLexer { private: IfcCharacterDecoder* decoder; unsigned int skipWhitespace(); unsigned int skipComment(); public: std::string &GetTempString() const { static my_thread_local std::string s; return s; } IfcSpfStream* stream; IfcFile* file; IfcSpfLexer(IfcSpfStream* s, IfcFile* f); Token Next(); ~IfcSpfLexer(); void TokenString(unsigned int offset, std::string &result); }; class IFC_PARSE_API ArgumentList: public Argument { private: size_t size_; Argument** list_; public: ArgumentList() : size_(0), list_(0) {} ArgumentList(size_t n) : size_(n), list_(new Argument*[size_]) {} ~ArgumentList(); void read(IfcSpfLexer* t, std::vector& ids); IfcUtil::ArgumentType type() const; operator std::vector() const; operator std::vector() const; operator std::vector() const; operator std::vector >() const; operator IfcEntityList::ptr() const; operator std::vector< std::vector >() const; operator std::vector< std::vector >() const; operator IfcEntityListList::ptr() const; bool isNull() const; unsigned int size() const; Argument* operator [] (unsigned int i) const; std::string toString(bool upper=false) const; Argument**& arguments() { return list_; } size_t& size() { return size_; } }; class IFC_PARSE_API NullArgument : public Argument { public: NullArgument() {} IfcUtil::ArgumentType type() const { return IfcUtil::Argument_NULL; } bool isNull() const { return true; } unsigned int size() const { return 1; } Argument* operator [] (unsigned int /*i*/) const { throw IfcException("Argument is not a list of attributes"); } std::string toString(bool /*upper=false*/) const { return "$"; } }; class IFC_PARSE_API TokenArgument : public Argument { private: public: Token token; TokenArgument(const Token& t); IfcUtil::ArgumentType type() const; operator int() const; operator bool() const; operator double() const; operator std::string() const; operator boost::dynamic_bitset<>() const; operator IfcUtil::IfcBaseClass*() const; bool isNull() const; unsigned int size() const; Argument* operator [] (unsigned int i) const; std::string toString(bool upper=false) const; }; class IFC_PARSE_API EntityArgument : public Argument { private: IfcUtil::IfcBaseClass* entity; public: EntityArgument(const Token& t); ~EntityArgument(); IfcUtil::ArgumentType type() const; operator IfcUtil::IfcBaseClass*() const; bool isNull() const; unsigned int size() const; Argument* operator [] (unsigned int i) const; std::string toString(bool upper=false) const; }; IFC_PARSE_API IfcEntityInstanceData* read(unsigned int i, IfcFile* t, boost::optional offset = boost::none); IFC_PARSE_API IfcEntityList::ptr traverse(IfcUtil::IfcBaseClass* instance, int max_level = -1); } IFC_PARSE_API std::ostream& operator<< (std::ostream& os, const IfcParse::IfcFile& f); #endif