CloneSet2


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
26510.952selection_statement
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
1261113
InclusionConstraintGraph/Graph.h
2261194
InclusionConstraintGraph/Graph.h
3261385
InclusionConstraintGraph/Graph.h
4261415
InclusionConstraintGraph/Graph.h
5261450
InclusionConstraintGraph/Graph.h
Clone Instance
1
Line Count
26
Source Line
1113
Source File
InclusionConstraintGraph/Graph.h

                                                                                                        if (including_node != included_node) {
                                                                                                                #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                        if (!including_node->GetInclusionConstraints().IsIn(included_node)) {
                                                                                                                                bool already_included=false;
                                                                                                                                const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
                                                                                                                                for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                        if (inclusion_constraints[ic] != included_node) {
                                                                                                                                                if (inclusion_constraints[ic]->TransitivelyCollapse() == included_node) {
                                                                                                                                                        already_included = true;
                                                                                                                                                                                                                        }
                                                                                                                                                                                        }
                                                                                                                                        else   {
                                                                                                                                                already_included = true;
                                                                                                                                               }
                                                                                                                                                                                              }
                                                                                                                                if (!already_included) {
                                                                                                                                        including_node->EstablishIncludes(included_node);
                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                        number_of_changes++;
                                                                                                                                                       }
                                                                                                                                                                                            }
                                                                                                                #else
                                                                                                                        if (including_node->EstablishIncludes(included_node)) {
                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                number_of_changes++;
                                                                                                                                                                              }
                                                                                                                #endif
                                                                                                                                             }


Clone Instance
2
Line Count
26
Source Line
1194
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                if (including_node != included_node) {
                                                                                                                        #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                if (!including_node->GetInclusionConstraints().IsIn(included_node)) {
                                                                                                                                        bool already_included=false;
                                                                                                                                        const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
                                                                                                                                        for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                if (inclusion_constraints[ic] != included_node) {
                                                                                                                                                        if (inclusion_constraints[ic]->TransitivelyCollapse() == included_node) {
                                                                                                                                                                already_included = true;
                                                                                                                                                                                                                                }
                                                                                                                                                                                                }
                                                                                                                                                else   {
                                                                                                                                                        already_included = true;
                                                                                                                                                       }
                                                                                                                                                                                                      }
                                                                                                                                        if (!already_included) {
                                                                                                                                                including_node->EstablishIncludes(included_node);
                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                number_of_changes++;
                                                                                                                                                               }
                                                                                                                                                                                                    }
                                                                                                                        #else
                                                                                                                                if (including_node->EstablishIncludes(included_node)) {
                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                        number_of_changes++;
                                                                                                                                                                                      }
                                                                                                                        #endif
                                                                                                                                                     }


Clone Instance
3
Line Count
26
Source Line
1385
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                                        if (including_node != argument) {
                                                                                                                                                #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                                        if (!including_node->GetInclusionConstraints().IsIn(argument)) {
                                                                                                                                                                bool already_included=false;
                                                                                                                                                                const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
                                                                                                                                                                for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                                        if (inclusion_constraints[ic] != argument) {
                                                                                                                                                                                if (inclusion_constraints[ic]->TransitivelyCollapse() == argument) {
                                                                                                                                                                                        already_included = true;
                                                                                                                                                                                                                                                   }
                                                                                                                                                                                                                   }
                                                                                                                                                                        else   {
                                                                                                                                                                                already_included = true;
                                                                                                                                                                               }
                                                                                                                                                                                                                              }
                                                                                                                                                                if (!already_included) {
                                                                                                                                                                        including_node->EstablishIncludes(argument);
                                                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                                                        number_of_changes++;
                                                                                                                                                                                       }
                                                                                                                                                                                                                       }
                                                                                                                                                #else
                                                                                                                                                        if (including_node->EstablishIncludes(argument)) {
                                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                                number_of_changes++;
                                                                                                                                                                                                         }
                                                                                                                                                #endif
                                                                                                                                                                        }


