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

* *

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

#include "express.h"

#include "character_decoder.h"

#include "exception.h"

#include "file.h"

#include "logger.h"

#include "schema.h"

#include "si_prefix.h"

#include "file_reader.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 ifcopenshell;

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

template <typename Reader>

spf_lexer<Reader>::spf_lexer(Reader* stream_) {

stream = stream_;

decoder_ = new character_decoder<Reader>(stream_);

}

template <typename Reader>

spf_lexer<Reader>::~spf_lexer() {

delete decoder_;

}

template <typename Reader>

size_t spf_lexer<Reader>::skip_whitespace() 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;

}

template <typename Reader>

size_t spf_lexer<Reader>::skip_comment() 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;

}

template <typename Reader>

std::string& spf_lexer<Reader>::get_temp_string() const {

const size_t idx = pool_index++;

const size_t slice = idx >> 4;

const size_t offset = idx & 0xF;

while (stringpool_.size() <= slice) {

stringpool_.push_back(std::make_unique<std::array<std::string, 16>>());

}

// std::wcout << "Num contexts: " << idx << std::endl;

return (*stringpool_[slice])[offset];

}

namespace {

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

char* pEnd;

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

if (*pEnd != 0) {

return false;

}

val = (int)result;

return true;

}

bool parse_float_(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;

}

} // namespace

namespace SWAR {

constexpr uint32_t ONES32 = 0x01010101u;

constexpr uint32_t HIGHS32 = 0x80808080u;

constexpr uint64_t ONES = 0x0101010101010101ull;

constexpr uint64_t HIGHS = 0x8080808080808080ull;

constexpr uint64_t splat(unsigned char c) {

return ONES * c;

}

inline uint32_t has_zero_byte(uint32_t x) {

return (x - ONES32) & ~x & HIGHS32;

}

inline uint64_t has_zero_byte(uint64_t x) {

return (x - ONES) & ~x & HIGHS;

}

inline uint32_t eq_mask(uint32_t x, uint32_t c) {

return has_zero_byte(x ^ c);

}

inline uint64_t eq_mask(uint64_t x, uint64_t c) {

return has_zero_byte(x ^ c);

}

namespace chars {

constexpr uint64_t lpar = splat('(');

constexpr uint64_t rpar = splat(')');

constexpr uint64_t eq = splat('=');

constexpr uint64_t comma = splat(',');

constexpr uint64_t semi = splat(';');

constexpr uint64_t slash = splat('/');

constexpr uint64_t space = splat(' ');

constexpr uint64_t cr = splat('\r');

constexpr uint64_t lf = splat('\n');

constexpr uint64_t tab = splat('\t');

constexpr uint64_t quote = splat('"');

constexpr uint64_t dot = splat('.');

} // namespace chars

template <bool IncludeDot = true>

inline uint64_t has_special_char(uint64_t x) {

return eq_mask(x, chars::lpar) |

eq_mask(x, chars::rpar) |

eq_mask(x, chars::eq) |

eq_mask(x, chars::comma) |

eq_mask(x, chars::semi) |

eq_mask(x, chars::slash) |

eq_mask(x, chars::space) |

eq_mask(x, chars::cr) |

eq_mask(x, chars::lf) |

eq_mask(x, chars::tab) |

eq_mask(x, chars::quote) |

(IncludeDot ? eq_mask(x, chars::dot) : uint64_t{0});

}

template <bool IncludeDot = true>

inline uint32_t has_special_char(uint32_t x) {

return eq_mask(x, static_cast<uint32_t>(chars::lpar)) |

eq_mask(x, static_cast<uint32_t>(chars::rpar)) |

eq_mask(x, static_cast<uint32_t>(chars::eq)) |

eq_mask(x, static_cast<uint32_t>(chars::comma)) |

eq_mask(x, static_cast<uint32_t>(chars::semi)) |

eq_mask(x, static_cast<uint32_t>(chars::slash)) |

eq_mask(x, static_cast<uint32_t>(chars::space)) |

eq_mask(x, static_cast<uint32_t>(chars::cr)) |

eq_mask(x, static_cast<uint32_t>(chars::lf)) |

eq_mask(x, static_cast<uint32_t>(chars::tab)) |

eq_mask(x, static_cast<uint32_t>(chars::quote)) |

(IncludeDot ? eq_mask(x, static_cast<uint32_t>(chars::dot)) : uint32_t{0});

}

}

//

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

//

template <typename Reader>

token spf_lexer<Reader>::next() {

if (stream->eof()) {

return token{};

}

auto pos = stream->tell();

char character = stream->read();

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

while ((skip_whitespace() != 0U) || (skip_comment() != 0U)) {

}

if (stream->eof()) {

return token{};

}

pos = stream->tell();

character = stream->read();

}

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

