Exemplo n.º 1
0
void IfcEntityList::push(const IfcEntityList::ptr& l) {
	if (l) {
		for( it i = l->begin(); i != l->end(); ++i  ) {
			if ( *i ) ls.push_back(*i);
		}
	}
}
IfcSchema::IfcProject* IfcHierarchyHelper::addProject(IfcSchema::IfcOwnerHistory* owner_hist) {
	IfcSchema::IfcRepresentationContext::list::ptr rep_contexts (new IfcSchema::IfcRepresentationContext::list);

	IfcEntityList::ptr units (new IfcEntityList);
	IfcSchema::IfcDimensionalExponents* dimexp = new IfcSchema::IfcDimensionalExponents(0, 0, 0, 0, 0, 0, 0);
	IfcSchema::IfcSIUnit* unit1 = new IfcSchema::IfcSIUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT, 
		IfcSchema::IfcSIPrefix::IfcSIPrefix_MILLI, IfcSchema::IfcSIUnitName::IfcSIUnitName_METRE);
	IfcSchema::IfcSIUnit* unit2a = new IfcSchema::IfcSIUnit(IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, 
		boost::none, IfcSchema::IfcSIUnitName::IfcSIUnitName_RADIAN);
	IfcSchema::IfcMeasureWithUnit* unit2b = new IfcSchema::IfcMeasureWithUnit(
		new IfcSchema::IfcPlaneAngleMeasure(0.017453293), unit2a);
	IfcSchema::IfcConversionBasedUnit* unit2 = new IfcSchema::IfcConversionBasedUnit(dimexp, 
		IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, "Degrees", unit2b);

	units->push(unit1);
	units->push(unit2);

	IfcSchema::IfcUnitAssignment* unit_assignment = new IfcSchema::IfcUnitAssignment(units);

	IfcSchema::IfcProject* project = new IfcSchema::IfcProject(IfcParse::IfcGlobalId(), owner_hist, boost::none, boost::none, 
		boost::none, boost::none, boost::none, rep_contexts, unit_assignment);

	addEntity(dimexp);
	addEntity(unit1);
	addEntity(unit2a);
	addEntity(unit2b);
	addEntity(unit2);
	addEntity(unit_assignment);
	addEntity(project);

	return project;
}
	void operator()(const IfcEntityList::ptr& i) { 
		data << "(";
		for (IfcEntityList::it it = i->begin(); it != i->end(); ++it) {
			if (it != i->begin()) data << ",";
			(*this)(*it);
		}
		data << ")";
	}
Exemplo n.º 4
0
bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, IfcRepresentationShapeItems& shapes) {
    IfcEntityList::ptr shells = l->SbsmBoundary();
    const SurfaceStyle* collective_style = get_style(l);
    for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) {
        TopoDS_Shape s;
        const SurfaceStyle* shell_style = 0;
        if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
            shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
        }
        if (convert_shape(*it,s)) {
            shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
        }
    }
    return true;
}
void IfcWritableEntity::setArgument(int i,IfcEntityList::ptr v){
	if ( v.get() ) {
		_setArgument(i, v);
	} else {
		_setArgument(i, boost::none);
	}
}
Exemplo n.º 6
0
bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresentationShapeItems& shapes) {
    IfcEntityList::ptr elements = l->Elements();
    if ( !elements->size() ) return false;
    bool part_succes = false;
    const IfcGeom::SurfaceStyle* parent_style = get_style(l);
    for ( IfcEntityList::it it = elements->begin(); it != elements->end(); ++ it ) {
        IfcSchema::IfcGeometricSetSelect* element = *it;
        TopoDS_Shape s;
        if (convert_shape(element, s)) {
            part_succes = true;
            const IfcGeom::SurfaceStyle* style = 0;
            if (element->is(IfcSchema::Type::IfcPoint)) {
                style = get_style((IfcSchema::IfcPoint*) element);
            } else if (element->is(IfcSchema::Type::IfcCurve)) {
                style = get_style((IfcSchema::IfcCurve*) element);
            } else if (element->is(IfcSchema::Type::IfcSurface)) {
                style = get_style((IfcSchema::IfcSurface*) element);
            }
            shapes.push_back(IfcRepresentationShapeItem(s, style ? style : parent_style));
        }
    }
    return part_succes;
}
	int operator()(const IfcEntityList::ptr& i) const { return i->size(); }
void IfcWritableEntity::setArgument(int i, Argument* a) {
	IfcWrite::IfcWriteArgument* wa = new IfcWrite::IfcWriteArgument(this);
	IfcUtil::ArgumentType attr_type = a->type();
	switch(attr_type) {
	case IfcUtil::Argument_NULL:
		this->setArgument(i);
		break;
	case IfcUtil::Argument_DERIVED:
		this->setArgumentDerived(i);
		break;
	case IfcUtil::Argument_INT:
		this->setArgument(i, static_cast<int>(*a));
		break;
	case IfcUtil::Argument_BOOL:
		this->setArgument(i, static_cast<bool>(*a));
		break;
	case IfcUtil::Argument_DOUBLE:
		this->setArgument(i, static_cast<double>(*a));
		break;
	case IfcUtil::Argument_STRING:
		this->setArgument(i, static_cast<std::string>(*a));
		break; 
	case IfcUtil::Argument_VECTOR_INT: {
		std::vector<int> attr_value = *a;
		this->setArgument(i, attr_value); }
		break;
	case IfcUtil::Argument_VECTOR_DOUBLE: {
		std::vector<double> attr_value = *a;
		this->setArgument(i, attr_value); }
		break;
	case IfcUtil::Argument_VECTOR_STRING: {
		std::vector<std::string> attr_value = *a;
		this->setArgument(i, attr_value); }
		break;
	case IfcUtil::Argument_ENUMERATION: {
		IfcSchema::Type::Enum ty = IfcSchema::Type::GetAttributeEntity(_type, i);
		std::string enum_literal = a->toString();
		// Remove leading and trailing '.'
		enum_literal = enum_literal.substr(1, enum_literal.size() - 2);
		std::pair<const char*, int> enum_ref = IfcSchema::Type::GetEnumerationIndex(ty, enum_literal);
		this->setArgument(i, enum_ref.second, enum_ref.first); }
		break; 
	case IfcUtil::Argument_ENTITY: {
		this->setArgument(i, static_cast<IfcUtil::IfcBaseClass*>(*a)); }
		break; 
	case IfcUtil::Argument_ENTITY_LIST: {
		IfcEntityList::ptr instances = *a;
		IfcEntityList::ptr mapped_instances(new IfcEntityList);
		for (IfcEntityList::it it = instances->begin(); it != instances->end(); ++it) {
			mapped_instances->push(*it);
		}
		this->setArgument(i, mapped_instances); }
		break; 
	case IfcUtil::Argument_ENTITY_LIST_LIST: {
		IfcEntityListList::ptr instances = *a;
		IfcEntityListList::ptr mapped_instances(new IfcEntityListList);
		for (IfcEntityListList::outer_it it = instances->begin(); it != instances->end(); ++it) {
			std::vector<IfcUtil::IfcBaseClass*> inner;
			for (IfcEntityListList::inner_it jt = it->begin(); jt != it->end(); ++jt) {
				inner.push_back(*jt);
			}
			mapped_instances->push(inner);
		}		
		this->setArgument(i, mapped_instances); }
		break; 
	case IfcUtil::Argument_UNKNOWN:
		throw IfcParse::IfcException("Unknown argument encountered");
		break;
	}
}