Program Listing for File IfcFile.h

↰ Return to documentation for file (src/ifcparse/IfcFile.h)

/********************************************************************************
 *                                                                              *
 * 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 <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

#ifndef IFCFILE_H
#define IFCFILE_H

#include <map>
#include <set>
#include <iterator>
#include <boost/unordered_map.hpp>

#include "ifc_parse_api.h"

#include "../ifcparse/IfcParse.h"
#include "../ifcparse/IfcSpfHeader.h"
#include "../ifcparse/IfcSchema.h"

namespace IfcParse {

class IFC_PARSE_API IfcFile {
public:
    typedef std::map<const IfcParse::declaration*, IfcEntityList::ptr> entities_by_type_t;
    typedef boost::unordered_map<unsigned int, IfcUtil::IfcBaseClass*> entity_by_id_t;
    typedef std::map<std::string, IfcUtil::IfcBaseClass*> entity_by_guid_t;
    typedef std::map<unsigned int, std::vector<unsigned int> > entities_by_ref_t;
    typedef std::map<unsigned int, IfcEntityList::ptr> ref_map_t;
    typedef entity_by_id_t::const_iterator const_iterator;

    class type_iterator : private entities_by_type_t::const_iterator {
    public:
        type_iterator() : entities_by_type_t::const_iterator() {};

        type_iterator(const entities_by_type_t::const_iterator& it)
            : entities_by_type_t::const_iterator(it)
        {};

        entities_by_type_t::key_type const * operator->() const {
            return &entities_by_type_t::const_iterator::operator->()->first;
        }

        entities_by_type_t::key_type const & operator*() const {
            return entities_by_type_t::const_iterator::operator*().first;
        }

        type_iterator& operator++() {
            entities_by_type_t::const_iterator::operator++(); return *this;
        }

        type_iterator operator++(int) {
            type_iterator tmp(*this); operator++(); return tmp;
        }

        bool operator!=(const type_iterator& other) const {
            const entities_by_type_t::const_iterator& self_ = *this;
            const entities_by_type_t::const_iterator& other_ = other;
            return self_ != other_;
        }
    };

private:
    typedef std::map<IfcUtil::IfcBaseClass*, IfcUtil::IfcBaseClass*> entity_entity_map_t;

    bool parsing_complete_, good_;

    const IfcParse::schema_definition* schema_;
    const IfcParse::declaration* ifcroot_type_;

    entity_by_id_t byid;
    entities_by_type_t bytype;
    entities_by_type_t bytype_excl;
    entities_by_ref_t byref;
    ref_map_t by_ref_cached_;
    entity_by_guid_t byguid;
    entity_entity_map_t entity_file_map;

    unsigned int MaxId;

    IfcSpfHeader _header;

    void setDefaultHeaderValues();

    void initialize_(IfcParse::IfcSpfStream* f);

    void build_inverses_(IfcUtil::IfcBaseClass*);
public:
    IfcParse::IfcSpfLexer* tokens;
    IfcParse::IfcSpfStream* stream;

#ifdef USE_MMAP
    IfcFile(const std::string& fn, bool mmap = false);
#else
    IfcFile(const std::string& fn);
#endif
    IfcFile(std::istream& fn, int len);
    IfcFile(void* data, int len);
    IfcFile(IfcParse::IfcSpfStream* f);
    IfcFile(const IfcParse::schema_definition* schema = IfcParse::schema_by_name("IFC4"));

    virtual ~IfcFile();

    bool good() const { return good_; }

    const_iterator begin() const;
    const_iterator end() const;

    type_iterator types_begin() const;
    type_iterator types_end() const;

    type_iterator types_incl_super_begin() const;
    type_iterator types_incl_super_end() const;

    template <class T>
    typename T::list::ptr instances_by_type() {
        IfcEntityList::ptr untyped_list = instances_by_type(&T::Class());
        if (untyped_list) {
            return untyped_list->as<T>();
        } else {
            return typename T::list::ptr(new typename T::list);
        }
    }

    template <class T>
    typename T::list::ptr instances_by_type_excl_subtypes() {
        IfcEntityList::ptr untyped_list = instances_by_type_excl_subtypes(&T::Class());
        if (untyped_list) {
            return untyped_list->as<T>();
        } else {
            return typename T::list::ptr(new typename T::list);
        }
    }

    IfcEntityList::ptr instances_by_type(const IfcParse::declaration*);

    IfcEntityList::ptr instances_by_type_excl_subtypes(const IfcParse::declaration*);

    IfcEntityList::ptr instances_by_type(const std::string& t);

    IfcEntityList::ptr instances_by_type_excl_subtypes(const std::string& t);

    IfcEntityList::ptr instances_by_reference(int id);

    IfcUtil::IfcBaseClass* instance_by_id(int id);

    IfcUtil::IfcBaseClass* instance_by_guid(const std::string& guid);

    IfcEntityList::ptr traverse(IfcUtil::IfcBaseClass* instance, int max_level=-1);

    IfcEntityList::ptr getInverse(int instance_id, const IfcParse::declaration* type, int attribute_index);

    void mark_entity_as_modified(int id);

    unsigned int FreshId() { return ++MaxId; }

    IfcUtil::IfcBaseClass* addEntity(IfcUtil::IfcBaseClass* entity);
    void addEntities(IfcEntityList::ptr es);

    void removeEntity(IfcUtil::IfcBaseClass* entity);

    const IfcSpfHeader& header() const { return _header; }
    IfcSpfHeader& header() { return _header; }

    std::string createTimestamp() const;

    size_t load(unsigned entity_instance_name, Argument**& attributes, size_t num_attributes);
    void seek_to(const IfcEntityInstanceData& data);
    void try_read_semicolon();

    void register_inverse(unsigned, Token);
    void register_inverse(unsigned, IfcUtil::IfcBaseClass*);
    void unregister_inverse(unsigned, IfcUtil::IfcBaseClass*);

    const IfcParse::schema_definition* schema() const { return schema_; }

    std::pair<IfcUtil::IfcBaseClass*, double> getUnit(const std::string& unit_type);

    bool parsing_complete() const { return parsing_complete_; }
    bool& parsing_complete() { return parsing_complete_; }

    void build_inverses();
};

#ifdef WITH_IFCXML
IFC_PARSE_API IfcFile* parse_ifcxml(const std::string& filename);
#endif

}

namespace std {
    template <>
    struct iterator_traits<IfcParse::IfcFile::type_iterator> {
        typedef ptrdiff_t difference_type;
        typedef const IfcParse::declaration* value_type;
        typedef const IfcParse::declaration*& reference;
        typedef const IfcParse::declaration** pointer;
        typedef std::forward_iterator_tag iterator_category;
    };
}

#endif