#include "IfcFile.h"

#include "IfcLogger.h"

#ifdef IFOPSH_WITH_ROCKSDB

#include <rocksdb/table.h>

#include <rocksdb/convenience.h>

#include <rocksdb/version.h>

#endif

#include <fstream>

#include <memory>

#include <utility>

#include <sys/types.h>

#include <sys/stat.h>

IfcParse::parse_context::~parse_context() {

for (auto& t : tokens_) {

std::visit([](auto& v) {

if constexpr (std::is_same_v<std::decay_t<decltype(v)>, parse_context*>) {

delete v;

}

}, t);

}

}

IfcParse::parse_context& IfcParse::parse_context::push() {

auto* pc = new IfcParse::parse_context;

tokens_.push_back(pc);

return *pc;

}

void IfcParse::parse_context::push(Token t) {

tokens_.push_back(t);

}

void IfcParse::parse_context::push(IfcUtil::IfcBaseClass* inst) {

tokens_.push_back(inst);

}

namespace {

template<typename Variant, typename T>

struct is_type_in_variant;

// Specialization when there are multiple types in the variant

template<typename T, typename First, typename... Rest>

struct is_type_in_variant<std::variant<First, Rest...>, T>

{

static constexpr bool value = std::is_same<T, First>::value || is_type_in_variant<std::variant<Rest...>, T>::value;

};

// Specialization when there is only one type left in the variant

template<typename T, typename Last>

struct is_type_in_variant<std::variant<Last>, T>

{

static constexpr bool value = std::is_same<T, Last>::value;

};

template<typename Variant, typename T>

constexpr bool is_type_in_variant_v = is_type_in_variant<Variant, T>::value;

template <typename Fn>

void dispatch_token(boost::optional<size_t> instance_id, int attribute_id, IfcParse::Token t, IfcParse::declaration* decl, Logger& logger, Fn fn) {

}

template <size_t Depth, typename Fn>

void construct_(boost::optional<size_t> instance_id, int attribute_id, IfcParse::parse_context& p, const IfcParse::aggregation_type* aggr, Logger& logger, Fn fn) {

}

}

