C++ ptr::begin方法代码示例

	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 << ")";
	}

void IfcEntityList::push(const IfcEntityList::ptr& l) {
	if (l) {
		for( it i = l->begin(); i != l->end(); ++i  ) {
			if ( *i ) ls.push_back(*i);
		}
	}
}

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;
}

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;
}

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;
	}
}