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

* *

* 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/>. *

* *

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

#include "IfcParse.h"

#include "IfcBaseClass.h"

#include "IfcCharacterDecoder.h"

#include "IfcException.h"

#include "IfcFile.h"

#include "IfcLogger.h"

#include "IfcSchema.h"

#include "IfcSIPrefix.h"

#include "FileReader.h"

#include "utils.h"

#include <algorithm>

#include <boost/algorithm/string.hpp>

#include <boost/variant.hpp>

#include <boost/math/special_functions/fpclassify.hpp>

#include <ctime>

#include <set>

#include <stdio.h>

#include <stdlib.h>

#include <string>

#include <iomanip>

#ifdef USE_MMAP

#include <boost/filesystem/path.hpp>

#endif

#define PERMISSIVE_FLOAT

using namespace IfcParse;

// A static locale for the real number parser. strtod() is locale-dependent, causing issues

// in locales that have ',' as a decimal separator. Therefore the non standard _strtod_l() /

// strtod_l() is used and a reference to the "C" locale is obtained here. The alternative is

// to use std::istringstream::imbue(std::locale::classic()), but there are subtleties in

// parsing in MSVC2010 and it appears to be much slower.

#if defined(_MSC_VER)

static _locale_t locale = (_locale_t)0;

void init_locale() {

if (locale == (_locale_t)0) {

locale = _create_locale(LC_NUMERIC, "C");

}

}

#else

#if defined(__MINGW64__) || defined(__MINGW32__)

#include <locale>

#include <sstream>

typedef void* locale_t;

static locale_t locale = (locale_t)0;

void init_locale() {}

double strtod_l(const char* start, char** end, locale_t loc) {

double d;

std::stringstream ss;

ss.imbue(std::locale::classic());

ss << start;

ss >> d;

size_t nread = ss.tellg();

*end = const_cast<char*>(start) + nread;

return d;

}

#else

#ifdef __APPLE__

#include <xlocale.h>

#endif

#include <locale.h>

static locale_t locale = (locale_t)0;

void init_locale() {

if (locale == (locale_t)0) {

locale = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0);

}

}

#endif

#endif

IfcSpfLexer::IfcSpfLexer(IfcParse::FileReader* stream_) {

stream = stream_;

decoder_ = new IfcCharacterDecoder(stream_);

}

IfcSpfLexer::~IfcSpfLexer() {

delete decoder_;

}

size_t IfcSpfLexer::skipWhitespace() const {

size_t index = 0;

while (!stream->eof()) {

char character = stream->peek();

if ((character == ' ' || character == '\r' || character == '\n' || character == '\t')) {

stream->increment();

++index;

} else {

break;

}

}

return index;

}

size_t IfcSpfLexer::skipComment() const {

if (stream->eof()) {

return 0;

}

char character = stream->peek();

if (character != '/') {

return 0;

}

stream->increment();

character = stream->peek();

if (character != '*') {

stream->seek(stream->tell() - 1);

return 0;

}

size_t index = 2;

char intermediate = 0;

while (!stream->eof()) {

character = stream->peek();

stream->increment();

++index;

if (character == '/' && intermediate == '*') {

break;

}

intermediate = character;

}

return index;

}

//

// Returns the offset of the current Token and moves cursor to next

//

Token IfcSpfLexer::Next() {

if (stream->eof()) {

return Token{};

}

while ((skipWhitespace() != 0U) || (skipComment() != 0U)) {

}

if (stream->eof()) {

return Token{};

}

auto& str = GetTempString();

auto pos = stream->tell();

char character = stream->read();

// If the cursor is at [()=,;$*] we know token consists of single char

if (character == '(' ||

character == ')' ||

character == '=' ||

character == ',' ||

character == ';' ||

character == '$' ||

character == '*')

{

return OperatorTokenPtr(this, pos, character);

}

if (character == '\'') {

// If a string is encountered defer processing to the IfcCharacterDecoder

str = *decoder_;

} else {

str.assign(&character, 1);

while (!stream->eof()) {

// Read character and increment pointer if not starting a new token

character = stream->peek();

if (character == '(' ||

character == ')' ||

character == '=' ||

character == ',' ||

character == ';' ||

character == '/') {

break;

}

if (!(character == ' ' || character == '\r' || character == '\n' || character == '\t')) {

str.push_back(character);

}

stream->increment();

}

}

return GeneralTokenPtr(this, pos, str);

}