IfcEntityInstanceData IfcParse::parse_context::construct(boost::optional<size_t> name, unresolved_references& references_to_resolve, const IfcParse::declaration* decl, boost::optional<size_t> expected_size, int resolve_reference_index, Logger& logger, bool coerce_attribute_count) {

std::vector<const IfcParse::parameter_type*> parameter_types;

std::unique_ptr<IfcParse::named_type> transient_named_type;

if ((decl != nullptr) && (decl->as_type_declaration() != nullptr)) {

parameter_types = { decl->as_type_declaration()->declared_type() };

} else if ((decl != nullptr) && (decl->as_enumeration_type() != nullptr)) {

transient_named_type.reset(new IfcParse::named_type(const_cast<IfcParse::declaration*>(decl)));

parameter_types = { &*transient_named_type };

} else if ((decl != nullptr) && (decl->as_entity() != nullptr)) {

auto entity_attrs = decl->as_entity()->all_attributes();

std::transform(

entity_attrs.begin(),

entity_attrs.end(),

std::back_inserter(parameter_types),

[](auto* attr) {

return attr->type_of_attribute();

}

);

}

if (((decl != nullptr) && (tokens_.size() != parameter_types.size())) ||

expected_size && *expected_size != tokens_.size())

{

size_t expected = expected_size ? *expected_size : parameter_types.size();

if (decl != nullptr && decl->schema() == &Header_section_schema::get_schema()) {

logger.Warning("VAL", 15, "Expected " + std::to_string(expected) + " attribute values, found " + std::to_string(tokens_.size()) + " for header entity " + decl->name());

} else {

logger.Warning("VAL", 16, "Expected " + std::to_string(expected) + " attribute values, found " + std::to_string(tokens_.size()) + (name ? std::string(" for instance #" + std::to_string(*name)) : std::string("")));

}

}

if (tokens_.empty()) {

return IfcEntityInstanceData(in_memory_attribute_storage(0));

}

in_memory_attribute_storage storage(coerce_attribute_count

? (decl != nullptr

? (std::min)(parameter_types.size(), tokens_.size())

: tokens_.size())

: tokens_.size()

);

auto it = tokens_.begin();

auto kt = parameter_types.begin();

for (; it != tokens_.end() && ((decl == nullptr) || kt != parameter_types.end()); ++it) {

auto& token = *it;

// @todo coerce to expected type, e.g empty -> std::vector<int>, bool -> logical

const IfcParse::parameter_type* param_type = nullptr;

if (decl != nullptr) {

param_type = *kt;

}

auto index = (uint8_t) std::distance(tokens_.begin(), it);

std::visit([this, &storage, name, &references_to_resolve, index, param_type, resolve_reference_index, &logger](const auto& v) {

if constexpr (std::is_same_v<std::decay_t<decltype(v)>, IfcParse::Token>) {

dispatch_token(name, index, v, param_type && param_type->as_named_type() ? param_type->as_named_type()->declared_type() : nullptr, logger, [this, &storage, name, &references_to_resolve, index, resolve_reference_index](auto v) {

if constexpr (std::is_same_v<std::decay_t<decltype(v)>, IfcParse::reference_or_simple_type>) {

if (name) {

references_to_resolve.push_back(std::make_pair(

// @todo previously this was storage but apparently the

// pointer is not constant with the moving and temporary nature

// maybe it ought to be and in that case a pointer is more direct

MutableAttributeValue{ (uint32_t) *name, resolve_reference_index == -1 ? index : (uint8_t) resolve_reference_index },

v

));

}

} else {

storage.set(index, v);

}

});

} else if constexpr (std::is_same_v<std::decay_t<decltype(v)>, IfcParse::parse_context*>) {

const auto *pt = param_type;

if (pt) {

while (pt->as_named_type() && pt->as_named_type()->declared_type()->as_type_declaration()) {

pt = pt->as_named_type()->declared_type()->as_type_declaration()->declared_type();

}

}

construct_<0>(name, index, *v, pt ? pt->as_aggregation_type() : nullptr, logger, [this, &storage, name, &references_to_resolve, index, resolve_reference_index](const auto& v) {

if constexpr (std::is_same_v<std::decay_t<decltype(v)>, std::vector<reference_or_simple_type>>) {

if (name) {

references_to_resolve.push_back({ { (uint32_t) *name, resolve_reference_index == -1 ? index : (uint8_t)resolve_reference_index }, v });

}

} else if constexpr (std::is_same_v<std::decay_t<decltype(v)>, std::vector<std::vector<reference_or_simple_type>>>) {

if (name) {

references_to_resolve.push_back({ { (uint32_t) *name, resolve_reference_index == -1 ? index : (uint8_t)resolve_reference_index }, v });

}

} else {

storage.set(index, v);

}

});

} else {

storage.set(index, v);

}

}, token);

if (decl != nullptr) {

++kt;

}

}

return IfcEntityInstanceData(std::move(storage));

}

IfcParse::impl::rocks_db_file_storage::rocksdb_types_iterator::value_type const& IfcParse::impl::rocks_db_file_storage::rocksdb_types_iterator::operator*() const {

return storage_->file->schema()->declarations()[*read_id_()];

}

