Class: OpenWFE::ExpressionMap

Inherits:
Object
  • Object
show all
Defined in:
lib/openwfe/expressions/expressionmap.rb

Overview

The mapping between expression names like ‘sequence’, ‘participant’, etc and classes like ‘ParticipantExpression’, ‘SequenceExpression’, etc.

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ExpressionMap

Returns a new instance of ExpressionMap.



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 78

def initialize ()

    super

    @expressions = {}
    @ancestors = {}

    register DefineExpression

    register SequenceExpression
    register ParticipantExpression

    register ConcurrenceExpression
    register GenericSyncExpression

    register ConcurrentIteratorExpression

    register SubProcessRefExpression

    register SetValueExpression
    register UnsetValueExpression

    register DefinedExpression

    register IfExpression
    register CaseExpression

    register EqualsExpression

    register SleepExpression
    register CronExpression
    register WhenExpression
    register WaitExpression

    register ReserveExpression

    register RevalExpression
    register PrintExpression
    register LogExpression

    register LoseExpression
    register ForgetExpression

    register CursorExpression
    register LoopExpression

    register CursorCommandExpression

    register IteratorExpression

    register FqvExpression
    register AttributeExpression

    register CancelProcessExpression

    register UndoExpression
    register RedoExpression

    register SaveWorkItemExpression
    register RestoreWorkItemExpression

    register FilterDefinitionExpression
    register FilterExpression

    register ListenExpression

    register TimeoutExpression

    register EvalExpression
    register ExpExpression

    register Environment
        #
        # only used by get_expression_names()

    register_ancestors RawExpression
    #register_ancestors XmlRawExpression
    #register_ancestors ProgRawExpression
        #
        # just register the ancestors for those two
end

Instance Method Details

#get_class(expression_name) ⇒ Object

Returns the expression class corresponding to the given expression name



164
165
166
167
168
169
170
171
172
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 164

def get_class (expression_name)

    expression_name = expression_name.expression_name \
        if expression_name.kind_of?(RawExpression)

    expression_name = OpenWFE::symbol_to_name(expression_name)

    @expressions[expression_name]
end

#get_expression_classes(ancestor) ⇒ Object

Returns an array of expression classes that have the given class/module among their ancestors.



211
212
213
214
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 211

def get_expression_classes (ancestor)

    @ancestors[ancestor]
end

#get_expression_names(expression_class) ⇒ Object

Returns an array of expression names whose class are assignable from the given expression_class.



195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 195

def get_expression_names (expression_class)

    return expression_class.expression_names \
        if expression_class.method_defined?(:expression_names)

    names = []
    @expressions.each do |k, v|
        names << k if v.ancestors.include? expression_class
    end
    names
end

#get_sync_class(expression_name) ⇒ Object 



174
175
176
177
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 174

def get_sync_class (expression_name)

    get_class(expression_name)
end

#is_definition?(expression_name) ⇒ Boolean

Returns true if the given expression name (‘sequence’, ‘process-definition’, …) is a DefineExpression.

Returns:

  • (Boolean) 


183
184
185
186
187
188
189
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 183

def is_definition? (expression_name)

    c = get_class(expression_name)

    #c == DefineExpression
    (c and c.is_definition?)
end

#register(expression_class) ⇒ Object

Registers an Expression class within this expression map. This method is usually never called from out of the ExpressionMap class, but, who knows, it could prove useful one day as a ‘public’ method.



230
231
232
233
234
235
236
237
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 230

def register (expression_class)

    expression_class.expression_names.each do |name|
        name = OpenWFE::to_dash(name)
        @expressions[name] = expression_class
    end
    register_ancestors expression_class
end

#to_s ⇒ Object 



216
217
218
219
220
221
222
 
# File 'lib/openwfe/expressions/expressionmap.rb', line 216

def to_s
    s = ""
    @expressions.keys.sort.each do |name|
        s << "- '#{name}' -> '#{@expressions[name].to_s}'\n"
    end
    s
end