Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-19 19:54:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial attempt at new python wrapper

Browse Source
This commit is contained in:
Thomas Krijnen
2012-10-21 17:54:09 +02:00
parent da616ffd64
commit 509c34d66a
29 changed files with 3358 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ifcparse/ArgumentType.h
+10
View File
@@ -0,0 +1,10 @@
#ifndef ARGUMENTTYPE_H
#define ARGUMENTTYPE_H
namespace IfcUtil {
enum ArgumentType {
Argument_INT, Argument_BOOL, Argument_DOUBLE, Argument_STRING, Argument_VECTOR_INT, Argument_VECTOR_DOUBLE, Argument_VECTOR_STRING, Argument_ENTITY, Argument_ENTITY_LIST, Argument_ENUMERATION, Argument_UNKNOWN
};
}
#endif
src/ifcparse/Ifc2x3-rt.cpp
+2055
View File
File diff suppressed because it is too large Load Diff
src/ifcparse/Ifc2x3-rt.h
+42
View File
@@ -0,0 +1,42 @@
/********************************************************************************
* *
* 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/>. *
* *
********************************************************************************/
/********************************************************************************
* *
* This file has been generated from IFC2X3_TC1.exp. Do not make modifications *
* but instead modify the python script that has been used to generate this. *
* *
********************************************************************************/
#ifndef IFC2X3RT_H
#define IFC2X3RT_H
#include "../ifcparse/ArgumentType.h"
namespace Ifc2x3 {
namespace Type {
int GetAttributeCount(Enum t);
int GetAttributeIndex(Enum t, const std::string& a);
IfcUtil::ArgumentType GetAttributeType(Enum t, unsigned char a);
const std::string& GetAttributeName(Enum t, unsigned char a);
bool GetAttributeOptional(Enum t, unsigned char a);
}}
#endif
src/ifcparse/Ifc2x3.cpp
+9 -6
View File
@@ -24,10 +24,11 @@
* *
********************************************************************************/
#include "Ifc2x3.h"
#include "IfcException.h"
#include "IfcWrite.h"
#include "IfcWritableEntity.h"
#include "../ifcparse/Ifc2x3.h"
#include "../ifcparse/IfcException.h"
#include "../ifcparse/IfcWrite.h"
#include "../ifcparse/IfcWritableEntity.h"
#include "../ifcparse/ArgumentType.h"
using namespace Ifc2x3;
using namespace IfcParse;
@@ -805,7 +806,7 @@ std::string Type::ToString(Enum v) {
std::map<std::string,Type::Enum> string_map;
void Ifc2x3::InitStringMap() {
string_map["IFCABSORBEDDOSEMEASURE" ] = Type::IfcAbsorbedDoseMeasure;
string_map["IFCABSORBEDDOSEMEASURE" ] = Type::IfcAbsorbedDoseMeasure;
string_map["IFCACCELERATIONMEASURE" ] = Type::IfcAccelerationMeasure;
string_map["IFCAMOUNTOFSUBSTANCEMEASURE" ] = Type::IfcAmountOfSubstanceMeasure;
string_map["IFCANGULARVELOCITYMEASURE" ] = Type::IfcAngularVelocityMeasure;
@@ -1563,8 +1564,10 @@ void Ifc2x3::InitStringMap() {
string_map["IFCWORKSCHEDULE" ] = Type::IfcWorkSchedule;
string_map["IFCZSHAPEPROFILEDEF" ] = Type::IfcZShapeProfileDef;
string_map["IFCZONE" ] = Type::IfcZone;
}
Type::Enum Type::FromString(const std::string& s) {
if (string_map.empty()) ::Ifc2x3::InitStringMap();
std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
else return it->second;
@@ -12008,4 +12011,4 @@ bool IfcZone::is(Type::Enum v) const { return v == Type::IfcZone || IfcGroup::is
Type::Enum IfcZone::type() const { return Type::IfcZone; }
Type::Enum IfcZone::Class() { return Type::IfcZone; }
IfcZone::IfcZone(IfcAbstractEntityPtr e) { if (!is(Type::IfcZone)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
IfcZone::IfcZone(IfcGloballyUniqueId v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, optional< IfcLabel > v3_Name, optional< IfcText > v4_Description, optional< IfcLabel > v5_ObjectType) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } ; if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } ; if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } ; entity = e; EntityBuffer::Add(this); }
IfcZone::IfcZone(IfcGloballyUniqueId v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, optional< IfcLabel > v3_Name, optional< IfcText > v4_Description, optional< IfcLabel > v5_ObjectType) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } ; if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } ; if (v5_ObjectType) { e->setArgument(4,(*v5_ObjectType)); } else { e->setArgument(4); } ; entity = e; EntityBuffer::Add(this); }
src/ifcparse/Ifc2x3.h
+2
View File
@@ -30,11 +30,13 @@
#include <string>
#include <vector>
#include <map>
#include <set>
#include <boost/optional.hpp>
#include "../ifcparse/IfcUtil.h"
#include "../ifcparse/IfcException.h"
#include "../ifcparse/ArgumentType.h"
#include "../ifcparse/Ifc2x3enum.h"
using namespace IfcUtil;
src/ifcparse/Ifc2x3enum.h
+2
View File
@@ -27,6 +27,8 @@
#ifndef IFC2X3ENUM_H
#define IFC2X3ENUM_H
#include "../ifcparse/ArgumentType.h"
namespace Ifc2x3 {
namespace Type {
src/ifcparse/IfcCharacterDecoder.cpp
+70 -1
View File
@@ -30,7 +30,7 @@
#include "../ifcparse/IfcCharacterDecoder.h"
#include "../ifcparse/IfcException.h"
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcSpfStream.h"
#define FIRST_SOLIDUS (1 << 1)
#define PAGE (1 << 2)
@@ -67,6 +67,7 @@
#define CLEAR_HEX(C) (C &= ~(HEX(1)&HEX(2)&HEX(3)&HEX(4)&HEX(5)&HEX(6)&HEX(7)&HEX(8)))
using namespace IfcParse;
using namespace IfcWrite;
void IfcCharacterDecoder::addChar(std::stringstream& s,const UChar32& ch) {
#ifdef HAVE_ICU
@@ -296,3 +297,71 @@ std::string IfcCharacterDecoder::compatibility_charset = "";
#else
char IfcCharacterDecoder::substitution_character = '_';
#endif
IfcCharacterEncoder::IfcCharacterEncoder(const std::string& input) {
#ifdef HAVE_ICU
if ( !converter) converter = ucnv_open("utf-8", &status);
#endif
str = input;
}
IfcCharacterEncoder::~IfcCharacterEncoder() {
#ifdef HAVE_ICU
if ( !converter) ucnv_close(converter);
converter = 0;
#endif
}
IfcCharacterEncoder::operator std::string() {
std::ostringstream oss;
oss.put('\'');
#ifdef HAVE_ICU
// Either 2 or 4 to uses \X2 or \X4 respectively.
// Currently hardcoded to 4, but \X2 might be
// sufficient for nearly all purposes.
const int num_bytes = 4;
const std::string num_bytes_str = std::string(1,num_bytes + 0x30);
UChar32 ch;
const char* source = str.c_str();
const char* limit = &*str.end();
bool in_extended = false;
while(source < limit) {
ch = ucnv_getNextUChar(converter, &source, limit, &status);
const bool within_spf_range = ch >= 0x20 && ch <= 0x7e;
if ( in_extended && within_spf_range ) {
oss << "\\X0\\";
} else if ( !in_extended && !within_spf_range ) {
oss << "\\X" << num_bytes_str << "\\";
}
if ( within_spf_range ) {
oss.put(ch);
if ( ch == '\\' || ch == '\'' ) oss.put(ch);
} else {
oss << std::hex << std::setw(num_bytes*2) << std::uppercase << std::setfill('0') << (int) ch;
}
in_extended = !within_spf_range;
}
if ( in_extended ) oss << "\\X0\\";
#else
for (std::string::const_iterator i = str.begin(); i != str.end(); ++i) {
char ch = *i;
if ( ch == '\\' || ch == '\'' ) oss.put(ch);
oss.put(ch);
}
#endif
oss.put('\'');
return oss.str();
}
#ifdef HAVE_ICU
UErrorCode IfcCharacterEncoder::status = U_ZERO_ERROR;
UConverter* IfcCharacterEncoder::converter = 0;
#endif
src/ifcparse/IfcCharacterDecoder.h
+18 -1
View File
@@ -36,7 +36,7 @@
typedef unsigned int UChar32;
#endif
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcSpfStream.h"
namespace IfcParse {
@@ -73,4 +73,21 @@ namespace IfcParse {
}
namespace IfcWrite {
class IfcCharacterEncoder {
private:
std::string str;
#ifdef HAVE_ICU
static UErrorCode status;
static UConverter* converter;
#endif
public:
IfcCharacterEncoder(const std::string& input);
~IfcCharacterEncoder();
operator std::string();
};
}
#endif
src/ifcparse/IfcFile.h
+70 -73
View File
@@ -1,81 +1,78 @@
/********************************************************************************
* *
* 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/>. *
* *
********************************************************************************/
/********************************************************************************
* *
* Reads a file in chunks of BUF_SIZE and provides functions to access its *
* contents randomly and character by character *
* *
********************************************************************************/
#ifndef IFCFILE_H
#define IFCFILE_H
#include <fstream>
#include <string>
#include <map>
// As of IfcOpenShell version 0.3.0 the paging functionality, which
// loads a file on disk into multiple chunks, has been disabled.
// It proved to be an inefficient way of working with large files,
// as often these did not facilitate to be parsed in a sequential
// manner efficiently, to enable the paging functionality uncomment
// the following statement.
//const int BUF_SIZE = (128 * 1024 * 1024);
#include "IfcUtil.h"
#include "IfcParse.h"
namespace IfcParse {
/// The IfcSpfStream class represents a ISO 10303-21 IFC-SPF file in memory.
/// The file is interpreted as a sequence of tokens which are lazily
/// interpreted only when requested. If the size of the file is
/// larger than BUF_SIZE, the file is split into seperate pages, of
/// which only one is simultaneously kept in memory, for files
/// that define their entities not in a sequential nature, this is
/// detrimental for the performance of the parser.
class IfcSpfStream {
private:
std::ifstream stream;
char* buffer;
unsigned int ptr;
unsigned int len;
void ReadBuffer(bool inc=true);
#ifdef BUF_SIZE
unsigned int offset;
bool paging;
#endif
public:
bool valid;
bool eof;
unsigned int size;
IfcSpfStream(const std::string& fn);
IfcSpfStream(std::istream& f, int len);
IfcSpfStream(void* data, int len);
/// Returns the character at the cursor
char Peek();
/// Returns the character at specified offset
char Read(unsigned int offset);
/// Increment the file cursor and reads new page if necessary
void Inc();
void Close();
/// Moves the file cursor to an arbitrary offset in the file
void Seek(unsigned int offset);
/// Returns the cursor position
unsigned int Tell();
};
typedef IfcUtil::IfcSchemaEntity IfcEntity;
//typedef IfcEntities IfcEntities;
typedef std::map<Ifc2x3::Type::Enum,IfcEntities> MapEntitiesByType;
typedef std::map<unsigned int,IfcEntity> MapEntityById;
typedef std::map<std::string,Ifc2x3::IfcRoot::ptr> MapEntityByGuid;
typedef std::map<unsigned int,IfcEntities> MapEntitiesByRef;
typedef std::map<unsigned int,unsigned int> MapOffsetById;
/// This class provides several static convenience functions and variables
/// and provide access to the entities in an IFC file
class IfcFile {
private:
MapEntityById byid;
MapEntitiesByType bytype;
MapEntitiesByRef byref;
MapEntityByGuid byguid;
MapOffsetById offsets;
unsigned int lastId;
unsigned int MaxId;
public:
typedef MapEntityById::const_iterator const_iterator;
IfcFile();
~IfcFile();
/// Returns the first entity in the file, this probably is the entity with the lowest id (EXPRESS ENTITY_INSTANCE_NAME)
const_iterator begin() const;
/// Returns the last entity in the file, this probably is the entity with the highes id (EXPRESS ENTITY_INSTANCE_NAME)
const_iterator end() const;
IfcParse::IfcSpfStream* file;
IfcParse::Tokens* tokens;
/// 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 EntitiesByType() {
IfcEntities e = EntitiesByType(T::Class());
typename T::list l ( new IfcTemplatedEntityList<T>() );
if ( e && e->Size() )
for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) {
l->push(reinterpret_pointer_cast<IfcUtil::IfcBaseClass,T>(*it));
}
return l;
}
/// 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
IfcEntities EntitiesByType(Ifc2x3::Type::Enum t);
/// 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
IfcEntities EntitiesByType(const std::string& t);
/// Returns all entities in the file that reference the id
IfcEntities EntitiesByReference(int id);
/// Returns the entity with the specified id
IfcEntity EntityById(int id);
/// Returns the entity with the specified GlobalId
Ifc2x3::IfcRoot::ptr EntityByGuid(const std::string& guid);
bool Init(const std::string& fn);
bool Init(std::istream& fn, int len);
bool Init(void* data, int len);
bool Init(IfcParse::IfcSpfStream* f);
unsigned int FreshId() { MaxId ++; return MaxId; }
void AddEntity(IfcUtil::IfcSchemaEntity e);
void AddEntities(IfcEntities es);
};
}
#endif
#endif
src/ifcparse/IfcParse.cpp
+20 -4
View File
@@ -24,9 +24,10 @@
#include "../ifcparse/IfcCharacterDecoder.h"
#include "../ifcparse/IfcParse.h"
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcException.h"
#include "../ifcparse/IfcUtil.h"
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcSpfStream.h"
#include "../ifcparse/IfcWritableEntity.h"
using namespace IfcParse;
@@ -468,7 +469,13 @@ TokenArgument::operator IfcUtil::IfcSchemaEntity() const { return token.first->f
TokenArgument::operator IfcEntities() const { throw IfcException("Argument is not a list of entities"); }
unsigned int TokenArgument::Size() const { return 1; }
ArgumentPtr TokenArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of arguments"); }
std::string TokenArgument::toString(bool upper) const { return TokenFunc::toString(token); }
std::string TokenArgument::toString(bool upper) const {
if ( upper && TokenFunc::isString(token) ) {
return IfcWrite::IfcCharacterEncoder(TokenFunc::asString(token));
} else {
return TokenFunc::toString(token);
}
}
bool TokenArgument::isNull() const { return TokenFunc::isOperator(token,'$'); }
//
// Functions for casting the EntityArgument to other types
@@ -488,10 +495,18 @@ ArgumentPtr EntityArgument::operator [] (unsigned int i) const { throw IfcExcept
std::string EntityArgument::toString(bool upper) const {
ArgumentPtr arg = entity->wrappedValue();
IfcParse::TokenArgument* token_arg = dynamic_cast<IfcParse::TokenArgument*>(arg);
std::string token_string = ( token_arg ) ? TokenFunc::toString(token_arg->token) : "";
const bool is_string = TokenFunc::isString(token_arg->token);
std::string token_string = token_arg ? (is_string
? TokenFunc::asString(token_arg->token)
: TokenFunc::toString(token_arg->token))
: std::string();
std::string dt = Ifc2x3::Type::ToString(entity->type());
if ( upper ) {
for (std::string::iterator p = dt.begin(); p != dt.end(); ++p ) *p = toupper(*p);
if (is_string) token_string = IfcWrite::IfcCharacterEncoder(token_string);
} else {
token_string.insert(token_string.begin(),'\'');
token_string.push_back('\'');
}
return dt + "(" + token_string + ")";
}
@@ -662,7 +677,8 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
if ( currentId ) {
try {
e = new Entity(currentId,this);
entity = Ifc2x3::SchemaEntity(e);
//entity = Ifc2x3::SchemaEntity(e);
entity = new Ifc::IfcUntypedEntity(e);
} catch (IfcException ex) {
currentId = 0;
Logger::Message(Logger::LOG_ERROR,ex.what());
src/ifcparse/IfcParse.h
+2 -66
View File
@@ -41,7 +41,8 @@
#include "../ifcparse/IfcCharacterDecoder.h"
#include "../ifcparse/IfcUtil.h"
#include "../ifcparse/Ifc2x3.h"
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcSpfStream.h"
#include "../ifcparse/IfcUntypedEntity.h"
namespace IfcParse {
@@ -210,71 +211,6 @@ namespace IfcParse {
bool isWritable();
};
typedef IfcUtil::IfcSchemaEntity IfcEntity;
//typedef IfcEntities IfcEntities;
typedef std::map<Ifc2x3::Type::Enum,IfcEntities> MapEntitiesByType;
typedef std::map<unsigned int,IfcEntity> MapEntityById;
typedef std::map<std::string,Ifc2x3::IfcRoot::ptr> MapEntityByGuid;
typedef std::map<unsigned int,IfcEntities> MapEntitiesByRef;
typedef std::map<unsigned int,unsigned int> MapOffsetById;
/// This class provides several static convenience functions and variables
/// and provide access to the entities in an IFC file
class IfcFile {
private:
MapEntityById byid;
MapEntitiesByType bytype;
MapEntitiesByRef byref;
MapEntityByGuid byguid;
MapOffsetById offsets;
unsigned int lastId;
unsigned int MaxId;
public:
typedef MapEntityById::const_iterator const_iterator;
IfcFile();
~IfcFile();
/// Returns the first entity in the file, this probably is the entity with the lowest id (EXPRESS ENTITY_INSTANCE_NAME)
const_iterator begin() const;
/// Returns the last entity in the file, this probably is the entity with the highes id (EXPRESS ENTITY_INSTANCE_NAME)
const_iterator end() const;
IfcParse::IfcSpfStream* file;
IfcParse::Tokens* tokens;
/// 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 EntitiesByType() {
IfcEntities e = EntitiesByType(T::Class());
typename T::list l ( new IfcTemplatedEntityList<T>() );
if ( e && e->Size() )
for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) {
l->push(reinterpret_pointer_cast<IfcUtil::IfcBaseClass,T>(*it));
}
return l;
}
/// 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
IfcEntities EntitiesByType(Ifc2x3::Type::Enum t);
/// 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
IfcEntities EntitiesByType(const std::string& t);
/// Returns all entities in the file that reference the id
IfcEntities EntitiesByReference(int id);
/// Returns the entity with the specified id
IfcEntity EntityById(int id);
/// Returns the entity with the specified GlobalId
Ifc2x3::IfcRoot::ptr EntityByGuid(const std::string& guid);
bool Init(const std::string& fn);
bool Init(std::istream& fn, int len);
bool Init(void* data, int len);
bool Init(IfcParse::IfcSpfStream* f);
unsigned int FreshId() { MaxId ++; return MaxId; }
void AddEntity(IfcUtil::IfcSchemaEntity e);
void AddEntities(IfcEntities es);
};
double UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v );
}
src/ifcparse/IfcSpfStream.h
+81
View File
@@ -0,0 +1,81 @@
/********************************************************************************
* *
* 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/>. *
* *
********************************************************************************/
/********************************************************************************
* *
* Reads a file in chunks of BUF_SIZE and provides functions to access its *
* contents randomly and character by character *
* *
********************************************************************************/
#ifndef IFCSPFSTREAM_H
#define IFCSPFSTREAM_H
#include <fstream>
#include <string>
// As of IfcOpenShell version 0.3.0 the paging functionality, which
// loads a file on disk into multiple chunks, has been disabled.
// It proved to be an inefficient way of working with large files,
// as often these did not facilitate to be parsed in a sequential
// manner efficiently, to enable the paging functionality uncomment
// the following statement.
//const int BUF_SIZE = (128 * 1024 * 1024);
namespace IfcParse {
/// The IfcSpfStream class represents a ISO 10303-21 IFC-SPF file in memory.
/// The file is interpreted as a sequence of tokens which are lazily
/// interpreted only when requested. If the size of the file is
/// larger than BUF_SIZE, the file is split into seperate pages, of
/// which only one is simultaneously kept in memory, for files
/// that define their entities not in a sequential nature, this is
/// detrimental for the performance of the parser.
class IfcSpfStream {
private:
std::ifstream stream;
char* buffer;
unsigned int ptr;
unsigned int len;
void ReadBuffer(bool inc=true);
#ifdef BUF_SIZE
unsigned int offset;
bool paging;
#endif
public:
bool valid;
bool eof;
unsigned int size;
IfcSpfStream(const std::string& fn);
IfcSpfStream(std::istream& f, int len);
IfcSpfStream(void* data, int len);
/// Returns the character at the cursor
char Peek();
/// Returns the character at specified offset
char Read(unsigned int offset);
/// Increment the file cursor and reads new page if necessary
void Inc();
void Close();
/// Moves the file cursor to an arbitrary offset in the file
void Seek(unsigned int offset);
/// Returns the cursor position
unsigned int Tell();
};
}
#endif
src/ifcparse/IfcUntypedEntity.cpp
+156
View File
@@ -0,0 +1,156 @@
#include <sstream>
#include "IfcWritableEntity.h"
#include "IfcUtil.h"
#include "IfcWrite.h"
#include "Ifc2x3-rt.h"
IfcWrite::IfcWritableEntity* Ifc::IfcUntypedEntity::writable_entity() {
IfcWrite::IfcWritableEntity* e;
if (entity->isWritable()) {
e = (IfcWrite::IfcWritableEntity*) entity;
} else {
entity = e = new IfcWrite::IfcWritableEntity(entity);
}
return e;
}
Ifc::IfcUntypedEntity::IfcUntypedEntity(const std::string& s) {
std::string S = s;
for (std::string::iterator i = S.begin(); i != S.end(); ++i ) *i = toupper(*i);
_type = Ifc2x3::Type::FromString(S);
entity = new IfcWrite::IfcWritableEntity(_type);
}
Ifc::IfcUntypedEntity::IfcUntypedEntity(IfcAbstractEntity* e) {
entity = e;
_type = e->type();
}
bool Ifc::IfcUntypedEntity::is(Ifc2x3::Type::Enum v) const {
Ifc2x3::Type::Enum _ty = _type;
if (v == _ty) return true;
while (_ty != -1) {
_ty = Ifc2x3::Type::Parent(_ty);
if (v == _ty) return true;
}
return false;
}
std::string Ifc::IfcUntypedEntity::is_a() const {
return Ifc2x3::Type::ToString(_type);
}
bool Ifc::IfcUntypedEntity::is_a(const std::string& s) const {
std::string S = s;
for (std::string::iterator i = S.begin(); i != S.end(); ++i ) *i = toupper(*i);
return is(Ifc2x3::Type::FromString(S));
}
Ifc2x3::Type::Enum Ifc::IfcUntypedEntity::type() const {
return _type;
}
unsigned int Ifc::IfcUntypedEntity::getArgumentCount() const {
return Ifc2x3::Type::GetAttributeCount(_type);
}
IfcUtil::ArgumentType Ifc::IfcUntypedEntity::getArgumentType(unsigned int i) const {
return Ifc2x3::Type::GetAttributeType(_type,i);
}
ArgumentPtr Ifc::IfcUntypedEntity::getArgument(unsigned int i) const {
return entity->getArgument(i);
}
const char* Ifc::IfcUntypedEntity::getArgumentName(unsigned int i) const {
return Ifc2x3::Type::GetAttributeName(_type,i).c_str();
}
void Ifc::IfcUntypedEntity::invalid_argument(unsigned int i, const std::string& t) {
const std::string arg_name = Ifc2x3::Type::GetAttributeName(_type,i);
throw IfcException(t + " is not a valid type for '" + arg_name + "'");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, int v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_INT) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"INT");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, bool v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_BOOL) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"BOOL");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, double v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_DOUBLE) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"DOUBLE");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, const std::string& a) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_STRING) {
writable_entity()->setArgument(i,a);
} else if (arg_type == Argument_ENUMERATION) {
writable_entity()->setArgument(i,a);
} else invalid_argument(i,"STRING");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, const std::vector<int>& v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_VECTOR_INT) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"LIST of INT");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, const std::vector<double>& v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_VECTOR_DOUBLE) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"LIST of DOUBLE");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, const std::vector<std::string>& v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_VECTOR_STRING) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"LIST of STRING");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, Ifc::IfcUntypedEntity* v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_ENTITY) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"ENTITY");
}
void Ifc::IfcUntypedEntity::setArgument(unsigned int i, IfcEntities v) {
IfcUtil::ArgumentType arg_type = Ifc2x3::Type::GetAttributeType(_type,i);
if (arg_type == Argument_ENTITY_LIST) {
writable_entity()->setArgument(i,v);
} else invalid_argument(i,"LIST of ENTITY");
}
std::pair<IfcUtil::ArgumentType,ArgumentPtr> Ifc::IfcUntypedEntity::get_argument(unsigned i) {
return std::pair<IfcUtil::ArgumentType,ArgumentPtr>(getArgumentType(i),getArgument(i));
}
std::pair<IfcUtil::ArgumentType,ArgumentPtr> Ifc::IfcUntypedEntity::get_argument(const std::string& a) {
return get_argument(Ifc2x3::Type::GetAttributeIndex(_type,a));
}
unsigned Ifc::IfcUntypedEntity::getArgumentIndex(const std::string& a) const {
return Ifc2x3::Type::GetAttributeIndex(_type,a);
}
std::string Ifc::IfcUntypedEntity::toString() {
return entity->toString(false);
}
bool Ifc::IfcUntypedEntity::is_valid() {
const unsigned arg_count = getArgumentCount();
bool valid = true;
std::ostringstream oss;
oss << "Argument ";
for (unsigned i = 0; i < arg_count; ++i) {
bool is_null = true;
try {
const Argument& arg = *getArgument(i);
is_null = arg.isNull();
} catch(IfcException) {}
if (!Ifc2x3::Type::GetAttributeOptional(_type,i) && is_null) {
if (!valid) {
oss << ", ";
}
oss << "\"" << getArgumentName(i) << "\"";
valid = false;
}
}
oss << " not optional";
if (!valid) {
throw IfcException(oss.str());
}
return valid;
}
src/ifcparse/IfcUntypedEntity.h
+51
View File
@@ -0,0 +1,51 @@
#ifndef IFCUNTYPEDENTITY_H
#define IFCUNTYPEDENTITY_H
#include <string>
#include "IfcUtil.h"
#include "IfcWrite.h"
#include "IfcWritableEntity.h"
namespace Ifc {
class IfcUntypedEntity : public IfcUtil::IfcBaseEntity {
private:
Ifc2x3::Type::Enum _type;
IfcWrite::IfcWritableEntity* writable_entity();
void invalid_argument(unsigned int i, const std::string& t);
public:
IfcUntypedEntity(const std::string& s);
IfcUntypedEntity(IfcAbstractEntity* e);
bool is(Ifc2x3::Type::Enum v) const;
Ifc2x3::Type::Enum type() const;
bool is_a(const std::string& s) const;
std::string is_a() const;
unsigned int getArgumentCount() const;
IfcUtil::ArgumentType getArgumentType(unsigned int i) const;
ArgumentPtr getArgument(unsigned int i) const;
const char* getArgumentName(unsigned int i) const;
unsigned getArgumentIndex(const std::string& a) const;
void setArgument(unsigned int i, int v);
void setArgument(unsigned int i, bool v);
void setArgument(unsigned int i, double v);
void setArgument(unsigned int i, const std::string& v);
void setArgument(unsigned int i, const std::vector<int>& v);
void setArgument(unsigned int i, const std::vector<double>& v);
void setArgument(unsigned int i, const std::vector<std::string>& v);
void setArgument(unsigned int i, IfcUntypedEntity* v);
void setArgument(unsigned int i, IfcEntities v);
std::string toString();
// TODO: Write as SWIG extension methods
std::pair<IfcUtil::ArgumentType,ArgumentPtr> get_argument(unsigned i);
std::pair<IfcUtil::ArgumentType,ArgumentPtr> get_argument(const std::string& a);
bool is_valid();
};
}
#endif
src/ifcparse/IfcUtil.h
+63 -5
View File
@@ -23,9 +23,13 @@
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include "../ifcparse/SharedPointer.h"
#include "../ifcparse/Ifc2x3enum.h"
#include "../ifcparse/ArgumentType.h"
#include "../ifcparse/IfcException.h"
class IfcAbstractEntity;
//typedef SHARED_PTR<IfcAbstractEntity> IfcAbstractEntityPtr;
@@ -47,12 +51,66 @@ inline T* reinterpret_pointer_cast(F* from) {
}
namespace IfcUtil {
enum ArgumentType {
Argument_INT, Argument_BOOL, Argument_DOUBLE, Argument_STRING, Argument_VECTOR_INT, Argument_VECTOR_DOUBLE, Argument_VECTOR_STRING, Argument_ENTITY, Argument_ENTITY_LIST, Argument_ENUMERATION, Argument_UNKNOWN
};
}
namespace IfcUtil {
class IfcEntityDescriptor {
public:
class IfcArgumentDescriptor
{
public:
std::string name;
bool optional;
ArgumentType type;
IfcArgumentDescriptor(const std::string& name, bool optional, ArgumentType type)
: name(name), optional(optional), type(type) {}
};
private:
Ifc2x3::Type::Enum type;
IfcEntityDescriptor* parent;
std::vector<IfcArgumentDescriptor> arguments;
unsigned argument_start() {
return parent ? parent->getArgumentCount() : 0;
}
IfcArgumentDescriptor& get_argument(unsigned i) {
if (i < arguments.size()) return arguments[i];
else throw IfcParse::IfcException("Argument out of range");
}
public:
IfcEntityDescriptor(Ifc2x3::Type::Enum type, IfcEntityDescriptor* parent)
: type(type), parent(parent) {}
void add(const std::string& name, bool optional, ArgumentType type) {
arguments.push_back(IfcArgumentDescriptor(name, optional, type));
}
unsigned getArgumentCount() {
return (parent ? parent->getArgumentCount() : 0) + arguments.size();
}
std::string& getArgumentName(unsigned i) {
const unsigned a = argument_start();
return i < a
? parent->getArgumentName(i)
: get_argument(i-a).name;
}
ArgumentType getArgumentType(unsigned i) {
const unsigned a = argument_start();
return i < a
? parent->getArgumentType(i)
: get_argument(i-a).type;
}
bool getArgumentOptional(unsigned i) {
const unsigned a = argument_start();
return i < a
? parent->getArgumentOptional(i)
: get_argument(i-a).optional;
}
unsigned getArgumentIndex(const std::string& s) {
unsigned a = argument_start();
for(std::vector<IfcArgumentDescriptor>::const_iterator i = arguments.begin(); i != arguments.end(); ++i) {
if (i->name == s) return a;
a++;
}
if (parent) return parent->getArgumentIndex(s);
throw IfcParse::IfcException(std::string("Argument ") + s + " not found on " + Ifc2x3::Type::ToString(type));
}
};
class IfcBaseClass {
public:
src/ifcparse/IfcWritableEntity.h
+2
View File
@@ -31,6 +31,8 @@
#ifndef IFCWRITABLEENTITY_H
#define IFCWRITABLEENTITY_H
#include <map>
#include "IfcUtil.h"
namespace IfcWrite {
src/ifcparse/IfcWrite.cpp
+60 -56
View File
@@ -17,9 +17,11 @@
* *
********************************************************************************/
#include "IfcParse.h"
#include "IfcWrite.h"
#include "IfcWritableEntity.h"
#include "../ifcparse/IfcParse.h"
#include "../ifcparse/IfcFile.h"
#include "../ifcparse/IfcWrite.h"
#include "../ifcparse/IfcWritableEntity.h"
#include "../ifcparse/IfcCharacterDecoder.h"
using namespace IfcWrite;
@@ -69,7 +71,7 @@ IfcEntities IfcWritableEntity::getInverse(Ifc2x3::Type::Enum c, int i, const std
}
std::string IfcWritableEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
ArgumentPtr IfcWritableEntity::getArgument (unsigned int i) { if ( i >= getArgumentCount() ) throw; return args[i]; }
ArgumentPtr IfcWritableEntity::getArgument (unsigned int i) { if ( i >= getArgumentCount() ) throw IfcParse::IfcException("Argument not set"); return args[i]; }
unsigned int IfcWritableEntity::getArgumentCount() {return args.size(); }
Ifc2x3::Type::Enum IfcWritableEntity::type() const { return _type; }
bool IfcWritableEntity::is(Ifc2x3::Type::Enum v) const { return _type == v; }
@@ -152,33 +154,33 @@ void IfcWritableEntity::setArgument(int i,const std::vector<int>& v){
arg_writable(i,true);
}
IfcWriteNullArgument::operator int() const { throw; }
IfcWriteNullArgument::operator bool() const { throw; }
IfcWriteNullArgument::operator double() const { throw; }
IfcWriteNullArgument::operator std::string() const { throw; }
IfcWriteNullArgument::operator std::vector<double>() const { throw; }
IfcWriteNullArgument::operator std::vector<int>() const { throw; }
IfcWriteNullArgument::operator std::vector<std::string>() const { throw; }
IfcWriteNullArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
IfcWriteNullArgument::operator IfcEntities() const { throw; }
IfcWriteNullArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator std::string() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteNullArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
bool IfcWriteNullArgument::isNull() const { return true; }
ArgumentPtr IfcWriteNullArgument::operator [] (unsigned int i) const { throw; }
ArgumentPtr IfcWriteNullArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
std::string IfcWriteNullArgument::toString(bool upper) const { return "$"; }
unsigned int IfcWriteNullArgument::Size() const { throw; }
unsigned int IfcWriteNullArgument::Size() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::IfcWriteEntityListArgument(const IfcEntities& v) { value = v; }
IfcWriteEntityListArgument::operator int() const { throw; }
IfcWriteEntityListArgument::operator bool() const { throw; }
IfcWriteEntityListArgument::operator double() const { throw; }
IfcWriteEntityListArgument::operator std::string() const { throw; }
IfcWriteEntityListArgument::operator std::vector<double>() const { throw; }
IfcWriteEntityListArgument::operator std::vector<int>() const { throw; }
IfcWriteEntityListArgument::operator std::vector<std::string>() const { throw; }
IfcWriteEntityListArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
IfcWriteEntityListArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator std::string() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEntityListArgument::operator IfcEntities() const { return value; }
bool IfcWriteEntityListArgument::isNull() const { return false; }
unsigned int IfcWriteEntityListArgument::Size() const { return value->Size(); }
ArgumentPtr IfcWriteEntityListArgument::operator [] (unsigned int i) const { throw; }
ArgumentPtr IfcWriteEntityListArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
std::string IfcWriteEntityListArgument::toString(bool upper) const {
std::ostringstream ss;
ss << "(";
@@ -196,19 +198,19 @@ std::string IfcWriteEntityListArgument::toString(bool upper) const {
}
IfcWriteEnumerationArgument::IfcWriteEnumerationArgument(int v, const char* c) {data=v; enumeration_value = c;}
IfcWriteEnumerationArgument::operator int() const { throw; }
IfcWriteEnumerationArgument::operator bool() const { throw; }
IfcWriteEnumerationArgument::operator double() const { throw; }
IfcWriteEnumerationArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator std::string() const { return std::string(enumeration_value); }
IfcWriteEnumerationArgument::operator std::vector<double>() const { throw; }
IfcWriteEnumerationArgument::operator std::vector<int>() const { throw; }
IfcWriteEnumerationArgument::operator std::vector<std::string>() const { throw; }
IfcWriteEnumerationArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
IfcWriteEnumerationArgument::operator IfcEntities() const { throw; }
IfcWriteEnumerationArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteEnumerationArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
bool IfcWriteEnumerationArgument::isNull() const { return false; }
ArgumentPtr IfcWriteEnumerationArgument::operator [] (unsigned int i) const { throw; }
ArgumentPtr IfcWriteEnumerationArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
std::string IfcWriteEnumerationArgument::toString(bool upper) const { return std::string(".") + enumeration_value + '.';}
unsigned int IfcWriteEnumerationArgument::Size() const { throw; }
unsigned int IfcWriteEnumerationArgument::Size() const { throw IfcParse::IfcException("Invalid cast"); }
IfcWriteIntegralArgument::IfcWriteIntegralArgument(int v) {data=new int(v); type = Argument_INT;}
IfcWriteIntegralArgument::IfcWriteIntegralArgument(bool v) {data=new bool(v); type = Argument_BOOL;}
@@ -245,15 +247,15 @@ IfcWriteIntegralArgument::~IfcWriteIntegralArgument() {
break;
}
}
IfcWriteIntegralArgument::operator int() const { if ( type != Argument_INT ) throw; return *(int*)data; }
IfcWriteIntegralArgument::operator bool() const { if ( type != Argument_BOOL ) throw; return *(bool*)data; }
IfcWriteIntegralArgument::operator double() const { if ( type != Argument_DOUBLE ) throw; return *(double*)data; }
IfcWriteIntegralArgument::operator std::string() const { if ( type != Argument_STRING ) throw; return *(std::string*)data; }
IfcWriteIntegralArgument::operator std::vector<double>() const { if ( type != Argument_VECTOR_DOUBLE ) throw; return *(std::vector<double>*)data; }
IfcWriteIntegralArgument::operator std::vector<int>() const { if ( type != Argument_VECTOR_INT ) throw; return *(std::vector<int>*)data; }
IfcWriteIntegralArgument::operator std::vector<std::string>() const { if ( type != Argument_VECTOR_STRING ) throw; return *(std::vector<std::string>*)data; }
IfcWriteIntegralArgument::operator IfcUtil::IfcSchemaEntity() const { if ( type != Argument_ENTITY ) throw; return (IfcUtil::IfcSchemaEntity)data; }
IfcWriteIntegralArgument::operator IfcEntities() const { throw; }
IfcWriteIntegralArgument::operator int() const { if ( type != Argument_INT ) throw IfcParse::IfcException("Invalid cast"); return *(int*)data; }
IfcWriteIntegralArgument::operator bool() const { if ( type != Argument_BOOL ) throw IfcParse::IfcException("Invalid cast"); return *(bool*)data; }
IfcWriteIntegralArgument::operator double() const { if ( type != Argument_DOUBLE ) throw IfcParse::IfcException("Invalid cast"); return *(double*)data; }
IfcWriteIntegralArgument::operator std::string() const { if ( type != Argument_STRING ) throw IfcParse::IfcException("Invalid cast"); return *(std::string*)data; }
IfcWriteIntegralArgument::operator std::vector<double>() const { if ( type != Argument_VECTOR_DOUBLE ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<double>*)data; }
IfcWriteIntegralArgument::operator std::vector<int>() const { if ( type != Argument_VECTOR_INT ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<int>*)data; }
IfcWriteIntegralArgument::operator std::vector<std::string>() const { if ( type != Argument_VECTOR_STRING ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<std::string>*)data; }
IfcWriteIntegralArgument::operator IfcUtil::IfcSchemaEntity() const { if ( type != Argument_ENTITY ) throw IfcParse::IfcException("Invalid cast"); return (IfcUtil::IfcSchemaEntity)data; }
IfcWriteIntegralArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
bool IfcWriteIntegralArgument::isNull() const { return false; }
unsigned int IfcWriteIntegralArgument::Size() const {
switch ( type ) {
@@ -267,11 +269,11 @@ unsigned int IfcWriteIntegralArgument::Size() const {
return ((std::vector<std::string>*) data)->size();
break;
default:
throw;
throw IfcParse::IfcException("Invalid cast");
break;
}
}
ArgumentPtr IfcWriteIntegralArgument::operator [] (unsigned int i) const { throw; }
ArgumentPtr IfcWriteIntegralArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
std::string IfcWriteIntegralArgument::toString(bool upper) const {
std::ostringstream ss;
switch ( type ) {
@@ -284,10 +286,12 @@ std::string IfcWriteIntegralArgument::toString(bool upper) const {
case Argument_DOUBLE:
ss << *(double*) data;
break;
case Argument_STRING:
ss << '\'' << *(std::string*) data << '\'';
break;
case Argument_VECTOR_INT:
case Argument_STRING: {
std::string d = *(std::string*) data;
if ( upper ) d = IfcCharacterEncoder(d);
ss << d;
break;
} case Argument_VECTOR_INT:
ss << "(";
{const std::vector<int>& v = *(std::vector<int>*) data;
for ( std::vector<int>::const_iterator it = v.begin(); it != v.end(); ++ it ) {
@@ -322,16 +326,16 @@ std::string IfcWriteIntegralArgument::toString(bool upper) const {
ss << "#" << e->id();
}}
break;
default: throw;
default: throw IfcParse::IfcException("Invalid cast");
}
return ss.str();
}
IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum,int,const std::string &) {throw;}
IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum) {throw;}
IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum,int,const std::string &) {throw IfcParse::IfcException("Invalid cast");}
IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum) {throw IfcParse::IfcException("Invalid cast");}
std::string IfcSelectHelperEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
ArgumentPtr IfcSelectHelperEntity::getArgument(unsigned int i) {
if ( i != 0 ) throw;
if ( i != 0 ) throw IfcParse::IfcException("Invalid cast");
return arg;
}
unsigned int IfcSelectHelperEntity::getArgumentCount() { return 1; }
@@ -346,8 +350,8 @@ std::string IfcSelectHelperEntity::toString(bool upper) {
ss << dt << "(" << arg->toString(upper) << ")";
return ss.str();
}
unsigned int IfcSelectHelperEntity::id() { throw; }
bool IfcSelectHelperEntity::isWritable() { throw; }
unsigned int IfcSelectHelperEntity::id() { throw IfcParse::IfcException("Invalid cast"); }
bool IfcSelectHelperEntity::isWritable() { throw IfcParse::IfcException("Invalid cast"); }
IfcSelectHelper::IfcSelectHelper(const std::string& v, Ifc2x3::Type::Enum t) {
IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
@@ -361,7 +365,7 @@ IfcSelectHelper::IfcSelectHelper(int v, Ifc2x3::Type::Enum t) {
IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
this->entity = new IfcSelectHelperEntity(t,a);
}
IfcSelectHelper::IfcSelectHelper(float v, Ifc2x3::Type::Enum t) {
IfcSelectHelper::IfcSelectHelper(double v, Ifc2x3::Type::Enum t) {
IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
this->entity = new IfcSelectHelperEntity(t,a);
}
src/ifcparse/IfcWrite.h
+1 -1
View File
@@ -170,7 +170,7 @@ namespace IfcWrite {
IfcSelectHelper(const std::string& v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcText);
IfcSelectHelper(const char* const v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcText);
IfcSelectHelper(int v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcInteger);
IfcSelectHelper(float v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcReal);
IfcSelectHelper(double v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcReal);
IfcSelectHelper(bool v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcBoolean);
bool is(Ifc2x3::Type::Enum t) const;
Ifc2x3::Type::Enum type() const;