if (character == '(' ||

character == ')' ||

character == '=' ||

character == ',' ||

character == ';' ||

character == '$' ||

character == '*')

{

return token(pos, character);

}

auto& str = get_temp_string();

if (character == '\'') {

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

str = *decoder_;

return token(pos, token::Token_STRING, str);

} else {

auto ttype = token::Token_NONE;

if (character == '"' || character == '.') {

if (character == '"') {

ttype = token::Token_BINARY;

} else {

ttype = token::Token_ENUMERATION;

}

str.clear();

} else if (character == '#') {

ttype = token::Token_IDENTIFIER;

str.clear();

} else {

str.assign(&character, 1);

}

auto remaining = stream->remaining();

while (remaining) {

if (remaining >= 8) {

uint64_t x = stream->peek_u64();

if ((ttype == token::Token_NONE ? SWAR::has_special_char<false>(x) : SWAR::has_special_char<true>(x)) == 0) {

str.append(reinterpret_cast<const char*>(&x), 8);

stream->increment(8);

remaining -= 8;

continue;

}

}

if (remaining >= 4) {

uint32_t x = stream->peek_u32();

if ((ttype == token::Token_NONE ? SWAR::has_special_char<false>(x) : SWAR::has_special_char<true>(x)) == 0) {

str.append(reinterpret_cast<const char*>(&x), 4);

stream->increment(4);

remaining -= 4;

continue;

}

}

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

char character = stream->peek();

if (character == '(' ||

character == ')' ||

character == '=' ||

character == ',' ||

character == ';' ||

character == '/') {

break;

}

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

if ((ttype == token::Token_BINARY && character == '"') ||

(ttype == token::Token_ENUMERATION && character == '.')) {

// Skip

} else {

str.push_back(character);

}

}

stream->increment();

remaining -= 1;

}

if (ttype == token::Token_ENUMERATION && str.size() == 1 && (str[0] == 'T' || str[0] == 'F' || str[0] == 'U')) {

pop_pool_entry();

return token(pos, token::Token_BOOL, str[0]);

} else if (ttype == token::Token_IDENTIFIER) {

int int_val;

if (!parse_int_(str.c_str(), int_val)) {

throw invalid_token_exception(pos, str, "instance name");

}

pop_pool_entry();

return token(pos, ttype, int_val);

} else if (ttype == token::Token_NONE && !str.empty()) {

int int_val;

double float_val;

auto& first = str.front();

if ((first >= 'A' && first <= 'Z') || (first >= 'a' && first <= 'z')) {

ttype = token::Token_KEYWORD;

return token(pos, ttype, str);

} else if (parse_int_(str.c_str(), int_val)) {

ttype = token::Token_INT;

pop_pool_entry();

return token(pos, ttype, int_val);

} else if (parse_float_(str.c_str(), float_val)) {

ttype = token::Token_FLOAT;

pop_pool_entry();

return token(pos, float_val);

}

} else if (ttype == token::Token_BINARY || ttype == token::Token_ENUMERATION) {

return token(pos, ttype, str);

}

throw invalid_token_exception(pos, str, "valid token");

}

}

template class spf_lexer<file_reader<full_buffer_impl>>;

template class spf_lexer<file_reader<paged_file_impl>>;

template class spf_lexer<file_reader<pushed_sequential_impl>>;

#ifdef USE_MMAP

template class spf_lexer<file_reader<mmap_impl>>;

#endif

bool token::is_operator() {

return type == Token_OPERATOR;

}

bool token::is_operator(char character) {

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

}

bool token::is_identifier() {

return type == Token_IDENTIFIER;

}

bool token::is_string() {

return type == Token_STRING;

}

bool token::is_enumeration() {

// @nb this is a bit confusing?

return type == Token_ENUMERATION || type == Token_BOOL;

}

bool token::is_binary() {

return type == Token_BINARY;

}

bool token::is_keyword() {

return type == Token_KEYWORD;

}

bool token::is_int() {

return type == Token_INT;

}

bool token::is_bool() {

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

return type == Token_BOOL && value_char != 'U';

}

bool token::is_logical() {

return type == Token_BOOL;

}

bool token::is_float() {

#ifdef PERMISSIVE_FLOAT

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

return type == Token_FLOAT || type == Token_INT;

#else

return type == Token_FLOAT;

#endif

}

int token::as_int() {

if (type != Token_INT) {

throw invalid_token_exception(start_pos, to_string(), "integer");

}

return value_int;

}

unsigned token::as_identifier() {

if (type != Token_IDENTIFIER) {

throw invalid_token_exception(start_pos, to_string(), "instance name");

}

return (unsigned) value_int;

}

bool token::as_bool() {

if (type != Token_BOOL) {

throw invalid_token_exception(start_pos, to_string(), "boolean");

}

return value_char == 'T';

}