//

// Reads a std::string from the file at specified offset

// Omits whitespace and comments

//

void IfcSpfLexer::TokenString(size_t offset, std::string& buffer) {

buffer.clear();

auto local_stream = *this->stream;

local_stream.seek(offset);

while (!local_stream.eof()) {

char character = local_stream.peek();

if (!buffer.empty() && (character == '(' ||

character == ')' ||

character == '=' ||

character == ',' ||

character == ';' ||

character == '/')) {

break;

}

local_stream.increment();

if (character == ' ' ||

character == '\r' ||

character == '\n' ||

character == '\t') {

continue;

}

if (character == '\'') {

// todo, make decoder use local offset ptr

auto offset = local_stream.tell();

buffer = decoder_->get(offset);

break;

}

buffer.push_back(character);

}

}

//Note: according to STEP standard, there may be newlines in tokens

/*

inline void RemoveTokenSeparators(FileReader* stream, size_t start, size_t end, std::string& oDestination) {

oDestination.clear();

for (unsigned i = start; i < end; i++) {

char character = stream->get(i);

if (character == ' ' ||

character == '\r' ||

character == '\n' ||

character == '\t') {

continue;

}

oDestination += character;

}

}

*/

bool ParseInt(const char* pStart, int& val) {

char* pEnd;

long result = strtol(pStart, &pEnd, 10);

if (*pEnd != 0) {

return false;

}

val = (int)result;

return true;

}

bool ParseFloat(const char* pStart, double& val) {

char* pEnd;

#ifdef _MSC_VER

double result = _strtod_l(pStart, &pEnd, locale);

#else

double result = strtod_l(pStart, &pEnd, locale);

#endif

if (*pEnd != 0) {

return false;

}

val = result;

return true;

}

bool ParseBool(const char* pStart, int& val) {

if (strlen(pStart) != 3 || pStart[0] != '.' || pStart[2] != '.') {

return false;

}

char mid = pStart[1];

if (mid == 'T') {

val = 1;

} else if (mid == 'F') {

val = 0;

} else if (mid == 'U') {

val = 2;

} else {

return false;

}

return true;

}

Token IfcParse::OperatorTokenPtr(IfcSpfLexer* lexer, size_t start, char data) {

Token token(lexer, start, Token_OPERATOR);

token.value_char = data;

return token;

}

Token IfcParse::GeneralTokenPtr(IfcSpfLexer* lexer, size_t start, const std::string& tokenStr) {

Token token(lexer, start, Token_NONE);

//determine type of the token

const char& first = tokenStr.front();

if (first == '#') {

token.type = Token_IDENTIFIER;

if (!ParseInt(tokenStr.c_str() + 1, token.value_int)) {

Logger::Message(Logger::LOG_ERROR, "Token '" + tokenStr + "' at offset " + std::to_string(token.startPos) + " is not valid");

token.type = Token_OPERATOR;

token.value_char = '$';

}

} else if (first == '\'') {

token.type = Token_STRING;

} else if (first == '.') {

token.type = Token_ENUMERATION;

if (ParseBool(tokenStr.c_str(), token.value_int)) { //bool is also enumeration

token.type = Token_BOOL;

}

} else if (first == '"') {

token.type = Token_BINARY;

} else if (ParseInt(tokenStr.c_str(), token.value_int)) {

token.type = Token_INT;

} else if (ParseFloat(tokenStr.c_str(), token.value_double)) {

token.type = Token_FLOAT;

} else {

token.type = Token_KEYWORD;

}

return token;

}

bool TokenFunc::isOperator(const Token& token) {

return token.type == Token_OPERATOR;

}

bool TokenFunc::isOperator(const Token& token, char character) {

return token.type == Token_OPERATOR && token.value_char == character;

}

bool TokenFunc::isIdentifier(const Token& token) {

return token.type == Token_IDENTIFIER;

}

bool TokenFunc::isString(const Token& token) {

return token.type == Token_STRING;

}

bool TokenFunc::isEnumeration(const Token& token) {

return token.type == Token_ENUMERATION || token.type == Token_BOOL;

}

