Parent

Included Modules

Class/Module Index [+]

Quicksearch

DataMapper::Query::Conditions::AbstractOperation

Attributes

children[R]

Returns the child operations and comparisons

@return [Set<AbstractOperation, AbstractComparison, Array>]

the set of operations and comparisons

@api semipublic

operands[R]

Returns the child operations and comparisons

@return [Set<AbstractOperation, AbstractComparison, Array>]

the set of operations and comparisons

@api semipublic

parent[RW]

Returns the parent operation

@return [AbstractOperation]

the parent operation

@api semipublic

Public Class Methods

descendants() click to toggle source

Returns the classes that inherit from AbstractComparison

@return [Set]

the descendant classes

@api private

# File lib/dm-core/query/conditions/operation.rb, line 99
def self.descendants
  @descendants ||= DescendantSet.new
end
inherited(descendant) click to toggle source

Hook executed when inheriting from AbstractComparison

@return [undefined]

@api private

# File lib/dm-core/query/conditions/operation.rb, line 108
def self.inherited(descendant)
  descendants << descendant
end
new(*operands) click to toggle source

Initialize an operation

@param [Array<AbstractOperation, AbstractComparison, Array>] *operands

the operands to include in the operation

@return [AbstractOperation]

the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 333
def initialize(*operands)
  @operands = Set.new
  merge(operands)
end
slug(slug = nil) click to toggle source

Get and set the slug for the operation class

@param [Symbol] slug

optionally set the slug for the operation class

@return [Symbol]

the slug for the operation class

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 121
def self.slug(slug = nil)
  slug ? @slug = slug : @slug
end

Public Instance Methods

&(other) click to toggle source
Alias for: intersection
+(other) click to toggle source
Alias for: union
-(other) click to toggle source
Alias for: difference
<<(operand) click to toggle source

Add an operand to the operation

@param [AbstractOperation, AbstractComparison, Array] operand

the operand to add

@return [self]

the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 202
def <<(operand)
  assert_valid_operand_type(operand)
  @operands << relate_operand(operand)
  self
end
clear() click to toggle source

Clear the operands

@return [self]

the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 284
def clear
  @operands.clear
  self
end
difference(other) click to toggle source

Return the difference of the operation and another operand

@param [AbstractOperation] other

the operand to not match

@return [AndOperation]

the intersection of the operation and operand

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 262
def difference(other)
  Operation.new(:and, dup, Operation.new(:not, other.dup)).minimize
end
Also aliased as: -
each() click to toggle source

Iterate through each operand in the operation

@yield [operand]

yields to each operand

@yieldparam [AbstractOperation, AbstractComparison, Array] operand

each operand

@return [self]

returns the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 158
def each
  @operands.each { |op| yield op }
  self
end
empty?() click to toggle source

Test to see if there are operands

@return [Boolean]

returns true if there are operands

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 169
def empty?
  @operands.empty?
end
first() click to toggle source

Get the first operand

@return [AbstractOperation, AbstractComparison, Array]

returns the first operand

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 141
def first
  each { |operand| return operand }
  nil
end
intersection(other) click to toggle source

Return the intersection of the operation and another operand

@param [AbstractOperation] other

the operand to intersect with

@return [AndOperation]

the intersection of the operation and operand

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 247
def intersection(other)
  Operation.new(:and, dup, other.dup).minimize
end
Also aliased as: &
merge(operands) click to toggle source

Add operands to the operation

@param [each] operands

the operands to add

@return [self]

the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 217
def merge(operands)
  operands.each { |op| self << op }
  self
end
minimize() click to toggle source

Minimize the operation

@return [self]

the minimized operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 274
def minimize
  self
end
negated?() click to toggle source

Test if the operation is negated

Defaults to return false.

@return [Boolean]

true if the operation is negated, false if not

@api private

# File lib/dm-core/query/conditions/operation.rb, line 307
def negated?
  parent = self.parent
  parent ? parent.negated? : false
end
one?() click to toggle source

Test to see if there is one operand

@return [Boolean]

true if there is only one operand

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 179
def one?
  @operands.size == 1
end
slug() click to toggle source

Return the comparison class slug

@return [Symbol]

the comparison class slug

@api private

# File lib/dm-core/query/conditions/operation.rb, line 131
def slug
  self.class.slug
end
sorted_operands() click to toggle source

Return a list of operands in predictable order

@return [Array<AbstractOperation, AbstractComparison, Array>]

list of operands sorted in deterministic order

@api private

# File lib/dm-core/query/conditions/operation.rb, line 318
def sorted_operands
  sort_by { |op| op.hash }
end
to_s() click to toggle source

Return the string representation of the operation

@return [String]

the string representation of the operation

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 295
def to_s
  empty? ? '' : "(#{sort_by { |op| op.to_s }.map { |op| op.to_s }.join(" #{slug.to_s.upcase} ")})"
end
union(other) click to toggle source

Return the union with another operand

@param [AbstractOperation] other

the operand to union with

@return [OrOperation]

the union of the operation and operand

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 231
def union(other)
  Operation.new(:or, dup, other.dup).minimize
end
Also aliased as: |, +
valid?() click to toggle source

Test if the operation is valid

@return [Boolean]

true if the operation is valid, false if not

@api semipublic

# File lib/dm-core/query/conditions/operation.rb, line 189
def valid?
  any? && all? { |op| valid_operand?(op) }
end
|(other) click to toggle source
Alias for: union

[Validate]

Generated with the Darkfish Rdoc Generator 2.