/********************************************************************************

* *

* 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 "ifc_parse_api.h"

#include "IfcParse.h"

#include "IfcSchema.h"

#include "IfcSpfHeader.h"

#include "storage.h"

#include "file_open_status.h"

#include <boost/multi_index/ordered_index.hpp>

#include <boost/multi_index/random_access_index.hpp>

#include <boost/multi_index/sequenced_index.hpp>

#include <boost/multi_index_container.hpp>

#include <boost/circular_buffer.hpp>

#include <iterator>

#include <map>

#ifdef IFOPSH_WITH_ROCKSDB

#include <rocksdb/merge_operator.h>

namespace {

// @todo move to a proper place

class ConcatenateIdMergeOperator : public rocksdb::AssociativeMergeOperator {

public:

virtual bool FullMergeV2(const MergeOperator::MergeOperationInput& merge_in,

MergeOperator::MergeOperationOutput* merge_out) const {

// Log(InfoLogLevel::INFO_LEVEL, merge_in.logger, "FullMergeV2 new_value size:%ld", merge_out->new_value.size());

merge_out->new_value.clear();

if (merge_in.existing_value) {

merge_out->new_value.append(merge_in.existing_value->data(), merge_in.existing_value->size());

}

for (auto& operand : merge_in.operand_list) {

merge_out->new_value.append(operand.data(), operand.size());

}

return true;

}

virtual bool Merge(const rocksdb::Slice&,

const rocksdb::Slice*,

const rocksdb::Slice&,

std::string*,

rocksdb::Logger*) const override

{

return false;

}

virtual const char* Name() const override {

return "ConcatenateIdMergeOperator";

}

};

}

#endif

namespace IfcParse {

enum filetype {

FT_IFCSPF,

FT_IFCXML,

FT_IFCZIP,

FT_ROCKSDB,

FT_UNKNOWN,

FT_AUTODETECT

};

IFC_PARSE_API filetype guess_file_type(const std::string& fn);

class IFC_PARSE_API InstanceStreamer {

private:

FileReader* stream_;

IfcSpfLexer* lexer_;

IfcSpfHeader* header_;

boost::circular_buffer<Token> token_stream_;

const IfcParse::schema_definition* schema_;

IfcParse::impl::in_memory_file_storage storage_;

IfcParse::file_open_status good_ = IfcParse::file_open_status::SUCCESS;

int progress_;

IfcParse::unresolved_references references_to_resolve_;

int yielded_header_instances_ = 0;

std::vector<const declaration*> types_to_bypass_;

std::vector<unsigned> bypassed_instances_;

public:

bool coerce_attribute_count = true;

operator bool() const {

return good_ && !lexer_->stream->eof();

}

IfcParse::file_open_status status() const {

return good_;

}

const IfcParse::unresolved_references& references() const {

return references_to_resolve_;

}

IfcParse::unresolved_references& references() {

return references_to_resolve_;

}

const std::vector<unsigned>& bypassed_instances() {

std::sort(bypassed_instances_.begin(), bypassed_instances_.end());

return bypassed_instances_;

}

const IfcParse::impl::in_memory_file_storage::entities_by_ref_t& inverses() const {

return storage_.byref_excl_;

}

IfcParse::impl::in_memory_file_storage::entities_by_ref_t& inverses() {

return storage_.byref_excl_;

}

std::vector<std::unique_ptr<IfcUtil::IfcBaseClass>> stealInstances() {

return storage_.steal_instances();

}

bool hasSemicolon() const;

size_t semicolonCount() const;

void pushPage(const std::string& page);

InstanceStreamer();

InstanceStreamer(const std::string& fn, bool mmap=false);

InstanceStreamer(void* data, int length);

InstanceStreamer(const IfcParse::schema_definition* schema, IfcParse::IfcSpfLexer* lexer);

void bypassTypes(const std::set<std::string>& type_names);

~InstanceStreamer() {

delete stream_;

if (stream_) {

delete lexer_;

}

delete header_;

}

std::optional<std::tuple<size_t, const IfcParse::declaration*, IfcEntityInstanceData>> readInstance();

};

class uninitialized_tag {};

/// This class provides access to the entity instances in an IFC file

/// The file takes ownership of instances added to this file and deletes them when the file is deleted.

class IFC_PARSE_API IfcFile {

private:

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

// @todo determine the constness of things (probably needs to be all const, we don't want to overwrite)

// @todo we have variant_iterator and MapVariant, we probably need to retain only one?

public:

using const_iterator = variant_iterator<impl::in_memory_file_storage::iterator, impl::rocks_db_file_storage::const_iterator>;

using type_iterator = variant_iterator<impl::in_memory_file_storage::type_iterator, impl::rocks_db_file_storage::rocksdb_types_iterator>;

using storage_t = std::variant<std::monostate, impl::in_memory_file_storage, impl::rocks_db_file_storage>;

typedef VariantMap<impl::in_memory_file_storage::entity_instance_by_guid_t, impl::rocks_db_file_storage::entity_instance_by_guid_t> entity_instance_by_guid_t;

entity_instance_by_guid_t byguid_;

typedef VariantMap<impl::in_memory_file_storage::entity_instance_by_name_t, impl::rocks_db_file_storage::entity_instance_by_name_t> entity_by_id_t;

entity_by_id_t byid_;

typedef VariantMap<impl::in_memory_file_storage::entities_by_ref_t, impl::rocks_db_file_storage::entities_by_ref_t> entities_by_ref_t;

entities_by_ref_t byref_excl_;

bool check_existance_before_adding = true;

bool calculate_unit_factors = true;

bool instantiate_typed_instances = true;

// @todo temporarily public for header

storage_t storage_;

std::set<std::string> types_to_bypass_loading_;

private:

file_open_status good_ = file_open_status::SUCCESS;

const IfcParse::schema_definition* schema_;

const IfcParse::declaration* ifcroot_type_;

entity_entity_map_t entity_file_map_;

unsigned int max_id_;

IfcSpfHeader _header;

void setDefaultHeaderValues();

typedef boost::multi_index_container<

int,

boost::multi_index::indexed_by<

boost::multi_index::sequenced<>,

boost::multi_index::ordered_unique<

boost::multi_index::identity<int>>>>

batch_deletion_ids_t;

batch_deletion_ids_t batch_deletion_ids_;

bool batch_mode_ = false;

void process_deletion_(IfcUtil::IfcBaseClass* entity);

public:

#ifdef USE_MMAP

/// <summary>

/// Constructs an IfcFile object from a file path, optionally using memory-mapped I/O, only supports IFC-SPF files.

/// </summary>

/// <param name="path">UTF-8 file path to an IFC-SPF file</param>

/// <param name="mmap">Whether to use memory-mapped I/O</param>

IfcFile(const std::string& path, bool mmap);

#endif

/// <summary>

/// Constructs an IfcFile object from a file path, supports IFC-SPF and the IfcOpenShell-specific RocksDB format.

/// </summary>

/// <param name="path">UTF-8 file path to an IFC-SPF file or RocksDB database directory</param>

/// <param name="ty">File type of the path</param>

/// <param name="readonly">Whether to open in read-only mode, only supported on RocksDB databases</param>

IfcFile(const std::string& path, filetype ty=FT_AUTODETECT, bool readonly=false);

/// <summary>

/// Constructs an IfcFile object from a stream containing IFC-SPF data.

/// </summary>

IfcFile(std::istream& stream, int length);

/// <summary>

/// Constructs an IfcFile object from a memory buffer containing IFC-SPF data.

/// </summary>

IfcFile(void* data, int length);

/// <summary>

/// Constructs an IfcFile object from a given IFC SPF stream.

/// </summary>

/// <param name="stream">A pointer to an IfcParse::FileReader object representing the input IFC SPF data stream.</param>

IfcFile(IfcParse::FileReader* stream);

/// <summary>

/// Constructs an IfcFile object with the specified schema, file type, and file path.

/// @nb path is only used in rocksdb mode, for spf file is in-memory only until write() is called

/// </summary>

/// <param name="schema">Pointer to the schema definition to use. Defaults to the IFC4 schema if not specified.</param>

/// <param name="ty">The file type to use for the file. Defaults to FT_AUTODETECT.</param>

/// <param name="path">The file system path to the IFC file. Defaults to an empty string.</param>

IfcFile(const IfcParse::schema_definition* schema = IfcParse::schema_by_name("IFC4"), filetype ty = FT_AUTODETECT, const std::string& path = "");

/// <summary>

/// Constructs an unitialized IfcFile object. Call initialize() later on. Allows to specify which types to bypass during load.

/// </summary>

IfcFile(const uninitialized_tag&);

bool initialize(const std::string& path, filetype ty = FT_AUTODETECT, bool readonly = false);

#ifdef USE_MMAP

bool initialize(const std::string& path, bool mmap);

#endif

/// @brief Bypass loading of all instances of the specified type name. Only applies to parsed IFC-SPF files.

/// @param type_name case insensitive name of the type to bypass

void bypass_type(const std::string& type_name);

~IfcFile();

IfcParse::file_open_status good() const { return good_; }

/// Returns the first entity in the range of instances contained in the model,

/// in arbitrary order

entity_by_id_t::iterator begin() const {

return byid_.begin();

}

/// Returns the first entity in the range of instances contained in the model,

/// in arbitrary order

entity_by_id_t::iterator end() const {

return byid_.end();

}

type_iterator types_begin() const;

type_iterator types_end() const;

/// Returns all entities in the file that match the template argument.

/// NOTE: This also returns subtypes of the requested type, for example:

/// IfcWall will also return IfcWallStandardCase entities

template <class T>

typename T::list::ptr instances_by_type() {

aggregate_of_instance::ptr untyped_list = instances_by_type(&T::Class());

if (untyped_list) {

return untyped_list->as<T>();

}

return typename T::list::ptr(new typename T::list);

}

template <class T>

typename T::list::ptr instances_by_type_excl_subtypes() {

aggregate_of_instance::ptr untyped_list = instances_by_type_excl_subtypes(&T::Class());

if (untyped_list) {

return untyped_list->as<T>();

}

return typename T::list::ptr(new typename T::list);

}

/// Returns all entities in the file that match the positional argument.

/// NOTE: This also returns subtypes of the requested type, for example:

/// IfcWall will also return IfcWallStandardCase entities

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

/// Returns all entities in the file that match the positional argument.

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

/// Returns all entities in the file that match the positional argument.

/// NOTE: This also returns subtypes of the requested type, for example:

/// IfcWall will also return IfcWallStandardCase entities

aggregate_of_instance::ptr instances_by_type(const std::string& type);

/// Returns all entities in the file that match the positional argument.

aggregate_of_instance::ptr instances_by_type_excl_subtypes(const std::string& type);

/// Returns all entities in the file that reference the id

aggregate_of_instance::ptr instances_by_reference(int id);

/// Returns the entity with the specified id

IfcUtil::IfcBaseClass* instance_by_id(int id);

/// Returns the entity with the specified GlobalId

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

/// Performs a depth-first traversal, returning all entity instance

/// attributes as a flat list. NB: includes the root instance specified

/// in the first function argument.

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

/// Same as traverse() but maintains topological order by using a

/// breadth-first search

static aggregate_of_instance::ptr traverse_breadth_first(IfcUtil::IfcBaseClass* instance, int max_level = -1);

/// Get the attribute indices corresponding to the list of entity instances

/// returned by getInverse().

std::vector<int> get_inverse_indices(int instance_id);

template <typename T>

typename T::list::ptr getInverse(int instance_id, int attribute_index) {

return getInverse(instance_id, &T::Class(), attribute_index)->template as<T>();

}

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

size_t getTotalInverses(int instance_id);

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

unsigned int getMaxId() const { return max_id_; }

const IfcParse::declaration* ifcroot_type() const { return ifcroot_type_; }

void recalculate_id_counter();

IfcUtil::IfcBaseClass* addEntity(IfcUtil::IfcBaseClass* entity, int id = -1);

void addEntities(aggregate_of_instance::ptr entities);

/// Removes entity instance from file and unsets references.

///

/// Attention when running removeEntity inside a loop over a list of entities to be removed.

/// This invalidates the iterator. A workaround is to reverse the loop:

/// boost::shared_ptr<aggregate_of_instance> entities = ...;

/// for (auto it = entities->end() - 1; it >= entities->begin(); --it) {

/// IfcUtil::IfcBaseClass *const inst = *it;

/// model->removeEntity(inst);

/// }

void removeEntity(IfcUtil::IfcBaseClass* entity);

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

IfcSpfHeader& header() { return _header; }

static std::string createTimestamp();

const IfcParse::schema_definition* schema() const;

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

void build_inverses();

void register_inverse(unsigned, const IfcParse::entity* from_entity, int inst_id, int attribute_index);

void unregister_inverse(unsigned, const IfcParse::entity* from_entity, IfcUtil::IfcBaseClass*, int attribute_index);

entity_instance_by_guid_t internal_guid_map() { return byguid_; };

void add_type_ref(IfcUtil::IfcBaseClass* new_entity);

void remove_type_ref(IfcUtil::IfcBaseClass* new_entity);

void process_deletion_inverse(IfcUtil::IfcBaseClass* inst);

void build_inverses_(IfcUtil::IfcBaseClass*);

template <typename T>

T* create() {

return std::visit([](auto& m) -> T* {

if constexpr (std::is_same_v<std::decay_t<decltype(m)>, impl::in_memory_file_storage> ||

std::is_same_v<std::decay_t<decltype(m)>, impl::rocks_db_file_storage>)

{

return m.template create<T>();

} else {

return nullptr;

}

}, storage_);

}

IfcUtil::IfcBaseClass* create(const IfcParse::declaration* decl) {

return std::visit([decl](auto& m) -> IfcUtil::IfcBaseClass* {

if constexpr (std::is_same_v<std::decay_t<decltype(m)>, impl::in_memory_file_storage> ||

std::is_same_v<std::decay_t<decltype(m)>, impl::rocks_db_file_storage>)

{

return m.create(decl);

} else {

return nullptr;

}

}, storage_);

}

void batch() {

batch_mode_ = true;

}

void unbatch();

void reset_identity_cache();

};

#ifdef WITH_IFCXML

IFC_PARSE_API IfcFile* parse_ifcxml(const std::string& filename);

#endif

namespace impl {

// Trick to have a dependent static assertion

template <class> inline constexpr bool dependent_false_v = false;

}

} // namespace IfcParse

template <typename T>

T* IfcParse::impl::in_memory_file_storage::create() {

IfcUtil::IfcBaseClass* inst = nullptr;

if constexpr (std::is_same_v<std::decay_t<std::invoke_result_t<typename T::Class>>, IfcParse::entity>) {

inst = new T(in_memory_attribute_storage(T::Class().attribute_count()));

} else if constexpr (std::is_same_v<std::decay_t<std::invoke_result_t<typename T::Class>>, IfcParse::type_declaration>) {

inst = new T(in_memory_attribute_storage(1));

} else {

static_assert(dependent_false_v<T>, "Requires and entity or type declaration");

}

inst->file_ = file;

return file->addEntity(inst)->as<T>();

}

template <typename T>

T* IfcParse::impl::rocks_db_file_storage::create() {

if constexpr (std::is_same_v<std::decay_t<std::invoke_result_t<typename T::Class>>, IfcParse::entity> || std::is_same_v<std::decay_t<std::invoke_result_t<typename T::Class>>, IfcParse::type_declaration>) {

auto* inst = new T(rocks_db_attribute_storage{});

inst->file_ = file;

return file->addEntity(inst)->template as<T>();

} else {

static_assert(dependent_false_v<T>, "Requires and entity or type declaration");

}

}

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;

};

} // namespace std

#endif