X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Validators.cpp;h=ee82a62f5c8c415cd3a897a4818c44d102358822;hb=bf663b5a63ae8d55e6d19ef29235cb9cda040c3d;hp=ddcdfacf20b3ffc666907b81ced3ef6328998b79;hpb=5fd6dc8864d08e1c453d7d8cea7d1dca5161e4bd;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Validators.cpp b/src/FeaturesPlugin/FeaturesPlugin_Validators.cpp index ddcdfacf2..ee82a62f5 100644 --- a/src/FeaturesPlugin/FeaturesPlugin_Validators.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Validators.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -12,15 +12,18 @@ // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include "FeaturesPlugin_Validators.h" #include "FeaturesPlugin_Boolean.h" +#include "FeaturesPlugin_BooleanFuse.h" +#include "FeaturesPlugin_BooleanCommon.h" +#include "FeaturesPlugin_BooleanSmash.h" +#include "FeaturesPlugin_Pipe.h" #include "FeaturesPlugin_Union.h" #include @@ -32,17 +35,19 @@ #include #include #include -#include +#include #include #include #include +#include #include #include #include #include #include +#include #include #include @@ -62,8 +67,10 @@ bool FeaturesPlugin_ValidatorPipePath::isValid(const AttributePtr& theAttribute, AttributeSelectionPtr aPathAttrSelection = std::dynamic_pointer_cast(theAttribute); if(!aPathAttrSelection.get()) { +// LCOV_EXCL_START theError = "Error: This validator can only work with path selector in \"Pipe\" feature."; return false; +// LCOV_EXCL_STOP } GeomShapePtr aPathShape = aPathAttrSelection->value(); @@ -83,7 +90,84 @@ bool FeaturesPlugin_ValidatorPipePath::isValid(const AttributePtr& theAttribute, } //================================================================================================== -bool FeaturesPlugin_ValidatorPipeLocations::isValid( +bool FeaturesPlugin_ValidatorPipeLocations::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + if(!anAttrSelectionList.get()) { +// LCOV_EXCL_START + theError = + "Error: This validator can only work with selection list attributes in \"Pipe\" feature."; + return false; +// LCOV_EXCL_STOP + } + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theAttribute->owner()); + + AttributeSelectionPtr aPathSelection = aFeature->selection(FeaturesPlugin_Pipe::PATH_OBJECT_ID()); + if (!aPathSelection.get()) { +// LCOV_EXCL_START + theError = "Error: Path not selected."; + return false; +// LCOV_EXCL_STOP + } + + GeomShapePtr aPathShape = aPathSelection->value(); + if (!aPathShape.get()) { + ResultPtr aContext = aPathSelection->context(); + if (!aContext.get()) { + FeaturePtr aContFeat = aPathSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size()) { + theError = "Error: Empty selection context."; + return false; + } + } + aPathShape = aContext->shape(); + } + + if (!aPathShape.get()) { + theError = "Error: Empty path shape."; + return false; + } + + for (int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if (!anAttrSelection.get()) { + theError = "Error: Empty attribute selection."; + return false; + } + ResultPtr aContext = anAttrSelection->context(); + if (!aContext.get()) { + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size()) { + theError = "Error: Empty selection context."; + return false; + } + } + std::shared_ptr aShape = anAttrSelection->value(); + if (!aShape.get() && aContext.get()) { + GeomShapePtr aContextShape = aContext->shape(); + aShape = aContextShape; + } + if (!aShape.get()) { + theError = "Error: Empty shape."; + return false; + } + + if (!aPathShape->isSubShape(aShape)) { + theError = "Error: Location should be a vertex subshape from path shape."; + return false; + } + } + + return true; +} + +//================================================================================================== +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorPipeLocationsNumber::isValid( const std::shared_ptr& theFeature, const std::list& theArguments, Events_InfoMessage& theError) const @@ -131,23 +215,19 @@ bool FeaturesPlugin_ValidatorPipeLocations::isValid( return true; } - -//================================================================================================== -bool FeaturesPlugin_ValidatorPipeLocations::isNotObligatory(std::string theFeature, - std::string theAttribute) -{ - return false; -} +// LCOV_EXCL_STOP //================================================================================================== bool FeaturesPlugin_ValidatorBaseForGeneration::isValid(const AttributePtr& theAttribute, const std::list& theArguments, Events_InfoMessage& theError) const { +// LCOV_EXCL_START if(theArguments.empty()) { theError = "Error: Validator parameters is empty."; return false; } +// LCOV_EXCL_STOP // Checking attribute. if(!isValidAttribute(theAttribute, theArguments, theError)) { @@ -165,7 +245,7 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValid(const AttributePtr& theA for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) { AttributeSelectionPtr aSelectionAttr = aListAttr->value(anIndex); ResultPtr aContext = aSelectionAttr->context(); - if(!aContext.get()) { + if(!aContext.get() && !aSelectionAttr->contextFeature().get()) { theError = "Error: Empty context."; return false; } @@ -174,18 +254,24 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValid(const AttributePtr& theA std::dynamic_pointer_cast(aContext); if(!aResultConstruction.get()) { // It is not a result construction. - // If shape is compound check that it contains only faces and edges. + // If shape is compound check that it contains only faces, edges or vertices. GeomShapePtr aShape = aSelectionAttr->value(); if(!aShape.get()) { - aShape = aContext->shape(); + if (aContext.get()) { + aShape = aContext->shape(); + } else { + theError = "Error: Empty context."; + return false; + } } if(aShape->shapeType() == GeomAPI_Shape::COMPOUND) { for(GeomAPI_ShapeIterator anIt(aShape); anIt.more(); anIt.next()) { GeomShapePtr aSubShape = anIt.current(); - if(aSubShape->shapeType() != GeomAPI_Shape::EDGE + if(aSubShape->shapeType() != GeomAPI_Shape::VERTEX + && aSubShape->shapeType() != GeomAPI_Shape::EDGE && aSubShape->shapeType() != GeomAPI_Shape::FACE) { - theError = "Error: Compound should contain only faces and edges."; + theError = "Error: Compound should contain only faces, edges or vertices."; return false; } } @@ -233,9 +319,11 @@ bool FeaturesPlugin_ValidatorBaseForGenerationSketchOrSketchObjects::isValid( AttributeSelectionListPtr aListAttr = theFeature->selectionList(aBaseObjectsID); if(!aListAttr.get()) { +// LCOV_EXCL_START theError = "Error: Could not get \"%1\" attribute."; theError.arg(aBaseObjectsID); return false; +// LCOV_EXCL_STOP } std::set aSelectedSketches; @@ -245,8 +333,13 @@ bool FeaturesPlugin_ValidatorBaseForGenerationSketchOrSketchObjects::isValid( AttributeSelectionPtr aSelectionAttr = aListAttr->value(anIndex); ResultPtr aContext = aSelectionAttr->context(); if(!aContext.get()) { - theError = "Error: Empty context."; - return false; + FeaturePtr aFeature = aSelectionAttr->contextFeature(); + if (!aFeature.get() || aFeature->results().empty()) { + theError = "Error: Empty context."; + return false; + } else { + aContext = aFeature->firstResult(); + } } ResultConstructionPtr aResultConstruction = @@ -282,22 +375,16 @@ bool FeaturesPlugin_ValidatorBaseForGenerationSketchOrSketchObjects::isValid( return true; } -//================================================================================================== -bool FeaturesPlugin_ValidatorBaseForGenerationSketchOrSketchObjects::isNotObligatory( - std::string theFeature, - std::string theAttribute) -{ - return false; -} - //================================================================================================== bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const AttributePtr& theAttribute, const std::list& theArguments, Events_InfoMessage& theError) const { if(!theAttribute.get()) { +// LCOV_EXCL_START theError = "Error: Empty attribute."; return false; +// LCOV_EXCL_STOP } std::string anAttributeType = theAttribute->attributeType(); @@ -315,14 +402,15 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const Attribute AttributeSelectionPtr anAttr = std::dynamic_pointer_cast(theAttribute); ResultPtr aContext = anAttr->context(); - if(!aContext.get()) { + if(!aContext.get() && !anAttr->contextFeature().get()) { theError = "Error: Attribute have empty context."; return false; } GeomShapePtr aShape = anAttr->value(); - GeomShapePtr aContextShape = aContext->shape(); - if(!aShape.get()) { + GeomShapePtr aContextShape; + if(!aShape.get() && aContext.get()) { + aContextShape = aContext->shape(); aShape = aContextShape; } if(!aShape.get()) { @@ -330,15 +418,20 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const Attribute return false; } - ResultConstructionPtr aConstruction = - std::dynamic_pointer_cast(aContext); + ResultConstructionPtr aConstruction; + if (!aContext.get() && anAttr->contextFeature()->results().size() == 1) { + aContext = anAttr->contextFeature()->firstResult(); + } + if (aContext.get()) + aConstruction = std::dynamic_pointer_cast(aContext); if(aConstruction.get()) { - // Construciotn selected. Check that is is not infinite. + // Construction selected. Check that it is not infinite. if(aConstruction->isInfinite()) { theError = "Error: Infinite constructions is not allowed as base."; return false; } + GeomShapePtr aContextShape = aContext->shape(); if(aShape->isEqual(aContextShape)) { // Whole construction selected. Check that it have faces. if(aConstruction->facesNum() > 0) { @@ -351,11 +444,10 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const Attribute return true; } } - return false; } - if(!aShape->isEqual(aContextShape)) { + if(aContextShape.get() && !aShape->isEqual(aContextShape)) { // Local selection on body does not allowed. theError = "Error: Selected shape is in the local selection. Only global selection is allowed."; @@ -379,15 +471,18 @@ bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const Attribute } } else { +// LCOV_EXCL_START theError = "Error: Attribute \"%1\" does not supported by this validator."; theError.arg(anAttributeType); return false; +// LCOV_EXCL_STOP } return true; } //================================================================================================== +// LCOV_EXCL_START bool FeaturesPlugin_ValidatorCompositeLauncher::isValid(const AttributePtr& theAttribute, const std::list& theArguments, Events_InfoMessage& theError) const @@ -434,6 +529,7 @@ bool FeaturesPlugin_ValidatorCompositeLauncher::isValid(const AttributePtr& theA bool aValid = !aFeatureKind && aPlanarFace; return aValid; } +// LCOV_EXCL_STOP //================================================================================================== bool FeaturesPlugin_ValidatorExtrusionDir::isValid( @@ -442,8 +538,10 @@ bool FeaturesPlugin_ValidatorExtrusionDir::isValid( Events_InfoMessage& theError) const { if(theArguments.size() != 2) { +// LCOV_EXCL_START theError = "Error: Validator should be used with 2 parameters for extrusion."; return false; +// LCOV_EXCL_STOP } std::list::const_iterator @@ -458,13 +556,26 @@ bool FeaturesPlugin_ValidatorExtrusionDir::isValid( aDirShape = aSelAttr->value(); if(!aDirShape.get()) { ResultPtr aContext = aSelAttr->context(); + if(!aContext.get()) { + FeaturePtr aFeature = aSelAttr->contextFeature(); + if (aFeature.get() && !aFeature->results().empty()) { + aContext = aFeature->firstResult(); + } + } + if(aContext.get()) { aDirShape = aContext->shape(); } + + if (aDirShape.get() && aDirShape->isCompound()) { + GeomAPI_ShapeIterator anIt(aDirShape); + aDirShape = anIt.current(); + } } } - if(!aDirShape.get()) { + if(!aDirShape.get() || aDirShape->isNull() || + aDirShape->shapeType() != GeomAPI_Shape::EDGE) { // Check that dir can be empty. if(!isShapesCanBeEmpty(aCheckAttribute, theError)) { theError = "Error: Base objects list contains vertex or edge, so attribute \"%1\" " @@ -525,20 +636,15 @@ bool FeaturesPlugin_ValidatorExtrusionDir::isValid( return true; } -//================================================================================================== -bool FeaturesPlugin_ValidatorExtrusionDir::isNotObligatory(std::string theFeature, - std::string theAttribute) -{ - return false; -} - //================================================================================================== bool FeaturesPlugin_ValidatorExtrusionDir::isShapesCanBeEmpty(const AttributePtr& theAttribute, Events_InfoMessage& theError) const { +// LCOV_EXCL_START if(!theAttribute.get()) { return true; } +// LCOV_EXCL_STOP std::string anAttributeType = theAttribute->attributeType(); if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) { @@ -555,13 +661,13 @@ bool FeaturesPlugin_ValidatorExtrusionDir::isShapesCanBeEmpty(const AttributePtr AttributeSelectionPtr anAttr = std::dynamic_pointer_cast(theAttribute); ResultPtr aContext = anAttr->context(); - if(!aContext.get()) { + if(!aContext.get() && !anAttr->contextFeature().get()) { return false; } GeomShapePtr aShape = anAttr->value(); - GeomShapePtr aContextShape = aContext->shape(); - if(!aShape.get()) { + if(!aShape.get() && aContext.get()) { + GeomShapePtr aContextShape = aContext->shape(); aShape = aContextShape; } if(!aShape.get()) { @@ -588,12 +694,15 @@ bool FeaturesPlugin_ValidatorBooleanSelection::isValid(const AttributePtr& theAt AttributeSelectionListPtr anAttrSelectionList = std::dynamic_pointer_cast(theAttribute); if(!anAttrSelectionList.get()) { +// LCOV_EXCL_START theError = "Error: This validator can only work with selection list attributes in \"Boolean\" feature."; return false; +// LCOV_EXCL_STOP } - FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); - int anOperationType = aFeature->integer("bool_type")->value(); + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theAttribute->owner()); + FeaturesPlugin_Boolean::OperationType anOperationType = aFeature->operationType(); for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); @@ -603,8 +712,11 @@ bool FeaturesPlugin_ValidatorBooleanSelection::isValid(const AttributePtr& theAt } ResultPtr aContext = anAttrSelection->context(); if(!aContext.get()) { - theError = "Error: Empty selection context."; - return false; + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size()) { + theError = "Error: Empty selection context."; + return false; + } } ResultConstructionPtr aResultConstruction = std::dynamic_pointer_cast(aContext); @@ -616,46 +728,115 @@ bool FeaturesPlugin_ValidatorBooleanSelection::isValid(const AttributePtr& theAt } } std::shared_ptr aShape = anAttrSelection->value(); - GeomShapePtr aContextShape = aContext->shape(); - if(!aShape.get()) { + if(!aShape.get() && aContext.get()) { + GeomShapePtr aContextShape = aContext->shape(); aShape = aContextShape; } if(!aShape.get()) { theError = "Error: Empty shape."; return false; } - if(!aShape->isEqual(aContextShape)) { + if (aContext.get() && !aShape->isEqual(aContext->shape())) { theError = "Error: Local selection not allowed."; return false; } - int aShapeType = aShape->shapeType(); + GeomAPI_Shape::ShapeType aShapeType = aShape->shapeType(); + std::set anAllowedTypes; if(anOperationType == FeaturesPlugin_Boolean::BOOL_FUSE) { - // Fuse operation. Allow to select edges, faces and solids. - if(aShapeType != GeomAPI_Shape::EDGE && - aShapeType != GeomAPI_Shape::FACE && - aShapeType != GeomAPI_Shape::SOLID && - aShapeType != GeomAPI_Shape::COMPSOLID && - aShapeType != GeomAPI_Shape::COMPOUND) { - theError = "Error: Selected shape has the wrong type."; - return false; - } - } else if (anOperationType == FeaturesPlugin_Boolean::BOOL_FILL) { - if(aShapeType != GeomAPI_Shape::FACE && - aShapeType != GeomAPI_Shape::SOLID && - aShapeType != GeomAPI_Shape::COMPSOLID && - aShapeType != GeomAPI_Shape::COMPOUND) { - theError = "Error: Selected shape has the wrong type."; + anAllowedTypes.insert(GeomAPI_Shape::EDGE); + anAllowedTypes.insert(GeomAPI_Shape::FACE); + anAllowedTypes.insert(GeomAPI_Shape::SOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPOUND); + } else if (anOperationType == FeaturesPlugin_Boolean::BOOL_FILL + || anOperationType == FeaturesPlugin_Boolean::BOOL_CUT) + { + anAllowedTypes.insert(GeomAPI_Shape::VERTEX); + anAllowedTypes.insert(GeomAPI_Shape::EDGE); + anAllowedTypes.insert(GeomAPI_Shape::WIRE); + anAllowedTypes.insert(GeomAPI_Shape::FACE); + anAllowedTypes.insert(GeomAPI_Shape::SHELL); + anAllowedTypes.insert(GeomAPI_Shape::SOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPOUND); + } else { + anAllowedTypes.insert(GeomAPI_Shape::SOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID); + anAllowedTypes.insert(GeomAPI_Shape::COMPOUND); + } + + if(anAllowedTypes.find(aShapeType) == anAllowedTypes.end() + || (aResultConstruction.get() && aShapeType != GeomAPI_Shape::FACE)) { + theError = "Error: Selected shape has the wrong type."; + return false; + } + + } + + return true; +} + +//================================================================================================== +bool FeaturesPlugin_ValidatorFilletSelection::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + if(!anAttrSelectionList.get()) { +// LCOV_EXCL_START + theError = + "Error: This validator can only work with selection list attributes in \"Fillet\" feature."; + return false; +// LCOV_EXCL_STOP + } + + FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); + // Check all selected entities are sub-shapes of single solid + GeomShapePtr aBaseSolid; + for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if(!anAttrSelection.get()) { + theError = "Error: Empty attribute selection."; + return false; + } + ResultPtr aContext = anAttrSelection->context(); + if(!aContext.get()) { + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size() || + aContFeat->firstResult()->groupName() != ModelAPI_ResultBody::group()) { + theError = "Error: Empty selection context."; return false; } - } else { - if(aShapeType != GeomAPI_Shape::SOLID && - aShapeType != GeomAPI_Shape::COMPSOLID && - aShapeType != GeomAPI_Shape::COMPOUND) { - theError = "Error: Selected shape has the wrong type."; + if (aContFeat->results().size() == 1) + aContext = aContFeat->firstResult(); + else { + theError = "Error: Too many shapes selected."; return false; } } + + ResultBodyPtr aContextOwner = ModelAPI_Tools::bodyOwner(aContext); + GeomShapePtr anOwner = aContextOwner.get() ? aContextOwner->shape() : aContext->shape(); + + if (!anOwner) { + theError = "Error: wrong feature is selected."; + return false; + } + + if (anOwner->shapeType() != GeomAPI_Shape::SOLID && + anOwner->shapeType() != GeomAPI_Shape::COMPSOLID) { + theError = "Error: Not all selected shapes are sub-shapes of solids."; + return false; + } + + if (!aBaseSolid) + aBaseSolid = anOwner; + else if (!aBaseSolid->isEqual(anOwner)) { + theError = "Error: Sub-shapes of different solids have been selected."; + return false; + } } return true; @@ -669,8 +850,10 @@ bool FeaturesPlugin_ValidatorPartitionSelection::isValid(const AttributePtr& the AttributeSelectionListPtr anAttrSelectionList = std::dynamic_pointer_cast(theAttribute); if(!anAttrSelectionList.get()) { +// LCOV_EXCL_START theError = "Error: This validator can only work with selection list in \"Partition\" feature."; return false; +// LCOV_EXCL_STOP } for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { @@ -694,11 +877,22 @@ bool FeaturesPlugin_ValidatorPartitionSelection::isValid(const AttributePtr& the return false; } - ResultCompSolidPtr aResultCompsolid = - std::dynamic_pointer_cast(aContext); - if(aResultCompsolid.get()) { + ResultBodyPtr aResultBody = std::dynamic_pointer_cast(aContext); + if(aResultBody.get()) { continue; } + FeaturePtr aResultFeature = aSelectAttr->contextFeature(); + if(aResultFeature.get()) { + bool aOkRes = false; + std::list::const_iterator aFRes = aResultFeature->results().cbegin(); + for(; aFRes != aResultFeature->results().cend() && !aOkRes; aFRes++) { + ResultBodyPtr aBody = std::dynamic_pointer_cast(*aFRes); + if (aBody.get() && !aBody->isDisabled()) + aOkRes = true; + } + if (aOkRes) + continue; + } theError = "Error: Only body shapes and construction planes are allowed for selection."; return false; @@ -716,9 +910,11 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesSelection::isValid(const AttributePt AttributeSelectionListPtr aSubShapesAttrList = std::dynamic_pointer_cast(theAttribute); if(!aSubShapesAttrList.get()) { +// LCOV_EXCL_START theError = "Error: This validator can only work with selection list in \"Remove Sub-Shapes\" feature."; return false; +// LCOV_EXCL_STOP } static const std::string aBaseShapeID = "base_shape"; @@ -726,9 +922,11 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesSelection::isValid(const AttributePt AttributeSelectionPtr aShapeAttrSelection = aFeature->selection(aBaseShapeID); if(!aShapeAttrSelection.get()) { +// LCOV_EXCL_START theError = "Error: Could not get \"%1\" attribute."; theError.arg(aBaseShapeID); return false; +// LCOV_EXCL_STOP } GeomShapePtr aBaseShape = aShapeAttrSelection->value(); @@ -745,17 +943,19 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesSelection::isValid(const AttributePt return false; } + std::list aSubShapes = GeomAlgoAPI_ShapeTools::getLowLevelSubShapes(aBaseShape); for(int anIndex = 0; anIndex < aSubShapesAttrList->size(); ++anIndex) { bool isSameFound = false; AttributeSelectionPtr anAttrSelectionInList = aSubShapesAttrList->value(anIndex); GeomShapePtr aShapeToAdd = anAttrSelectionInList->value(); - for(GeomAPI_ShapeIterator anIt(aBaseShape); anIt.more(); anIt.next()) { - if(anIt.current()->isEqual(aShapeToAdd)) { + for (ListOfShape::const_iterator anIt = aSubShapes.cbegin(); anIt != aSubShapes.cend(); ++anIt) + { + if ((*anIt)->isEqual(aShapeToAdd)) { isSameFound = true; break; } } - if(!isSameFound) { + if (!isSameFound) { theError = "Error: Only sub-shapes of selected shape is allowed for selection."; return false; } @@ -773,6 +973,7 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isValid( static const std::string aBaseShapeID = "base_shape"; static const std::string aSubShapesID = "subshapes_to_keep"; +// LCOV_EXCL_START if(theFeature->getKind() != "Remove_SubShapes") { theError = "Error: Feature \"%1\" does not supported by this validator."; theError.arg(theFeature->getKind()); @@ -792,6 +993,7 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isValid( theError.arg(aSubShapesID); return false; } +// LCOV_EXCL_STOP // Copy base shape. GeomShapePtr aBaseShape = aShapeAttrSelection->value(); @@ -823,13 +1025,7 @@ bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isValid( } //================================================================================================== -bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isNotObligatory(std::string theFeature, - std::string theAttribute) -{ - return false; -} - -//================================================================================================== +// LCOV_EXCL_START bool FeaturesPlugin_ValidatorUnionSelection::isValid(const AttributePtr& theAttribute, const std::list& theArguments, Events_InfoMessage& theError) const @@ -845,11 +1041,32 @@ bool FeaturesPlugin_ValidatorUnionSelection::isValid(const AttributePtr& theAttr for(int anIndex = 0; anIndex < aBaseObjectsAttrList->size(); ++anIndex) { bool isSameFound = false; AttributeSelectionPtr anAttrSelectionInList = aBaseObjectsAttrList->value(anIndex); - ResultCompSolidPtr aResult = - std::dynamic_pointer_cast(anAttrSelectionInList->context()); + ResultPtr aContext = anAttrSelectionInList->context(); + if (!aContext.get()) { + theError = "Error: selection is invalid."; + return false; + } + + ResultConstructionPtr aConstruction = + std::dynamic_pointer_cast(aContext); + if(aConstruction.get()) { + theError = "Error: Result construction not allowed for selection."; + return false; + } + + GeomShapePtr aShape = anAttrSelectionInList->value(); + GeomShapePtr aContextShape = aContext->shape(); + if (aShape.get() && aContextShape.get() && !aContextShape->isEqual(aShape)) { + theError = "Error: Local selection not allowed."; + return false; + } + + ResultBodyPtr aResult = + std::dynamic_pointer_cast(aContext); if(!aResult.get()) { continue; } + if(aResult->numberOfSubs() > 0) { theError = "Error: Whole compsolids not allowed for selection."; return false; @@ -858,6 +1075,7 @@ bool FeaturesPlugin_ValidatorUnionSelection::isValid(const AttributePtr& theAttr return true; } +// LCOV_EXCL_STOP //================================================================================================== bool FeaturesPlugin_ValidatorUnionArguments::isValid( @@ -865,6 +1083,7 @@ bool FeaturesPlugin_ValidatorUnionArguments::isValid( const std::list& theArguments, Events_InfoMessage& theError) const { +// LCOV_EXCL_START // Check feature kind. if(theFeature->getKind() != FeaturesPlugin_Union::ID()) { theError = "Error: This validator supports only \"%1\" feature."; @@ -880,21 +1099,28 @@ bool FeaturesPlugin_ValidatorUnionArguments::isValid( theError.arg(FeaturesPlugin_Union::BASE_OBJECTS_ID()); return false; } +// LCOV_EXCL_STOP // Get all shapes. + GeomAPI_Shape::ShapeType aType = GeomAPI_Shape::COMPSOLID; ListOfShape aBaseShapesList; for(int anIndex = 0; anIndex < aBaseObejctsAttrList->size(); ++anIndex) { AttributeSelectionPtr anAttrSelectionInList = aBaseObejctsAttrList->value(anIndex); GeomShapePtr aShape = anAttrSelectionInList->value(); + if (!aShape.get()) { + continue; + } aBaseShapesList.push_back(aShape); + aType = aShape->shapeType() == GeomAPI_Shape::FACE ? GeomAPI_Shape::SHELL : + GeomAPI_Shape::COMPSOLID; } - // Make componud and find connected. + // Make compound and find connected. GeomShapePtr aCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseShapesList); - ListOfShape aCombined, aFree; - GeomAlgoAPI_ShapeTools::combineShapes(aCompound, GeomAPI_Shape::COMPSOLID, aCombined, aFree); + ListOfShape aResults; + GeomAlgoAPI_ShapeTools::combineShapes(aCompound, aType, aResults); - if(aFree.size() > 0 || aCombined.size() > 1) { + if(aResults.size() > 1 || (aResults.size() == 1 && aResults.front()->shapeType() > aType)) { theError = "Error: Not all shapes have shared topology."; return false; } @@ -902,21 +1128,16 @@ bool FeaturesPlugin_ValidatorUnionArguments::isValid( return true; } -//================================================================================================== -bool FeaturesPlugin_ValidatorUnionArguments::isNotObligatory(std::string theFeature, - std::string theAttribute) -{ - return false; -} - bool FeaturesPlugin_ValidatorConcealedResult::isValid(const AttributePtr& theAttribute, const std::list& theArguments, Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) { +// LCOV_EXCL_START theError = "Error: The attribute with the %1 type is not processed"; theError.arg(theAttribute->attributeType()); return false; +// LCOV_EXCL_STOP } AttributeReferencePtr aRefAttribute = std::dynamic_pointer_cast @@ -953,3 +1174,613 @@ bool FeaturesPlugin_ValidatorConcealedResult::isValid(const AttributePtr& theAtt return theError.empty(); } + +bool FeaturesPlugin_ValidatorCircular::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + static std::list aEdgeArg(1, "circle"); + static std::list aFaceArg(1, "cylinder"); + + Events_InfoMessage aError; + bool isValid = GeomValidators_ShapeType().isValid(theAttribute, aEdgeArg, aError); + if (!isValid) { + isValid = GeomValidators_Face().isValid(theAttribute, aFaceArg, aError); + if (!isValid) + theError = "The shape neither circle nor cylinder"; + } + return isValid; +} + +//================================================================================================= +bool FeaturesPlugin_ValidatorBooleanArguments::isValid( + const std::shared_ptr& theFeature, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ +// LCOV_EXCL_START + if (theArguments.size() != 2) + { + theError = "Wrong number of arguments (expected 2)."; + return false; + } +// LCOV_EXCL_STOP + + int anObjectsToolsNb[2] = { 0, 0 }; + + std::list::const_iterator anIt = theArguments.begin(), aLast = theArguments.end(); + + bool isAllInSameCompSolid = true; + ResultBodyPtr aCompSolid; + + for (int* anArgNbIt = anObjectsToolsNb; anIt != aLast; ++anIt, ++anArgNbIt) { + AttributeSelectionListPtr anAttrSelList = theFeature->selectionList(*anIt); + if (anAttrSelList) + { + *anArgNbIt = anAttrSelList->size(); + if (isAllInSameCompSolid) { + for (int anIndex = 0; anIndex < *anArgNbIt; ++anIndex) + { + AttributeSelectionPtr anAttr = anAttrSelList->value(anIndex); + ResultPtr aContext = anAttr->context(); + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if (aResCompSolidPtr.get()) + { + if (aCompSolid.get()) + { + isAllInSameCompSolid = aCompSolid == aResCompSolidPtr; + } + else + { + aCompSolid = aResCompSolidPtr; + } + } + else + { + isAllInSameCompSolid = false; + break; + } + } + } + } + } + + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theFeature); + FeaturesPlugin_Boolean::OperationType anOperationType = aFeature->operationType(); + + if (anOperationType == FeaturesPlugin_Boolean::BOOL_FUSE) + { + // Fuse operation + if (anObjectsToolsNb[0] + anObjectsToolsNb[1] < 2) + { + theError = "Not enough arguments for Fuse operation."; + return false; + } + else if (isAllInSameCompSolid) + { + theError = "Operations only between sub-shapes of the same shape not allowed."; + return false; + } + } + else + { + if (anObjectsToolsNb[0] < 1) // check number of objects + { + theError = "Objects not selected."; + return false; + } + if (anObjectsToolsNb[1] < 1) // check number of tools + { + theError = "Tools not selected."; + return false; + } + if (isAllInSameCompSolid) + { + theError = "Operations only between sub-shapes of the same shape not allowed."; + return false; + } + } + + return true; +} + +//================================================================================================= +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorBooleanArguments::isNotObligatory(std::string theFeature, + std::string theAttribute) +{ + if (theAttribute == "main_objects" || theAttribute == "tool_objects") + { + return true; + } + + return false; +} +// LCOV_EXCL_STOP + +//================================================================================================== +bool FeaturesPlugin_ValidatorBooleanSmashSelection::isValid( + const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theAttribute->owner()); + + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + if (!aFeature.get() || !anAttrSelectionList.get()) { +// LCOV_EXCL_START + theError = + "Error: Validator used in wrong feature or attribute"; + return false; +// LCOV_EXCL_STOP + } + + AttributeSelectionListPtr anOtherAttrSelectionList; + if (theAttribute->id() == FeaturesPlugin_BooleanSmash::OBJECT_LIST_ID()) { + anOtherAttrSelectionList = + aFeature->selectionList(FeaturesPlugin_BooleanSmash::TOOL_LIST_ID()); + } else { + anOtherAttrSelectionList = + aFeature->selectionList(FeaturesPlugin_BooleanSmash::OBJECT_LIST_ID()); + } + + GeomAPI_Shape::ShapeType aSelectedShapesType = GeomAPI_Shape::SHAPE; + GeomAPI_DataMapOfShapeShape aSelectedCompSolidsInOtherList; + GeomPlanePtr aFacesPln; + + for (int anIndex = 0; anIndex < anOtherAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anOtherAttrSelectionList->value(anIndex); + + if (anAttrSelection->contextFeature().get()) { + theError = "Error: Features not allowed for selection."; + return false; + } + + ResultPtr aContext = anAttrSelection->context(); + std::shared_ptr aShape = anAttrSelection->value(); + if (!aShape.get()) { + if (!aContext.get()) { + theError = "Error: Empty selection."; + return false; + } + aShape = aContext->shape(); + } + + if (aShape->isSolid() || aShape->isCompSolid()) { + aSelectedShapesType = GeomAPI_Shape::SOLID; + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if (aResCompSolidPtr.get()) { + GeomShapePtr aCompSolidShape = aResCompSolidPtr->shape(); + aSelectedCompSolidsInOtherList.bind(aCompSolidShape, aCompSolidShape); + } + } else { + aSelectedShapesType = GeomAPI_Shape::FACE; + GeomAPI_Face aFace(aShape); + aFacesPln = aFace.getPlane(); + break; + } + } + + for (int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if (!anAttrSelection.get()) { + theError = "Error: Empty attribute selection."; + return false; + } + + if (anAttrSelection->contextFeature().get()) { + theError = "Error: Features not allowed for selection."; + return false; + } + + ResultPtr aContext = anAttrSelection->context(); + if(!aContext.get()) { + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size() || + aContFeat->firstResult()->groupName() != ModelAPI_ResultBody::group()) { + theError = "Error: Empty selection context."; + return false; + } + } + ResultConstructionPtr aResultConstruction = + std::dynamic_pointer_cast(aContext); + if (aResultConstruction.get()) { + theError = "Error: Result construction not allowed for selection."; + return false; + } + std::shared_ptr aShape = anAttrSelection->value(); + GeomShapePtr aContextShape = aContext->shape(); + if (!aShape.get()) { + aShape = aContextShape; + } + if (!aShape.get()) { + theError = "Error: Empty shape."; + return false; + } + if (!aShape->isEqual(aContextShape)) { + theError = "Error: Local selection not allowed."; + return false; + } + + if (aSelectedShapesType == GeomAPI_Shape::SHAPE) { + // Other list is empty. + if (aShape->isSolid() || aShape->isCompSolid()) { + aSelectedShapesType = GeomAPI_Shape::SOLID; + } else { + aSelectedShapesType = GeomAPI_Shape::FACE; + GeomAPI_Face aFace(aShape); + aFacesPln = aFace.getPlane(); + + if (!aFacesPln.get()) { + theError = "Error: Only planar faces allowed."; + return false; + } + } + + continue; + } else if (aSelectedShapesType == GeomAPI_Shape::SOLID) { + if (!aShape->isSolid() && !aShape->isCompSolid()) { + theError = "Error: Selected shapes should have the same type."; + return false; + } + } else { + GeomAPI_Face aFace(aShape); + GeomPlanePtr aPln = aFace.getPlane(); + + if (!aPln.get()) { + theError = "Error: Only planar faces allowed."; + return false; + } + + if (!aFacesPln->isCoincident(aPln)) { + theError = "Error: Only coincident faces allowed."; + return false; + } + } + } + + return true; +} + +//================================================================================================== +// LCOV_EXCL_START +bool FeaturesPlugin_IntersectionSelection::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + if (!theAttribute.get()) { + theError = "Error: empty selection."; + return false; + } + FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + for (int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if (!anAttrSelection.get()) { + theError = "Error: empty attribute selection."; + return false; + } + ResultPtr aContext = anAttrSelection->context(); + if(!aContext.get()) { + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size() || + aContFeat->firstResult()->groupName() != ModelAPI_ResultBody::group()) { + theError = "Error: Empty selection context."; + return false; + } + } + FeaturePtr aFeature = anAttrSelection->contextFeature().get() ? + anAttrSelection->contextFeature() : ModelAPI_Feature::feature(aContext); + if (!aFeature.get()) { + theError = "Error: empty feature."; + return false; + } + std::string aFeatureKind = aFeature->getKind(); + if (aFeatureKind == "Sketch" || + aFeatureKind == "Plane" || + aFeatureKind == "Axis") { + theError = "Error: %1 shape is not allowed for selection."; + theError.arg(aFeatureKind); + return false; + } + std::shared_ptr aShape = anAttrSelection->value(); + if (!aShape.get()) { + GeomShapePtr aContextShape = aContext->shape(); + aShape = aContextShape; + } + if (!aShape.get()) { + theError = "Error: empty shape."; + return false; + } + if (aContext.get() && !aShape->isEqual(aContext->shape())) { + theError = "Error: Local selection not allowed."; + return false; + } + + int aShapeType = aShape->shapeType(); + // Allow to select edges, faces and solids. + if (aShapeType != GeomAPI_Shape::EDGE && + aShapeType != GeomAPI_Shape::FACE && + aShapeType != GeomAPI_Shape::SOLID && + aShapeType != GeomAPI_Shape::COMPSOLID && + aShapeType != GeomAPI_Shape::COMPOUND) { + theError = "Error: selected shape has the wrong type."; + return false; + } + } + + return true; +} +// LCOV_EXCL_STOP + +//================================================================================================== +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorBooleanFuseSelection::isValid( + const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + if (!anAttrSelectionList.get()) { + theError = + "Error: This validator can only work with selection list attributes in \"Boolean\" feature."; + return false; + } + + for (int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if (!anAttrSelection.get()) { + theError = "Error: Empty attribute selection."; + return false; + } + ResultPtr aContext = anAttrSelection->context(); + if(!aContext.get()) { + FeaturePtr aContFeat = anAttrSelection->contextFeature(); + if (!aContFeat.get() || !aContFeat->results().size() || + aContFeat->firstResult()->groupName() != ModelAPI_ResultBody::group()) { + theError = "Error: Empty selection context."; + return false; + } + } + ResultConstructionPtr aResultConstruction = + std::dynamic_pointer_cast(aContext); + if (aResultConstruction.get()) { + theError = "Error: Result construction not allowed for selection."; + return false; + } + std::shared_ptr aShape = anAttrSelection->value(); + if (!aShape.get()) { + GeomShapePtr aContextShape = aContext->shape(); + aShape = aContextShape; + } + if (!aShape.get()) { + theError = "Error: Empty shape."; + return false; + } + if (aContext.get() && !aShape->isEqual(aContext->shape())) { + theError = "Error: Local selection not allowed."; + return false; + } + } + + return true; +} +// LCOV_EXCL_STOP + +//================================================================================================= +bool FeaturesPlugin_ValidatorBooleanFuseArguments::isValid( + const std::shared_ptr& theFeature, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ +// LCOV_EXCL_START + if (theArguments.size() != 2) { + theError = "Wrong number of arguments (expected 2)."; + return false; + } +// LCOV_EXCL_STOP + + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theFeature); + + int anObjectsNb = 0, aToolsNb = 0; + + std::list::const_iterator anIt = theArguments.begin(), aLast = theArguments.end(); + + bool isAllInSameCompSolid = true; + ResultBodyPtr aCompSolid; + + AttributeSelectionListPtr anAttrSelList = theFeature->selectionList(*anIt); + if (anAttrSelList) { + anObjectsNb = anAttrSelList->size(); + for (int anIndex = 0; anIndex < anObjectsNb; ++anIndex) { + AttributeSelectionPtr anAttr = anAttrSelList->value(anIndex); + ResultPtr aContext = anAttr->context(); + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if (aResCompSolidPtr.get()) { + if (aCompSolid.get()) { + isAllInSameCompSolid = aCompSolid == aResCompSolidPtr; + } else { + aCompSolid = aResCompSolidPtr; + } + } else { + isAllInSameCompSolid = false; + break; + } + } + } + anIt++; + + if (aFeature->string(FeaturesPlugin_BooleanFuse::CREATION_METHOD())->value() + == FeaturesPlugin_BooleanFuse::CREATION_METHOD_ADVANCED()) { + anAttrSelList = theFeature->selectionList(*anIt); + if (anAttrSelList) { + aToolsNb = anAttrSelList->size(); + if (isAllInSameCompSolid) { + for (int anIndex = 0; anIndex < aToolsNb; ++anIndex) { + AttributeSelectionPtr anAttr = anAttrSelList->value(anIndex); + ResultPtr aContext = anAttr->context(); + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if (aResCompSolidPtr.get()) { + if (aCompSolid.get()) { + isAllInSameCompSolid = aCompSolid == aResCompSolidPtr; + } else { + aCompSolid = aResCompSolidPtr; + } + } else { + isAllInSameCompSolid = false; + break; + } + } + } + } + } + + anIt++; + + if (anObjectsNb + aToolsNb < 2) { + theError = "Not enough arguments for Fuse operation."; + return false; + } else if (isAllInSameCompSolid) { + theError = "Operations only between sub-shapes of the same shape not allowed."; + return false; + } + + return true; +} + +//================================================================================================= +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorBooleanFuseArguments::isNotObligatory( + std::string theFeature, + std::string theAttribute) +{ + if (theAttribute == "main_objects" || theAttribute == "tool_objects") { + return true; + } + + return false; +} +// LCOV_EXCL_STOP + +//================================================================================================== +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorBooleanCommonSelection::isValid( + const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + AttributeSelectionListPtr anAttrSelectionList = + std::dynamic_pointer_cast(theAttribute); + if (!anAttrSelectionList.get()) { + theError = + "Error: This validator can only work with selection list attributes in \"Boolean\" feature."; + return false; + } + + for (int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) { + AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex); + if (!anAttrSelection.get()) { + theError = "Error: Empty attribute selection."; + return false; + } + ResultPtr aContext = anAttrSelection->context(); + if (!aContext.get() && !anAttrSelection->contextFeature().get()) { + theError = "Error: Empty selection context."; + return false; + } + ResultConstructionPtr aResultConstruction = + std::dynamic_pointer_cast(aContext); + if (aResultConstruction.get()) { + if (theAttribute->id() != FeaturesPlugin_BooleanCommon::TOOL_LIST_ID()) { + theError = "Error: Result construction not allowed for selection."; + return false; + } + } + std::shared_ptr aShape = anAttrSelection->value(); + GeomShapePtr aContextShape; + if (aContext.get()) { + aContextShape = aContext->shape(); + } + if (!aShape.get()) { + aShape = aContextShape; + } + if (!aShape.get()) { + theError = "Error: Empty shape."; + return false; + } + if (aContextShape.get() && !aShape->isEqual(aContextShape)) { + theError = "Error: Local selection not allowed."; + return false; + } + + if (aResultConstruction.get() && aShape->shapeType() != GeomAPI_Shape::FACE) { + theError = "Error: Result construction should be plane."; + return false; + } + } + + return true; +} +// LCOV_EXCL_STOP + +//================================================================================================= +bool FeaturesPlugin_ValidatorBooleanCommonArguments::isValid( + const std::shared_ptr& theFeature, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + if (theArguments.size() != 2) { +// LCOV_EXCL_START + theError = "Wrong number of arguments (expected 2)."; + return false; +// LCOV_EXCL_STOP + } + + std::shared_ptr aFeature = + std::dynamic_pointer_cast(theFeature); + + int anObjectsNb = 0, aToolsNb = 0; + + std::list::const_iterator anIt = theArguments.begin(), aLast = theArguments.end(); + + bool isAllInSameCompSolid = true; + ResultBodyPtr aCompSolid; + + AttributeSelectionListPtr anAttrSelList = theFeature->selectionList(*anIt); + if (anAttrSelList) { + anObjectsNb = anAttrSelList->size(); + } + + bool isSimpleMode = aFeature->string(FeaturesPlugin_BooleanCommon::CREATION_METHOD())->value() + == FeaturesPlugin_BooleanCommon::CREATION_METHOD_SIMPLE(); + + if (!isSimpleMode) { + anAttrSelList = theFeature->selectionList(*anIt); + if (anAttrSelList) { + aToolsNb = anAttrSelList->size(); + } + } + + if ((isSimpleMode && anObjectsNb < 2) + || (!isSimpleMode && (anObjectsNb == 0 || aToolsNb == 0))) { + theError = "Not enough arguments for Fuse operation."; + return false; + } + return true; +} + +//================================================================================================= +// LCOV_EXCL_START +bool FeaturesPlugin_ValidatorBooleanCommonArguments::isNotObligatory( + std::string theFeature, + std::string theAttribute) +{ + return false; +} +// LCOV_EXCL_STOP