Gecoder C0 Coverage Information - RCov

 # A module containing constraints that have set operands as left hand side

 # (but not enumerations).

   # A SetOperand is a combination of operands on which the

   # constraints defined in SetConstraintReceiver can be placed.

   #

   # Set operands can be created either by using Gecode::Mixin#set_var et

   # al, or by using properties that produce set operands. The operands,

   # no matter how they were created, all respond to the properties

   # defined by SetOperand.

   #

   # ==== Examples 

   #

   # Produces a single set operand (more specifically a SetVar), with

   # greatest lower bound {0} and least upper bound {0, 1, 2}, inside a

   # problem formulation, using Gecode::Mixin#set_var:

   #

   #   set_operand = set_var(0, 0..2)

   #

   # Uses the SetOperand#union property to produce a new set operand

   # representing the union between +set_operand1+ and +set_operand2+: 

   #

   #   new_set_operand = set_operand1.union(set_operand2)

   #

   # Uses the SetEnumOperand#union property to produce a new set operand

   # representing the union of the set operands in the enumeration

   # +set_enum+:

   # 

   #   new_set_operand = set_enum.union

   #

   # Uses the SetEnumOperand#[] property to produce a new set operand

   # representing the set operand at the index decided by

   # +int_operand+ (which can change during search) in the enumeration

   # +set_enum+:

   # 

   #   new_set_operand = set_enum[int_operand]

   #

   #--

   # Classes that mix in SetOperand must define #model and #to_set_var .

         # Delegate to the set var.

       else

       end

     end

     end

   end

   # An operand that short circuits set equality.

     end

               operand.respond_to? :to_set_var

             # Short circuit the constraint.

                 @model, @params) do

                 @params.values_at(:strength, :kind))

             end)

           else

           end

         end

       end

     end

           {}).values_at(:strength, :kind)

       end

     end

     # Constrains this operand to equal +set_operand+ using the

     # specified +propagation_options+. If +constrain_domain+ is true

     # then the method should also attempt to constrain the bounds of the

     # domain of +set_operand+.

     end

   end

   # An operand that short circuits set non-negated and non-reified versions 

   # of the relation constraints.

     end

             alias_method :alias_#{comp.to_i}_without_short_circuit, :#{comp}

             def #{comp}(operand, options = {})

               if !@params[:negate] && !options.has_key?(:reify) && 

                   (operand.respond_to?(:to_set_var) or 

                   Gecode::Util::constant_set?(operand))

                 # Short circuit the constraint.

                 @params.update Gecode::Set::Util.decode_options(options)

                 @model.add_constraint(

                   @short_circuit.relation_constraint(

                     :#{comp}, operand, @params))

               else

                 alias_#{comp.to_i}_without_short_circuit(operand, options)

               end

             end

           end_code

         end

       end

     end

     end

     # Returns a constraint that constrains this operand to have relation

     # +relation+ to +set_operand_or_constant_set+, which is either a set

     # operand or a constant set, given the specified hash +params+ of 

     # parameters. The constraints are never negated nor reified.

     end

   end

   # SetConstraintReceiver contains all constraints that can be

   # placed on a SetOperand.

   #

   # Constraints are placed by calling SetOperand#must (or any other

   # of the variations defined in Operand), which produces a 

   # SetConstraintReceiver from which the desired constraint can be used.

   #

   # Most constraint accept :reify option. See ConstraintReceiver for

   # more information.

   #

   # ==== Examples 

   #

   # Constrains +set_operand+ to be a subset of {0, 1, 2} using

   # an alias of SetConstraintReceiver#subset:

   #

   #   set_operand.must_be.subset_of 0..2

   #

   # Constrains the union of +set_operand1+ and +set_operand2+ to a

   # subset of {0, 1, 2} using the SetOperand#union property and

   # SetConstraintReceiver#subset:

   #

   #   set_operand1.union(set_operand2).must_be.subset_of 0..2

   #

   # Constrains the union of the set operands in +set_enum+ to _not_ 

   # equal {0, 1, 2} by using the SetEnumOperand#union property and 

   # an alias of SetConstraintReceiver#==:

   #

   #   set_enum.union.must_not == 0..2

   #

   # The same as above, but alsa specifying that the constraint should be 

   # reified with +bool_operand+:

   #

   #   set_enum.union.must_not.equal(0..2, :reify => bool_operand)

   #

     # Raises TypeError unless the left hand side is a set operand.

       end

     end

   end

   # Utility methods for sets.

           'option.'

       end

           'option.'

       end

     end

   end

 end