Clone Instance
4
Line Count
26
Source Line
1415
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                                                if (including_node != argument) {
                                                                                                                                                        #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                                                if (!including_node->GetInclusionConstraints().IsIn(argument)) {
                                                                                                                                                                        bool already_included=false;
                                                                                                                                                                        const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
                                                                                                                                                                        for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                                                if (inclusion_constraints[ic] != argument) {
                                                                                                                                                                                        if (inclusion_constraints[ic]->TransitivelyCollapse() == argument) {
                                                                                                                                                                                                already_included = true;
                                                                                                                                                                                                                                                           }
                                                                                                                                                                                                                           }
                                                                                                                                                                                else   {
                                                                                                                                                                                        already_included = true;
                                                                                                                                                                                       }
                                                                                                                                                                                                                                      }
                                                                                                                                                                        if (!already_included) {
                                                                                                                                                                                including_node->EstablishIncludes(argument);
                                                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                                                number_of_changes++;
                                                                                                                                                                                               }
                                                                                                                                                                                                                               }
                                                                                                                                                        #else
                                                                                                                                                                if (including_node->EstablishIncludes(argument)) {
                                                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                                                        number_of_changes++;
                                                                                                                                                                                                                 }
                                                                                                                                                        #endif
                                                                                                                                                                                }


Clone Instance
5
Line Count
26
Source Line
1450
Source File
InclusionConstraintGraph/Graph.h

                                                                                                                                if (including_node != argument) {
                                                                                                                                        #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
                                                                                                                                                if (!including_node->GetInclusionConstraints().IsIn(argument)) {
                                                                                                                                                        bool already_included=false;
                                                                                                                                                        const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
                                                                                                                                                        for (std::size_t ic=0; ic <inclusion_constraints.Size();ic++) {
                                                                                                                                                                if (inclusion_constraints[ic] != argument) {
                                                                                                                                                                        if (inclusion_constraints[ic]->TransitivelyCollapse() == argument) {
                                                                                                                                                                                already_included = true;
                                                                                                                                                                                                                                           }
                                                                                                                                                                                                           }
                                                                                                                                                                else   {
                                                                                                                                                                        already_included = true;
                                                                                                                                                                       }
                                                                                                                                                                                                                      }
                                                                                                                                                        if (!already_included) {
                                                                                                                                                                including_node->EstablishIncludes(argument);
                                                                                                                                                                changed_on_current_iteration = true;
                                                                                                                                                                number_of_changes++;
                                                                                                                                                                               }
                                                                                                                                                                                                               }
                                                                                                                                        #else
                                                                                                                                                if (including_node->EstablishIncludes(argument)) {
                                                                                                                                                        changed_on_current_iteration = true;
                                                                                                                                                        number_of_changes++;
                                                                                                                                                                                                 }
                                                                                                                                        #endif
                                                                                                                                                                }


Clone AbstractionParameter Count: 1Parameter Bindings

if (including_node != [[#variable4f86f60]])
  {
    #if PERFORM_EXTENDED_ALREADY_INCLUDED_CHECKS
      if (!including_node->GetInclusionConstraints().IsIn([[#variable4f86f60]]))
        {
          bool already_included = false;
          const SetOfNodes &inclusion_constraints = including_node->GetInclusionConstraints();
          for (std::size_t ic = 0; ic < inclusion_constraints.Size(); ic++)
            {
              if (inclusion_constraints[ic] != [[#variable4f86f60]])
                {
                  if (inclusion_constraints[ic]->TransitivelyCollapse() == [[#variable4f86f60]])
                    {
                      already_included = true;
                    }
                }
              else
                {
                  already_included = true;
                }
            }
          if (!already_included)
            {
              including_node->EstablishIncludes([[#variable4f86f60]]);
              changed_on_current_iteration = true;
              number_of_changes++;
            }
        }
    #else
      if (including_node->EstablishIncludes([[#variable4f86f60]]))
        {
          changed_on_current_iteration = true;
          number_of_changes++;
        }
    #endif
  }
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#4f86f60]]
argument 
12[[#4f86f60]]
included_node 
13[[#4f86f60]]
argument 
14[[#4f86f60]]
argument 
15[[#4f86f60]]
included_node