bool TokenFunc::isBinary(const Token& token) {

return token.type == Token_BINARY;

}

bool TokenFunc::isKeyword(const Token& token) {

return token.type == Token_KEYWORD;

}

bool TokenFunc::isInt(const Token& token) {

return token.type == Token_INT;

}

bool TokenFunc::isBool(const Token& token) {

// Bool and logical share the same storage type, just logical unknown is stored as 2.

return token.type == Token_BOOL && token.value_int != 2;

}

bool TokenFunc::isLogical(const Token& token) {

return token.type == Token_BOOL;

}

bool TokenFunc::isFloat(const Token& token) {

#ifdef PERMISSIVE_FLOAT

/// NB: We are being more permissive here then allowed by the standard

return token.type == Token_FLOAT || token.type == Token_INT;

#else

return token.type == Token_FLOAT;

#endif

}

int TokenFunc::asInt(const Token& token) {

if (token.type != Token_INT) {

throw IfcInvalidTokenException(token.startPos, toString(token), "integer");

}

return token.value_int;

}

int TokenFunc::asIdentifier(const Token& token) {

if (token.type != Token_IDENTIFIER) {

throw IfcInvalidTokenException(token.startPos, toString(token), "instance name");

}

return token.value_int;

}

bool TokenFunc::asBool(const Token& token) {

if (token.type != Token_BOOL) {

throw IfcInvalidTokenException(token.startPos, toString(token), "boolean");

}

return token.value_int == 1;

}

boost::logic::tribool TokenFunc::asLogical(const Token& token) {

if (token.type != Token_BOOL) {

throw IfcInvalidTokenException(token.startPos, toString(token), "boolean");

}

if (token.value_int == 0) {

return false;

}

if (token.value_int == 1) {

return true;

}

return boost::logic::indeterminate;

}

double TokenFunc::asFloat(const Token& token) {

#ifdef PERMISSIVE_FLOAT

if (token.type == Token_INT) {

/// NB: We are being more permissive here then allowed by the standard

return token.value_int;

} // ----> continues beyond preprocessor directive

#endif

if (token.type == Token_FLOAT) {

return token.value_double;

}

throw IfcInvalidTokenException(token.startPos, toString(token), "real");

}

const std::string& TokenFunc::asStringRef(const Token& token) {

if (token.type == Token_NONE) {

throw IfcParse::IfcException("Null token encountered, premature end of file?");

}

std::string& str = token.lexer->GetTempString();

token.lexer->TokenString(token.startPos, str);

if ((isString(token) || isEnumeration(token) || isBinary(token)) && !str.empty()) {

//remove start+end characters in-place

str.erase(str.end() - 1);

str.erase(str.begin());

}

return str;

}

std::string TokenFunc::asString(const Token& token) {

if (isString(token) || isEnumeration(token) || isBinary(token)) {

return asStringRef(token);

}

throw IfcInvalidTokenException(token.startPos, toString(token), "string");

}

boost::dynamic_bitset<> TokenFunc::asBinary(const Token& token) {

const std::string& str = asStringRef(token);

if (str.empty()) {

throw IfcException("Token is not a valid binary sequence");

}

std::string::const_iterator it = str.begin();

int n = *it - '0';

if ((n < 0 || n > 3) || (str.size() == 1 && n != 0)) {

throw IfcException("Token is not a valid binary sequence");

}

++it;

unsigned i = ((unsigned)str.size() - 1) * 4 - n;

boost::dynamic_bitset<> bitset(i);

for (; it != str.end(); ++it) {

const std::string::value_type& c = *it;

int value = (c < 'A') ? (c - '0') : (c - 'A' + 10);

for (unsigned j = 0; j < 4; ++j) {

if (i-- == 0) {

break;

}

if ((value & (1 << (3 - j))) != 0) {

bitset.set(i);

}

}

}

return bitset;

}

std::string TokenFunc::toString(const Token& token) {

std::string result;

if (token.type == Token_OPERATOR) {

result.push_back(token.value_char);

} else if (token.type == Token_INT) {

result = std::to_string(token.value_int);

} else if (token.type == Token_BOOL) {

if (token.value_int == 1) {

result = ".T.";

} else if (token.value_int == 0) {

result = ".F.";

} else {

result = ".U.";

}

} else if (token.type == Token_FLOAT) {

std::ostringstream oss;

oss << std::setprecision(15) << token.value_double;

result = oss.str();

} else {

token.lexer->TokenString(token.startPos, result);

}

return result;

}

