Module: Module::Cluster::InstanceController::InstanceControllerInterface

Included in:
Module::Cluster::InstanceController
Defined in:
lib/module/cluster/instance_controller/instance_controller_interface.rb

Overview

Interface implementation for Module::Cluster::InstanceController. 

Implementation provided separately for ease of overloading.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#instance ⇒ Object (readonly)

Get reference to object instance for which Instance Controller (self) is operative.



267
268
269
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 267

def instance
  @instance
end

#Object instance for which this Instance Controller operates.(instance) ⇒ Object (readonly)

Get reference to object instance for which Instance Controller (self) is operative.



267
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 267

attr_reader :instance

Instance Method Details

#after_extend_controller ⇒ Module::Cluster::InstanceController::HookController

Returns after-extend hook controller.

Returns:



168
169
170
171
172
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 168

def after_extend_controller

  return @after_extend_controller ||= self.class::HookController.new( :after_extend, self )

end

#after_extend_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for after-extend and subclass hook controllers.

Returns:



220
221
222
223
224
225
226
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 220

def after_extend_subclass_proxy

  return @after_extend_subclass_proxy ||= self.class::MultipleHookControllerProxy.new( :after_extend_subclass,
                                                                                       after_extend_controller,
                                                                                       subclass_controller )

end

#after_include_controller ⇒ Module::Cluster::InstanceController::HookController

Returns after-include hook controller.

Returns:



153
154
155
156
157
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 153

def after_include_controller

  return @after_include_controller ||= self.class::HookController.new( :after_include, self )

end

#after_include_extend_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for after-include and after-extend hook controllers.

Returns:



184
185
186
187
188
189
190
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 184

def after_include_extend_proxy

  return @after_include_extend_proxy ||= self.class::MultipleHookControllerProxy.new( :after_include_extend,
                                                                                      after_include_controller,
                                                                                      after_extend_controller )

end

#after_include_extend_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for after-include, after-extend, and subclass hook controllers.

Returns:



238
239
240
241
242
243
244
245
246
247
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 238

def after_include_extend_subclass_proxy

  @after_include_extend_subclass_proxy ||= self.class::
                                           MultipleHookControllerProxy.new( :after_include_extend_subclass,
                                                                            after_include_controller,
                                                                            after_extend_controller,
                                                                            subclass_controller )
  return @after_include_extend_subclass_proxy

end

#after_include_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for after-include and subclass hook controllers.

Returns:



202
203
204
205
206
207
208
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 202

def after_include_subclass_proxy

  return @after_include_subclass_proxy ||= self.class::MultipleHookControllerProxy.new( :after_include_subclass,
                                                                                        after_include_controller,
                                                                                        subclass_controller )

end

#before_extend_controller ⇒ Module::Cluster::InstanceController::HookController

Returns before-extend hook controller.

Returns:



63
64
65
66
67
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 63

def before_extend_controller

  return @before_extend_controller ||= self.class::HookController.new( :before_extend, self )

end

#before_extend_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for before-extend and subclass hook controllers.

Returns:



115
116
117
118
119
120
121
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 115

def before_extend_subclass_proxy

  return @before_extend_subclass_proxy ||= self.class::MultipleHookControllerProxy.new( :before_extend_subclass,
                                                                                        before_extend_controller,
                                                                                        subclass_controller )

end

#before_include_controller ⇒ Module::Cluster::InstanceController::HookController

Returns before-include hook controller.

Returns:



48
49
50
51
52
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 48

def before_include_controller

  return @before_include_controller ||= self.class::HookController.new( :before_include, self )

end

#before_include_extend_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for before-include and before-extend hook controllers.

Returns:



79
80
81
82
83
84
85
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 79

def before_include_extend_proxy

  return @before_include_extend_proxy ||= self.class::MultipleHookControllerProxy.new( :before_include_extend,
                                                                                       before_include_controller,
                                                                                       before_extend_controller )

end

#before_include_extend_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for before-include, before-extend, and subclass hook controllers.

Returns:



133
134
135
136
137
138
139
140
141
142
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 133

def before_include_extend_subclass_proxy

  @before_include_extend_subclass_proxy ||= self.class::
                                            MultipleHookControllerProxy.new( :before_include_extend_subclass,
                                                                             before_include_controller,
                                                                             before_extend_controller,
                                                                             subclass_controller )
  return @before_include_extend_subclass_proxy

end

#before_include_subclass_proxy ⇒ Module::Cluster::InstanceController::MultipleHookControllerProxy

Returns a multi-controller proxy for before-include and subclass hook controllers.

Returns:



97
98
99
100
101
102
103
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 97

def before_include_subclass_proxy

  return @before_include_subclass_proxy ||= self.class::MultipleHookControllerProxy.new( :before_include_subclass,
                                                                                         before_include_controller,
                                                                                         subclass_controller )

end

#initialize(instance) ⇒ Object

Parameters:

  • instance —

    Object instance for which Instance Controller is to operate.



18
19
20
21
22
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 18

def initialize( instance )
  
  @instance = instance
  
end

#subclass_controller ⇒ Module::Cluster::InstanceController::HookController

Returns subclass hook controller.

Returns:



33
34
35
36
37
 
# File 'lib/module/cluster/instance_controller/instance_controller_interface.rb', line 33

def subclass_controller

  return @subclass_controller ||= self.class::HookController.new( :subclass, self )

end