IfcUtil::IfcBaseClass* IfcParse::impl::rocks_db_file_storage::assert_existance(size_t number, instance_ref r) {

#ifdef IFOPSH_WITH_ROCKSDB

if (r == IfcParse::impl::rocks_db_file_storage::entityinstance_ref) {

auto it = instance_cache_.find(number);

if (it != instance_cache_.end()) {

return it->second;

}

} else {

auto it = type_instance_cache_.find(number);

if (it != type_instance_cache_.end()) {

return it->second;

}

}

std::string v;

rocksdb::Status s = db->Get(rocksdb::ReadOptions{}, (r == entityinstance_ref ? "i|" : "t|") + std::to_string(number) + "|_", &v);

if (s.ok()) {

size_t s;

memcpy(&s, v.data(), sizeof(size_t));

if (s >= file->schema()->declarations().size()) {

throw std::runtime_error("");

}

auto decl = file->schema()->declarations()[s];

bool is_entity = decl->as_entity() != nullptr;

if (is_entity != (r == entityinstance_ref)) {

throw std::runtime_error("Incorrect reference");

}

IfcEntityInstanceData data(rocks_db_attribute_storage{});

IfcUtil::IfcBaseClass* inst;

if (file->instantiate_typed_instances) {

inst = file->schema()->instantiate(decl, std::move(data));

} else {

inst = new IfcUtil::IfcLateBoundEntity(decl, std::move(data));

}

inst->id_ = number;

inst->file_ = file;

if (r == IfcParse::impl::rocks_db_file_storage::entityinstance_ref) {

instance_cache_.insert({ number, inst });

} else {

type_instance_cache_.insert({ number, inst });

}

return inst;

} else {

throw IfcException("Instance #" + boost::lexical_cast<std::string>(number) + " not found");

}

#else

throw IfcException("RocksDB support not compiled in");

#endif

}

namespace {

std::unique_ptr<rocksdb::DB> init_db(const std::string& filepath, bool readonly) {

}

}

IfcParse::impl::rocks_db_file_storage::rocks_db_file_storage(const std::string& filepath, IfcParse::IfcFile* ffile, bool readonly)

: file(ffile)

, db(init_db(filepath, readonly))

// @todo streaming serializer does not populate the byguid map

, byguid_internal_(db.get(), "g|")

, byguid_(&byguid_internal_, [this](size_t v) { return assert_existance(v, entityinstance_ref); }, [](IfcUtil::IfcBaseClass* v) { return v->identity(); })

, instance_ids_(db.get(), "i|")

, instance_by_name_(&instance_ids_, [this](size_t v) { return assert_existance(v, entityinstance_ref); })

, bytype_(db.get(), "t|")

, byref_excl_(db.get(), "v|")

// @todo by_identity is probably not correct here, this mapping is Name -> Identity, so Fn should have access to full pair?

// , byidentity_(&byid_, [this](size_t v) { return assert_existance(v, by_identity); }, [](IfcUtil::IfcBaseClass* v) { return v->identity(); })

{

#ifdef IFOPSH_WITH_ROCKSDB

wopts.disableWAL = true;

#endif

}

IfcParse::impl::rocks_db_file_storage::~rocks_db_file_storage()

{

#ifdef IFOPSH_WITH_ROCKSDB

rocksdb::FlushOptions flush_options;

flush_options.allow_write_stall = true;

flush_options.wait = true; // Wait until flush completes.

rocksdb::Status s = db->Flush(flush_options);

// compact entire db

db->CompactRange(rocksdb::CompactRangeOptions{}, nullptr, nullptr);

assert(s.ok());

db->Close();

#endif

}

IfcUtil::IfcBaseClass* IfcParse::impl::rocks_db_file_storage::instance_by_id(int id)

{

// @todo rename assert_existance() -> instance_by_id();

// - no cannot be done, because it needs to differentiate between entity instances and typedecls

return assert_existance(id, entityinstance_ref);

}

void IfcParse::impl::rocks_db_file_storage::process_deletion_inverse(IfcUtil::IfcBaseClass* inst)