//

// Reads the arguments from a list of token

// Aditionally, registers the ids (i.e. #[\d]+) in the inverse map

//

void IfcParse::impl::in_memory_file_storage::load(boost::optional<size_t> entity_instance_name, const IfcParse::entity* entity, parse_context& context, int attribute_index) {

Token next = tokens->Next();

/*

if (TokenFunc::isOperator(next, '(')) {

next = tokens->Next();

}

*/

size_t attribute_index_within_data = 0;

size_t return_value = 0;

while ((next.startPos != 0U) || (next.lexer != nullptr)) {

if (TokenFunc::isOperator(next, ',')) {

if (attribute_index == -1) {

attribute_index_within_data += 1;

}

} else if (TokenFunc::isOperator(next, ')')) {

break;

} else if (TokenFunc::isOperator(next, '(')) {

return_value++;

load(entity_instance_name, entity, context.push(), attribute_index == -1 ? (int) attribute_index_within_data : attribute_index);

} else {

return_value++;

if (TokenFunc::isIdentifier(next) && entity && entity_instance_name) {

register_inverse(*entity_instance_name, entity, next.value_int, attribute_index == -1 ? (int) attribute_index_within_data : attribute_index);

}

if (TokenFunc::isKeyword(next)) {

try {

const auto* decl = (schema ? schema : file->schema())->declaration_by_name(TokenFunc::asStringRef(next));

parse_context ps;

tokens->Next();

// The only case we know where a defined type contains entity

// instance references is IfcPropertySetDefinitionSet. For

// that purpose we propagate the entity_instance_name to

// register inverses to the host entity (and not the defined

// type) and to be able to actually register the references in

// the 2nd pass.

load(entity_instance_name, entity, ps, attribute_index == -1 ? (int)attribute_index_within_data : attribute_index);

auto* simple_type_instance = (schema ? schema : file->schema())->instantiate(decl, ps.construct(entity_instance_name, *references_to_resolve, decl, boost::none, attribute_index == -1 ? (int)attribute_index_within_data : attribute_index));

read_simple_type_instances.emplace_back(simple_type_instance);

//@todo decide addEntity(((IfcUtil::IfcBaseClass*)*entity));

context.push(simple_type_instance);

simple_type_instance->file_ = file;

} catch (IfcException& e) {

Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + " at offset " + std::to_string(next.startPos));

// #4070 We didn't actually capture an aggregate entry, undo length increment.

return_value--;

}

} else {

context.push(next);

}

}

next = tokens->Next();

}

}

//

// Reads an Entity from the list of Tokens at the specified offset in the file

//

IfcEntityInstanceData IfcParse::impl::in_memory_file_storage::read(unsigned int i) {

Token datatype = tokens->Next();

if (!TokenFunc::isKeyword(datatype)) {

throw IfcException("Unexpected token while parsing entity");

}

const IfcParse::declaration* ty = file->schema()->declaration_by_name(TokenFunc::asStringRef(datatype));

parse_context pc;

tokens->Next();

load(i, ty->as_entity(), pc, -1);

return IfcEntityInstanceData(pc.construct(i, *references_to_resolve, ty, boost::none, -1));

}

void IfcParse::impl::in_memory_file_storage::try_read_semicolon() const {

auto old_offset = tokens->stream->tell();

Token semilocon = tokens->Next();

if (!TokenFunc::isOperator(semilocon, ';')) {

tokens->stream->seek(old_offset);

}

}

void IfcParse::impl::in_memory_file_storage::register_inverse(unsigned id_from, const IfcParse::entity* from_entity, int inst_id, int attribute_index) {

// Assume a check on token type has already been performed

byref_excl_[{inst_id, from_entity->index_in_schema(), attribute_index}].push_back(id_from);

}