boost::logic::tribool token::as_logical() {

if (type != Token_BOOL) {

throw invalid_token_exception(start_pos, to_string(), "logical");

}

if (value_int == 'F') {

return false;

}

if (value_int == 'T') {

return true;

}

return boost::logic::indeterminate;

}

double token::as_float() {

#ifdef PERMISSIVE_FLOAT

if (type == Token_INT) {

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

return value_int;

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

#endif

if (type == Token_FLOAT) {

return value_double;

}

throw invalid_token_exception(start_pos, to_string(), "real");

}

const std::string& token::as_string() {

if (is_string() || is_enumeration() || is_binary() || is_keyword()) {

// @todo quotes

return *value_string;

}

throw invalid_token_exception(start_pos, to_string(), "string");

}

boost::dynamic_bitset<> token::as_binary() {

const std::string& str = as_string();

if (str.empty()) {

throw exception("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 exception("token is not a valid binary sequence");

}

++it;

unsigned i = (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 token::to_string() {

std::string result;

if (type == Token_OPERATOR || type == Token_BOOL) {

result.push_back(value_char);

} else if (type == Token_INT) {

result = std::to_string(value_int);

} else if (type == Token_FLOAT) {

std::ostringstream oss;

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

result = oss.str();

} else {

return as_string();

}

return result;

}

//

// Reads the arguments from a list of token

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

//

template <typename Reader>

void ifcopenshell::impl::in_memory_file_storage::load(ifcopenshell::spf_lexer<Reader>* tokens, std::optional<size_t> entity_instance_name, const ifcopenshell::entity* entity, parse_context& context, int attribute_index) {

token next = tokens->next();

size_t attribute_index_within_data = 0;

size_t return_value = 0;

while (next) {

if (next.is_operator(',')) {

if (attribute_index == -1) {

attribute_index_within_data += 1;

}

} else if (next.is_operator(')')) {

break;

} else if (next.is_operator('(')) {

return_value++;

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

} else {

return_value++;

if (next.is_identifier() && entity && entity_instance_name) {

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

}

if (next.is_keyword()) {

try {

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

parse_context ps(&context_pool_);

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(tokens, entity_instance_name, entity, ps, attribute_index == -1 ? (int)attribute_index_within_data : attribute_index);

express::Base simple_type_instance(read_simple_type_instances.emplace_back(

ps.construct(file, entity_instance_name, *references_to_resolve, decl, std::nullopt, attribute_index == -1 ? (int)attribute_index_within_data : attribute_index))

);

// @todo do we need express::Base here? Or should we just push instance_data?

context.push(simple_type_instance);

} catch (exception& e) {

logger::message(logger::LOG_ERROR, std::string(e.what()) + " at offset " + std::to_string(next.start_pos));

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

return_value--;

}

} else {

context.push(next);

}

}

next = tokens->next();

}

}

template <typename Reader>

void ifcopenshell::impl::in_memory_file_storage::try_read_semicolon(ifcopenshell::spf_lexer<Reader>* tokens) const {

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

token semilocon = tokens->next();

if (!semilocon.is_operator(';')) {

tokens->stream->seek(old_offset);

}

}

void ifcopenshell::impl::in_memory_file_storage::register_inverse(unsigned id_from, const ifcopenshell::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 ifcopenshell::impl::in_memory_file_storage::unregister_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, const express::Base& 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 ifcopenshell::exception("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 ifcopenshell::impl::rocks_db_file_storage::register_inverse(unsigned id_from, const ifcopenshell::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 ifcopenshell::impl::rocks_db_file_storage::unregister_inverse(unsigned id_from, const ifcopenshell::entity* from_entity, const express::Base& 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 ifcopenshell::impl::rocks_db_file_storage::add_type_ref(const express::Base& 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 ifcopenshell::impl::rocks_db_file_storage::remove_type_ref(const express::Base& 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>::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>(character_encoder(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 enumeration_reference& i) {

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

}

void operator()(const express::Base& i) {

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

i.to_string(data_, upper_);

} else {

data_ << "#" << i.id();

}

}

void operator()(const std::vector<express::Base>& i) {

data_ << "(";

for (auto 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 std::vector<std::vector<express::Base>>& i) {

data_ << "(";

for (auto outer_it = i.begin(); outer_it != i.end(); ++outer_it) {

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

data_ << ",";

}

data_ << "(";

for (auto 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 = character_encoder(*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 instance_data::to_string(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 = (declaration_ && declaration_->as_entity() ? declaration_->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>(i)) {

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

ss << "*";

} else {

ss << "$";

}

} else {

get_attribute_value(i).apply_visitor(vis);

}

}

ss << ")";

}

/*

unsigned ifcopenshell::IfcBaseEntity::set_id(const std::optional<unsigned>& i) {

if (i) {

return id_ = *i;

}

return id_ = file_->fresh_id();

}

*/

namespace {

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