C++ RefPtr::get方法代码示例

void IfcVertexBasedTextureMap::copy(const IfcVertexBasedTextureMap &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcTextureVertex >, 3 >::const_iterator it_m_textureVertices;
    Step::List< Step::RefPtr< IfcCartesianPoint >, 3 >::const_iterator it_m_texturePoints;
    Step::BaseEntity::copy(obj, copyop);
    for (it_m_textureVertices = obj.m_textureVertices.begin(); it_m_textureVertices != obj.m_textureVertices.end(); ++it_m_textureVertices) {
        Step::RefPtr< IfcTextureVertex > copyTarget = (IfcTextureVertex *) (copyop((*it_m_textureVertices).get()));
        m_textureVertices.push_back(copyTarget.get());
    }
    for (it_m_texturePoints = obj.m_texturePoints.begin(); it_m_texturePoints != obj.m_texturePoints.end(); ++it_m_texturePoints) {
        Step::RefPtr< IfcCartesianPoint > copyTarget = (IfcCartesianPoint *) (copyop((*it_m_texturePoints).get()));
        m_texturePoints.push_back(copyTarget.get());
    }
    return;
}

void IfcSectionedSpine::copy(const IfcSectionedSpine &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcProfileDef >, 2 >::const_iterator it_m_crossSections;
    Step::List< Step::RefPtr< IfcAxis2Placement3D >, 2 >::const_iterator it_m_crossSectionPositions;
    IfcGeometricRepresentationItem::copy(obj, copyop);
    setSpineCurve((IfcCompositeCurve*)copyop(obj.m_spineCurve.get()));
    for (it_m_crossSections = obj.m_crossSections.begin(); it_m_crossSections != obj.m_crossSections.end(); ++it_m_crossSections) {
        Step::RefPtr< IfcProfileDef > copyTarget = (IfcProfileDef *) (copyop((*it_m_crossSections).get()));
        m_crossSections.push_back(copyTarget.get());
    }
    for (it_m_crossSectionPositions = obj.m_crossSectionPositions.begin(); it_m_crossSectionPositions != obj.m_crossSectionPositions.end(); ++it_m_crossSectionPositions) {
        Step::RefPtr< IfcAxis2Placement3D > copyTarget = (IfcAxis2Placement3D *) (copyop((*it_m_crossSectionPositions).get()));
        m_crossSectionPositions.push_back(copyTarget.get());
    }
    return;
}

void IfcStructuralAnalysisModel::copy(const IfcStructuralAnalysisModel &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcStructuralLoadGroup >, 1 >::const_iterator it_m_loadedBy;
    Step::Set< Step::RefPtr< IfcStructuralResultGroup >, 1 >::const_iterator it_m_hasResults;
    IfcSystem::copy(obj, copyop);
    setPredefinedType(obj.m_predefinedType);
    setOrientationOf2DPlane((IfcAxis2Placement3D*)copyop(obj.m_orientationOf2DPlane.get()));
    for (it_m_loadedBy = obj.m_loadedBy.begin(); it_m_loadedBy != obj.m_loadedBy.end(); ++it_m_loadedBy) {
        Step::RefPtr< IfcStructuralLoadGroup > copyTarget = (IfcStructuralLoadGroup *) (copyop((*it_m_loadedBy).get()));
        m_loadedBy.insert(copyTarget.get());
    }
    for (it_m_hasResults = obj.m_hasResults.begin(); it_m_hasResults != obj.m_hasResults.end(); ++it_m_hasResults) {
        Step::RefPtr< IfcStructuralResultGroup > copyTarget = (IfcStructuralResultGroup *) (copyop((*it_m_hasResults).get()));
        m_hasResults.insert(copyTarget.get());
    }
    return;
}

void IfcOrganization::copy(const IfcOrganization &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcActorRole >, 1 >::const_iterator it_m_roles;
    Step::List< Step::RefPtr< IfcAddress >, 1 >::const_iterator it_m_addresses;
    Step::BaseEntity::copy(obj, copyop);
    setId(obj.m_id);
    setName(obj.m_name);
    setDescription(obj.m_description);
    for (it_m_roles = obj.m_roles.begin(); it_m_roles != obj.m_roles.end(); ++it_m_roles) {
        Step::RefPtr< IfcActorRole > copyTarget = (IfcActorRole *) (copyop((*it_m_roles).get()));
        m_roles.push_back(copyTarget.get());
    }
    for (it_m_addresses = obj.m_addresses.begin(); it_m_addresses != obj.m_addresses.end(); ++it_m_addresses) {
        Step::RefPtr< IfcAddress > copyTarget = (IfcAddress *) (copyop((*it_m_addresses).get()));
        m_addresses.push_back(copyTarget.get());
    }
    return;
}

void IfcTextureMap::copy(const IfcTextureMap &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcVertexBasedTextureMap >, 1 >::const_iterator it_m_textureMaps;
    IfcTextureCoordinate::copy(obj, copyop);
    for (it_m_textureMaps = obj.m_textureMaps.begin(); it_m_textureMaps != obj.m_textureMaps.end(); ++it_m_textureMaps) {
        Step::RefPtr< IfcVertexBasedTextureMap > copyTarget = (IfcVertexBasedTextureMap *) (copyop((*it_m_textureMaps).get()));
        m_textureMaps.insert(copyTarget.get());
    }
    return;
}

void IfcIrregularTimeSeries::copy(const IfcIrregularTimeSeries &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcIrregularTimeSeriesValue >, 1 >::const_iterator it_m_values;
    IfcTimeSeries::copy(obj, copyop);
    for (it_m_values = obj.m_values.begin(); it_m_values != obj.m_values.end(); ++it_m_values) {
        Step::RefPtr< IfcIrregularTimeSeriesValue > copyTarget = (IfcIrregularTimeSeriesValue *) (copyop((*it_m_values).get()));
        m_values.push_back(copyTarget.get());
    }
    return;
}