void IfcParse::impl::in_memory_file_storage::unregister_inverse(unsigned id_from, const IfcParse::entity* from_entity, IfcUtil::IfcBaseClass* inst, int attribute_index) {

auto& ids = byref_excl_[{inst->id(), from_entity->index_in_schema(), attribute_index}];

auto iter = std::find(ids.begin(), ids.end(), id_from);

if (iter == ids.end()) {

// @todo inverses also need to be populated when multiple instances are added to a new file.

// throw IfcParse::IfcException("Instance not found among inverses");

} else {

ids.erase(iter);

}

}

namespace {

template <typename T>

std::string to_string_fixed_width(const T& t, size_t) {

// @todo currently inactive

std::ostringstream oss;

oss << /*std::setfill('0') << std::setw(w) <<*/ t;

return oss.str();

}

}

void IfcParse::impl::rocks_db_file_storage::register_inverse(unsigned id_from, const IfcParse::entity* from_entity, int inst_id, int attribute_index) {

#ifdef IFOPSH_WITH_ROCKSDB

static std::string s;

uint32_t v = id_from;

s.resize(sizeof(uint32_t));

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

auto key = "v|" + to_string_fixed_width(inst_id, 10) + "|" + to_string_fixed_width(from_entity->index_in_schema(), 4) + "|" + to_string_fixed_width(attribute_index, 2);

db->Merge(wopts, key, s);

/*

// Python client does not support merges

// @todo turn this into a setting

{

std::string current;

db->Get(rocksdb::ReadOptions{}, key, &current);

auto new_val = current + s;

db->Put(wopts, key, new_val);

}*/

#endif

}

void IfcParse::impl::rocks_db_file_storage::unregister_inverse(unsigned id_from, const IfcParse::entity* from_entity, IfcUtil::IfcBaseClass* inst, int attribute_index) {

#ifdef IFOPSH_WITH_ROCKSDB

static std::string s;

auto inst_id = inst->id();

auto key = "v|" + to_string_fixed_width(inst_id, 10) + "|" + to_string_fixed_width(from_entity->index_in_schema(), 4) + "|" + to_string_fixed_width(attribute_index, 2);

if (db->Get(rocksdb::ReadOptions{}, key, &s).ok()) {

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

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

auto it = std::find(vals.begin(), vals.end(), (uint32_t)id_from);

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

vals.erase(it);

} else {

Logger::Error("Unregistering non-existant inverse #" + std::to_string(id_from) + " on instance #" + std::to_string(inst_id) + " at attribute " + std::to_string(attribute_index));

}

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

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

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

}

#endif

}

void IfcParse::impl::rocks_db_file_storage::add_type_ref(IfcUtil::IfcBaseClass* new_entity)

{

#ifdef IFOPSH_WITH_ROCKSDB

size_t v;

std::string s(sizeof(size_t), ' ');

if (new_entity->declaration().as_entity()) {

v = new_entity->id();

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

// no merges yet, because the python client doesn't support them

db->Merge(wopts, "t|" + std::to_string(new_entity->declaration().index_in_schema()), s);

/*{

std::string current;

// @todo this uses the same key-namespace as typedecl instances, not a direct conflict, but also not very clear

auto key = "t|" + std::to_string(new_entity->declaration().index_in_schema());

db->Get(rocksdb::ReadOptions{}, key, &current);

auto new_val = current + s;

db->Put(wopts, key, new_val);

}*/

}

// not only mapping also register type

v = new_entity->declaration().index_in_schema();

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

db->Put(wopts, (new_entity->declaration().as_entity() ? "i|" : "t|") + std::to_string(new_entity->id() ? new_entity->id() : new_entity->identity()) + "|_", s);

#endif

}

void IfcParse::impl::rocks_db_file_storage::remove_type_ref(IfcUtil::IfcBaseClass* new_entity)

{

#ifdef IFOPSH_WITH_ROCKSDB

if (new_entity->declaration().as_entity()) {

std::string s;

auto key = "t|" + std::to_string(new_entity->declaration().index_in_schema());

if (db->Get(rocksdb::ReadOptions{}, key, &s).ok()) {

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)new_entity->id()));

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

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

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

}

}

db->Delete(wopts, (new_entity->declaration().as_entity() ? "i|" : "t|") + std::to_string(new_entity->id() ? new_entity->id() : new_entity->identity()) + "|_");

#endif

}