{

#ifdef IFOPSH_WITH_ROCKSDB

auto id = inst->id();

{

// compute next prefix that does not start with v|{id}|

auto prefix = "v|" + std::to_string(id) + "|";

auto it = std::unique_ptr<rocksdb::Iterator>(db->NewIterator(rocksdb::ReadOptions()));

it->Seek(prefix);

while (it->Valid()) {

it->Next();

if (!it->key().starts_with(prefix)) {

break;

}

}

rocksdb::WriteBatch batch;

batch.DeleteRange(prefix, it->key());

db->Write(wopts, &batch);

}

// This is based on traversal which needs instances to still be contained in the map.

// another option would be to keep byid intact for the remainder of this loop

aggregate_of_instance::ptr entity_attributes = traverse(inst, 1);

for (aggregate_of_instance::it it = entity_attributes->begin(); it != entity_attributes->end(); ++it) {

IfcUtil::IfcBaseClass* entity_attribute = *it;

if (entity_attribute == inst) {

continue;

}

const unsigned int name = entity_attribute->id();

// Do not update inverses for simple types (which have id()==0 in IfcOpenShell).

if (name != 0) {

// Find instances entity -> other

// and update inverses from entity into other

{

auto prefix = "v|" + std::to_string(name) + "|";

auto it = std::unique_ptr<rocksdb::Iterator>(db->NewIterator(rocksdb::ReadOptions()));

it->Seek(prefix);

while (it->Valid() && it->key().starts_with(prefix)) {

std::string s = it->value().ToString();

// Iterator are snapshotted? So don't get invalidated?

std::vector<size_t> vals(s.size() / sizeof(size_t));

memcpy(vals.data(), s.data(), s.size());

vals.erase(std::find(vals.begin(), vals.end(), (size_t)id));

s.resize(vals.size() * sizeof(size_t));

memcpy(s.data(), vals.data(), s.size());

db->Put(wopts, it->key(), s);

it->Next();

}

}

}

}

#endif

}

IfcUtil::IfcBaseClass* IfcParse::impl::in_memory_file_storage::instance_by_id(int id)

{

auto it = byid_.find(id);

if (it == byid_.end()) {

throw IfcException("Instance #" + boost::lexical_cast<std::string>(id) + " not found");

}

return it->second;

}

IfcParse::IfcFile::~IfcFile() {

// @todo this does not make sense for rocksdb, because it would assert existance for the entire lazy model only to free the instances again

for (const auto& p : byid_) {

delete p.second;

}

}

namespace {

// Utility functions for path handling in order not to rely on C++17's std::filesystem

#ifdef _WIN32

#define stat_t struct _stat

inline int stat_(const char* p, stat_t* s) { return ::_stat(p, s); }

#ifndef S_ISDIR

#define S_ISDIR(m) (((m) & _S_IFDIR) != 0)

#endif

#ifndef S_ISREG

#define S_ISREG(m) (((m) & _S_IFREG) != 0)

#endif

#else

using stat_t = struct stat;

inline int stat_(const char* p, stat_t* s) { return ::stat(p, s); }

#endif

inline bool path_exists_(const std::string& p, stat_t* out = nullptr) {

}

inline bool path_is_directory_(const stat_t& s) { return S_ISDIR(s.st_mode); }

inline bool path_is_regular_file_(const stat_t& s) { return S_ISREG(s.st_mode); }

inline std::string path_join_(const std::string& dir, const std::string& name) {

}

} // namespace

IfcParse::filetype IfcParse::guess_file_type(const std::string& fn) {

}

void IfcParse::InstanceStreamer::bypassTypes(const std::set<std::string>& type_names) {

for (auto& name : type_names) {

try {

types_to_bypass_.push_back(schema_->declaration_by_name(name));

} catch (const IfcException&) {

continue;

}

}

}

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

std::optional<std::tuple<size_t, const IfcParse::declaration*, IfcEntityInstanceData>> return_value;

if (header_ && yielded_header_instances_ < 3) {

if (yielded_header_instances_ == 0) {

return_value.emplace(

0,

&header_->file_description()->declaration(),

std::move(header_->file_description()->data())

);

} else if (yielded_header_instances_ == 1) {

return_value.emplace(

0,

&header_->file_name()->declaration(),

std::move(header_->file_name()->data())

);

} else if (yielded_header_instances_ == 2) {

return_value.emplace(

0,

&header_->file_schema()->declaration(),

std::move(header_->file_schema()->data())

);

}

yielded_header_instances_ += 1;

return return_value;

}