void IfcEdgeLoop::copy(const IfcEdgeLoop &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcOrientedEdge >, 1 >::const_iterator it_m_edgeList;
    IfcLoop::copy(obj, copyop);
    for (it_m_edgeList = obj.m_edgeList.begin(); it_m_edgeList != obj.m_edgeList.end(); ++it_m_edgeList) {
        Step::RefPtr< IfcOrientedEdge > copyTarget = (IfcOrientedEdge *) (copyop((*it_m_edgeList).get()));
        m_edgeList.push_back(copyTarget.get());
    }
    return;
}

void IfcSurfaceStyleWithTextures::copy(const IfcSurfaceStyleWithTextures &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcSurfaceTexture >, 1 >::const_iterator it_m_textures;
    Step::BaseEntity::copy(obj, copyop);
    for (it_m_textures = obj.m_textures.begin(); it_m_textures != obj.m_textures.end(); ++it_m_textures) {
        Step::RefPtr< IfcSurfaceTexture > copyTarget = (IfcSurfaceTexture *) (copyop((*it_m_textures).get()));
        m_textures.push_back(copyTarget.get());
    }
    return;
}

void IfcConnectedFaceSet::copy(const IfcConnectedFaceSet &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcFace >, 1 >::const_iterator it_m_cfsFaces;
    IfcTopologicalRepresentationItem::copy(obj, copyop);
    for (it_m_cfsFaces = obj.m_cfsFaces.begin(); it_m_cfsFaces != obj.m_cfsFaces.end(); ++it_m_cfsFaces) {
        Step::RefPtr< IfcFace > copyTarget = (IfcFace *) (copyop((*it_m_cfsFaces).get()));
        m_cfsFaces.insert(copyTarget.get());
    }
    return;
}

void IfcPropertySet::copy(const IfcPropertySet &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcProperty >, 1 >::const_iterator it_m_hasProperties;
    IfcPropertySetDefinition::copy(obj, copyop);
    for (it_m_hasProperties = obj.m_hasProperties.begin(); it_m_hasProperties != obj.m_hasProperties.end(); ++it_m_hasProperties) {
        Step::RefPtr< IfcProperty > copyTarget = (IfcProperty *) (copyop((*it_m_hasProperties).get()));
        m_hasProperties.insert(copyTarget.get());
    }
    return;
}

void IfcRelDefines::copy(const IfcRelDefines &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcObject >, 1 >::const_iterator it_m_relatedObjects;
    IfcRelationship::copy(obj, copyop);
    for (it_m_relatedObjects = obj.m_relatedObjects.begin(); it_m_relatedObjects != obj.m_relatedObjects.end(); ++it_m_relatedObjects) {
        Step::RefPtr< IfcObject > copyTarget = (IfcObject *) (copyop((*it_m_relatedObjects).get()));
        m_relatedObjects.insert(copyTarget.get());
    }
    return;
}

void IfcPath::copy(const IfcPath &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcOrientedEdge >, 1 >::const_iterator it_m_edgeList;
    IfcTopologicalRepresentationItem::copy(obj, copyop);
    for (it_m_edgeList = obj.m_edgeList.begin(); it_m_edgeList != obj.m_edgeList.end(); ++it_m_edgeList) {
        Step::RefPtr< IfcOrientedEdge > copyTarget = (IfcOrientedEdge *) (copyop((*it_m_edgeList).get()));
        m_edgeList.push_back(copyTarget.get());
    }
    return;
}

void IfcFaceBasedSurfaceModel::copy(const IfcFaceBasedSurfaceModel &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcConnectedFaceSet >, 1 >::const_iterator it_m_fbsmFaces;
    IfcGeometricRepresentationItem::copy(obj, copyop);
    for (it_m_fbsmFaces = obj.m_fbsmFaces.begin(); it_m_fbsmFaces != obj.m_fbsmFaces.end(); ++it_m_fbsmFaces) {
        Step::RefPtr< IfcConnectedFaceSet > copyTarget = (IfcConnectedFaceSet *) (copyop((*it_m_fbsmFaces).get()));
        m_fbsmFaces.insert(copyTarget.get());
    }
    return;
}

void IfcFace::copy(const IfcFace &obj, const CopyOp &copyop) {
    Step::Set< Step::RefPtr< IfcFaceBound >, 1 >::const_iterator it_m_bounds;
    IfcTopologicalRepresentationItem::copy(obj, copyop);
    for (it_m_bounds = obj.m_bounds.begin(); it_m_bounds != obj.m_bounds.end(); ++it_m_bounds) {
        Step::RefPtr< IfcFaceBound > copyTarget = (IfcFaceBound *) (copyop((*it_m_bounds).get()));
        m_bounds.insert(copyTarget.get());
    }
    return;
}

void IfcPolyLoop::copy(const IfcPolyLoop &obj, const CopyOp &copyop) {
    Step::List< Step::RefPtr< IfcCartesianPoint >, 3 >::const_iterator it_m_polygon;
    IfcLoop::copy(obj, copyop);
    for (it_m_polygon = obj.m_polygon.begin(); it_m_polygon != obj.m_polygon.end(); ++it_m_polygon) {
        Step::RefPtr< IfcCartesianPoint > copyTarget = (IfcCartesianPoint *) (copyop((*it_m_polygon).get()));
        m_polygon.push_back(copyTarget.get());
    }
    return;
}