namespace {

class StringBuilderVisitor : public boost::static_visitor<void> {

private:

StringBuilderVisitor(const StringBuilderVisitor&); //N/A

StringBuilderVisitor& operator=(const StringBuilderVisitor&); //N/A

std::ostream& data_;

template <typename T>

void serialize(const std::vector<T>& i) {

data_ << "(";

for (typename std::vector<T>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

data_ << *it;

}

data_ << ")";

}

// The REAL token definition from the IFC SPF standard does not necessarily match

// the output of the C++ ostream formatting operation.

// REAL = [ SIGN ] DIGIT { DIGIT } "." { DIGIT } [ "E" [ SIGN ] DIGIT { DIGIT } ] .

static std::string format_double(const double& d) {

std::ostringstream oss;

oss.imbue(std::locale::classic());

oss << std::setprecision(std::numeric_limits<double>::max_digits10) << d;

const std::string str = oss.str();

oss.str("");

std::string::size_type e = str.find('e');

if (e == std::string::npos) {

e = str.find('E');

}

const std::string mantissa = str.substr(0, e);

oss << mantissa;

if (mantissa.find('.') == std::string::npos) {

oss << ".";

}

if (e != std::string::npos) {

oss << "E";

oss << str.substr(e + 1);

}

return oss.str();

}

static std::string format_binary(const boost::dynamic_bitset<>& b) {

std::ostringstream oss;

oss.imbue(std::locale::classic());

oss.put('"');

oss << std::uppercase << std::hex << std::setw(1);

unsigned c = (unsigned)b.size();

unsigned n = (4 - (c % 4)) & 3;

oss << n;

for (unsigned i = 0; i < c + n;) {

unsigned accum = 0;

for (int j = 0; j < 4; ++j, ++i) {

unsigned bit = i < n ? 0 : b.test(c - i + n - 1) ? 1

: 0;

accum |= bit << (3 - j);

}

oss << accum;

}

oss.put('"');

return oss.str();

}

bool upper_;

public:

StringBuilderVisitor(std::ostream& stream, bool upper = false)

: data_(stream),

upper_(upper) {}

void operator()(const Blank& /*i*/) { data_ << "$"; }

void operator()(const Derived& /*i*/) { data_ << "*"; }

void operator()(const int& i) { data_ << i; }

void operator()(const bool& i) { data_ << (i ? ".T." : ".F."); }

void operator()(const boost::logic::tribool& i) { data_ << (i ? ".T." : (boost::logic::indeterminate(i) ? ".U." : ".F.")); }

void operator()(const double& i) { data_ << format_double(i); }

void operator()(const boost::dynamic_bitset<>& i) { data_ << format_binary(i); }

void operator()(const std::string& i) {

std::string s = i;

if (upper_) {

data_ << static_cast<std::string>(IfcCharacterEncoder(s));

} else {

data_ << '\'' << s << '\'';

}

}

void operator()(const std::vector<int>& i);

void operator()(const std::vector<double>& i);

void operator()(const std::vector<std::string>& i);

void operator()(const std::vector<boost::dynamic_bitset<>>& i);

void operator()(const EnumerationReference& i) {

data_ << "." << i.value() << ".";

}

void operator()(const IfcUtil::IfcBaseClass* const& i) {

if (i->declaration().as_entity() == nullptr || i->declaration().schema() == &Header_section_schema::get_schema()) {

i->toString(data_, upper_);

} else {

data_ << "#" << i->id();

}

}

void operator()(const aggregate_of_instance::ptr& i) {

data_ << "(";

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

if (it != i->begin()) {

data_ << ",";

}

(*this)(*it);

}

data_ << ")";

}

void operator()(const std::vector<std::vector<int>>& i);

void operator()(const std::vector<std::vector<double>>& i);

void operator()(const aggregate_of_aggregate_of_instance::ptr& i) {

data_ << "(";

for (aggregate_of_aggregate_of_instance::outer_it outer_it = i->begin(); outer_it != i->end(); ++outer_it) {

if (outer_it != i->begin()) {

data_ << ",";

}

data_ << "(";

for (aggregate_of_aggregate_of_instance::inner_it inner_it = outer_it->begin(); inner_it != outer_it->end(); ++inner_it) {

if (inner_it != outer_it->begin()) {

data_ << ",";

}

(*this)(*inner_it);

}

data_ << ")";

}

data_ << ")";

}

void operator()(const empty_aggregate_t& /*unused*/) const { data_ << "()"; }

void operator()(const empty_aggregate_of_aggregate_t& /*unused*/) const { data_ << "()"; }

};