unsigned current_id = 0;

while (good_ && !lexer_->stream->eof() && !current_id) {

if (token_stream_[0].type == IfcParse::Token_IDENTIFIER &&

token_stream_[1].type == IfcParse::Token_OPERATOR &&

token_stream_[1].value_char == '=' &&

token_stream_[2].type == IfcParse::Token_KEYWORD) {

current_id = (unsigned)TokenFunc::asIdentifier(token_stream_[0]);

const IfcParse::declaration* entity_type;

try {

entity_type = schema_->declaration_by_name(TokenFunc::asStringRef(token_stream_[2]));

} catch (const IfcException& ex) {

logger_.get().Message(Logger::LOG_ERROR, "SYN", 3, std::string(ex.what()) + " at offset " + std::to_string(token_stream_[2].startPos));

current_id = 0;

goto advance;

}

if (entity_type->as_entity() == nullptr) {

logger_.get().Message(Logger::LOG_ERROR, "SYN", 4, "Non-entity type " + entity_type->name() + " at offset " + std::to_string(token_stream_[2].startPos));

current_id = 0;

goto advance;

}

for (auto& ty : types_to_bypass_) {

if (entity_type->is(*ty)) {

bypassed_instances_.push_back(current_id);

// Why is this a conditional clause in the loop?

current_id = 0;

goto advance;

}

}

parse_context ps;

lexer_->Next();

try {

storage_.load(current_id, entity_type->as_entity(), ps, -1);

} catch (const IfcInvalidTokenException& e) {

good_ = file_open_status::INVALID_SYNTAX;

logger_.get().Error("SYN", 5, e);

break;

}

/// @todo Printing to stdout in a library class feels weird. Maybe move the progress prints to the client code?

// Update the status after every 1000 instances parsed

if (((++progress_) % 1000) == 0) {

std::stringstream ss;

ss << "\r#" << current_id;

logger_.get().Status(ss.str(), false);

}

auto data = ps.construct(current_id, references_to_resolve_, entity_type, boost::none, -1, logger_.get(), coerce_attribute_count);

return_value.emplace(

(size_t)current_id,

entity_type,

std::move(data)

);

}

advance:

Token next_token;

try {

next_token = lexer_->Next();

} catch (const IfcException& e) {

logger_.get().Message(Logger::LOG_ERROR, "SYN", 6, std::string(e.what()) + ". Parsing terminated");

} catch (...) {

logger_.get().Message(Logger::LOG_ERROR, "SYN", 7, "Parsing terminated");

}

if (!lexer_->stream->eof() && next_token.type == Token_NONE) {

good_ = file_open_status::INVALID_SYNTAX;

break;

}

token_stream_.push_back(next_token);

}

// Free pages in front of cursor when variable-width tokens are materialized into entity instance data objects

(stream_ ? stream_ : (lexer_)->stream)->dropPages();

return return_value;

}

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

if (decl->as_entity() || decl->as_type_declaration()) {

auto* inst = file->schema()->instantiate(decl, rocks_db_attribute_storage{});

// @todo maybe this needs to be set to file? In order to have a context (ie. rocksdb::db*) to write to?

inst->file_ = nullptr;

return file->addEntity(inst);

} else {

throw std::runtime_error("Requires and entity or type declaration");

}

}

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

IfcUtil::IfcBaseClass* inst = nullptr;

if (auto* ent = decl->as_entity()) {

inst = file->schema()->instantiate(decl, in_memory_attribute_storage(ent->attribute_count()));

} else if (decl->as_type_declaration() != nullptr) {

inst = file->schema()->instantiate(decl, in_memory_attribute_storage(1));

} else {

throw std::runtime_error("Requires and entity or type declaration");

}

// file_ should be nullptr in order not to bypass addEntity() behaviour of registration in maps

inst->file_ = nullptr;

return file->addEntity(inst);

}