Module: Enumerable

Included in:
OpenHAB::Core::EmulateHash, OpenHAB::Core::LazyArray, OpenHAB::Core::Provider
Defined in:
lib/openhab/core/items/semantics/enumerable.rb,
lib/openhab/core/items/semantics.rb

Overview

Additions to Enumerable to allow easily filtering groups of items based on the semantic model

Filtering Methods Methods to help filter the members of the Enumerable collapse

Items State and Command Methods collapse

Filtering Methods collapse

Instance Method Details

#all_groups ⇒ Array<GroupItem>

Returns all groups all elements are a part of, recursively

Returns:



91
92
93
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 91

def all_groups
  flat_map(&:all_groups).uniq
end

#all_members ⇒ Array<Item>

Returns all non-group members of all group elements, recursively

Returns:



79
80
81
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 79

def all_members
  grep(OpenHAB::Core::Items::GroupItem).flat_map(&:all_members).uniq
end

#command(command, **kwargs) ⇒ self?

Send a command to every item in the collection

Returns:

  • (self, nil) —

    nil when ‘ensure` is in effect and all the items were already in the same state, otherwise self



100
101
102
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 100

def command(command, **kwargs)
  self if count { |i| i.command(command, **kwargs) }.positive?
end

#command!(command, **kwargs) ⇒ self

Send a command to every item in the collection, even when ensure_states! is in effect.

Returns:

  • (self) 


106
107
108
109
110
111
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 106

def command!(command, **kwargs)
  # We cannot alias this to #command above, otherwise it will call
  # DSL::Items::Ensure::Item#command which checks for ensure_states
  each { |i| i.command!(command, **kwargs) }
  self
end

#decrease ⇒ self

Send the DECREASE command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 162

#down ⇒ self

Send the DOWN command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 146

#equipments(*types) ⇒ Array<Item>

Note:

As equipments are usually GroupItems, this method therefore returns an array of GroupItems. In order to get the points that belong to the equipments, use #members before calling #points. See the example with #points.

Returns a new array of items that are a semantics equipment (optionally of one of the given types)

Examples:

Get all TVs in a room

lGreatRoom.equipments(Semantics::Television)

Get all TVs and Speakers in a room

lGreatRoom.equipments(Semantics::Television, Semantics::Speaker)

Returns:



649
650
651
652
653
654
655
656
657
658
659
660
 
# File 'lib/openhab/core/items/semantics.rb', line 649

def equipments(*types)
  begin
    raise ArgumentError unless types.all? { |type| type < Semantics::Equipment }
  rescue ArgumentError, TypeError
    raise ArgumentError, "type must be a subclass of Equipment"
  end

  result = select(&:equipment?)
  result.select! { |i| types.any? { |type| i.equipment_type <= type } } unless types.empty?

  result
end

#fast_forward ⇒ self

Send the FASTFORWARD command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 178

#groups ⇒ Array<GroupItem>

Returns the groups of all elements

Returns:



85
86
87
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 85

def groups
  flat_map(&:groups).uniq
end

#increase ⇒ self

Send the INCREASE command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 158

#locations(*types) ⇒ Array<Item>

Returns a new array of items that are a semantics Location (optionally of one of the given types)

Examples:

Get all rooms

items.locations(Semantics::Room)

Get all bedrooms and bathrooms

items.locations(Semantics::Bedroom, Semantics::Bathroom)

Returns:



619
620
621
622
623
624
625
626
627
628
629
630
 
# File 'lib/openhab/core/items/semantics.rb', line 619

def locations(*types)
  begin
    raise ArgumentError unless types.all? { |type| type < Semantics::Location }
  rescue ArgumentError, TypeError
    raise ArgumentError, "type must be a subclass of Location"
  end

  result = select(&:location?)
  result.select! { |i| types.any? { |type| i.location_type <= type } } unless types.empty?

  result
end

#member_of(*groups) ⇒ Array<Item>

Returns a new array of items that are a member of at least one of the given groups

Parameters:

Returns:



60
61
62
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 60

def member_of(*groups)
  select { |i| i.member_of?(*groups) }
end

#members ⇒ Array<Item>

Returns the group members of all group elements

Returns:



73
74
75
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 73

def members
  grep(OpenHAB::Core::Items::GroupItem).flat_map(&:members).uniq
end

#move ⇒ self

Send the MOVE command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 154

#next ⇒ self

Send the NEXT command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 182

#not_member_of(*groups) ⇒ Array<Item>

Returns a new array of items that are not a member of any of the given groups

Parameters:

Returns:



67
68
69
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 67

def not_member_of(*groups)
  reject { |i| i.member_of?(*groups) }
end

#not_tagged(*tags) ⇒ Array<Item>

Returns a new array of items that do not have any of the given tags

Parameters:

Returns:



53
54
55
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 53

def not_tagged(*tags)
  reject { |i| i.tagged?(*tags) }
end

#off ⇒ self

Send the OFF command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 138

#on ⇒ self

Send the ON command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 134

#pause ⇒ self

Send the PAUSE command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 170

#play ⇒ self

Send the PLAY command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 166

#points(*point_or_property_types) ⇒ Array<Item>

Returns a new array of items that are semantics points (optionally of a given type)

Examples:

Get all the power switch items for every equipment in a room

lGreatRoom.equipments.members.points(Semantics::Switch)

Returns:

See Also:



671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
 
# File 'lib/openhab/core/items/semantics.rb', line 671

def points(*point_or_property_types)
  unless (0..2).cover?(point_or_property_types.length)
    raise ArgumentError, "wrong number of arguments (given #{point_or_property_types.length}, expected 0..2)"
  end

  begin
    raise ArgumentError unless point_or_property_types.all? do |tag|
                                 tag < Semantics::Point ||
                                 tag < Semantics::Property
                               end
  rescue ArgumentError, TypeError
    raise ArgumentError, "point_or_property_types must all be a subclass of Point or Property"
  end
  if point_or_property_types.count { |tag| tag < Semantics::Point } > 1 ||
     point_or_property_types.count { |tag| tag < Semantics::Property } > 1
    raise ArgumentError, "point_or_property_types cannot both be a subclass of Point or Property"
  end

  select do |point|
    point.point? && point_or_property_types.all? do |tag|
      (tag < Semantics::Point && point.point_type&.<=(tag)) ||
        (tag < Semantics::Property && point.property_type&.<=(tag))
    end
  end
end

#previous ⇒ self

Send the PREVIOUS command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 186

#refresh ⇒ self

Send the REFRESH command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 130

#rewind ⇒ self

Send the REWIND command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 174

#stop ⇒ self

Send the STOP command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 150

#tagged(*tags) ⇒ Array<Item>

Returns a new array of items that have at least one of the given tags

Parameters:

Returns:



46
47
48
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 46

def tagged(*tags)
  select { |i| i.tagged?(*tags) }
end

#toggle(source: nil) ⇒ self

Send a toggle command to every item in the collection

Returns:

  • (self) 


201
202
203
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 201

def toggle(source: nil)
  each { |i| i.toggle(source: source) }
end

#up ⇒ self

Send the UP command to every item in the collection

Returns:

  • (self) 



# File 'lib/openhab/core/items/semantics/enumerable.rb', line 142

#update(state) ⇒ self?

Update the state of every item in the collection

Returns:

  • (self, nil) —

    nil when ‘ensure` is in effect and all the items were already in the same state, otherwise self



116
117
118
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 116

def update(state)
  self if count { |i| i.update(state) }.positive?
end

#update!(state) ⇒ self

Update the state of every item in the collection, even when

{OpenHAB::DSL.ensure_states! ensure_states!} is in effect.

Returns:

  • (self) 


123
124
125
126
127
128
 
# File 'lib/openhab/core/items/semantics/enumerable.rb', line 123

def update!(state)
  # We cannot alias this to #update above, otherwise it will call
  # DSL::Items::Ensure::Item#update which checks for ensure_states
  each { |i| i.update!(state) }
  self
end