template <>

void StringBuilderVisitor::serialize(const std::vector<std::string>& i) {

data_ << "(";

for (std::vector<std::string>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

std::string encoder = IfcCharacterEncoder(*it);

data_ << encoder;

}

data_ << ")";

}

template <>

void StringBuilderVisitor::serialize(const std::vector<double>& i) {

data_ << "(";

for (std::vector<double>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

data_ << format_double(*it);

}

data_ << ")";

}

template <>

void StringBuilderVisitor::serialize(const std::vector<boost::dynamic_bitset<>>& i) {

data_ << "(";

for (std::vector<boost::dynamic_bitset<>>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

data_ << format_binary(*it);

}

data_ << ")";

}

void StringBuilderVisitor::operator()(const std::vector<int>& i) { serialize(i); }

void StringBuilderVisitor::operator()(const std::vector<double>& i) { serialize(i); }

void StringBuilderVisitor::operator()(const std::vector<std::string>& i) { serialize(i); }

void StringBuilderVisitor::operator()(const std::vector<boost::dynamic_bitset<>>& i) { serialize(i); }

void StringBuilderVisitor::operator()(const std::vector<std::vector<int>>& i) {

data_ << "(";

for (std::vector<std::vector<int>>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

serialize(*it);

}

data_ << ")";

}

void StringBuilderVisitor::operator()(const std::vector<std::vector<double>>& i) {

data_ << "(";

for (std::vector<std::vector<double>>::const_iterator it = i.begin(); it != i.end(); ++it) {

if (it != i.begin()) {

data_ << ",";

}

serialize(*it);

}

data_ << ")";

}

}

//

// Returns a string representation of the entity

// Note that this initializes the entity if it is not initialized

//

void IfcEntityInstanceData::toString(void* storage, const IfcParse::declaration* decl, std::size_t identity, std::ostream& ss, bool upper) const {

ss.imbue(std::locale::classic());

ss << "(";

StringBuilderVisitor vis(ss, upper);

// In almost all cases, storage is initialized with the size of the schema declaration,

// apparently except in case of header entities and invalid in-line type declarations.

auto size = (decl && decl->as_entity() ? decl->as_entity()->attribute_count() : 1);

if (storage_) {

size = (std::min)(size, storage_->size());

}

for (size_t i = 0; i < size; ++i) {

if (i != 0) {

ss << ",";

}

if (has_attribute_value<Blank>(storage, decl, identity, i)) {

if (decl != nullptr && decl->as_entity() && decl->as_entity()->derived()[i]) {

ss << "*";

} else {

ss << "$";

}

} else {

apply_visitor(storage, decl, identity, vis, i);

}

}

ss << ")";

}

unsigned IfcUtil::IfcBaseEntity::set_id(const boost::optional<unsigned>& i) {

if (i) {

return id_ = *i;

}

return id_ = file_->FreshId();

}

namespace {

// @todo remove redundancy with python wrapper code (which is not identical due to

// different handling of enumerations)

IfcUtil::ArgumentType get_argument_type(const IfcParse::declaration* decl, size_t i) {

const IfcParse::parameter_type* pt = 0;

if (decl->as_entity() != nullptr) {

pt = decl->as_entity()->attribute_by_index(i)->type_of_attribute();

if (decl->as_entity()->derived()[i]) {

return IfcUtil::Argument_DERIVED;

}

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

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

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

return IfcUtil::Argument_ENUMERATION;

}

if (pt == 0) {

return IfcUtil::Argument_UNKNOWN;

}

return IfcUtil::from_parameter_type(pt);

}

} // namespace

class unregister_inverse_visitor {

private:

IfcFile& file_;

const IfcUtil::IfcBaseClass* data_;

public:

unregister_inverse_visitor(IfcFile& file, const IfcUtil::IfcBaseClass* data)

: file_(file),

data_(data) {}

void operator()(IfcUtil::IfcBaseClass* inst, int index) {

file_.unregister_inverse(data_->id(), data_->declaration().as_entity(), inst, index);

}

};

class register_inverse_visitor {