def deploy_output__filtered(self):
filtered_var = NodeOutputVariableName(self.id, 'filtered')
entry_var = NodeOutputVariableName(self.id, 'entry')
index_var = NodeOutputVariableName(self.id, 'index')
array_var = self.get_input_connection_variable_name('array')
i_var = NodePrivateVariableName(self.id, 'i')
return LanguageConcat(
self.resolve_input_deploy('array'),
VariableSetStatement(entry_var, LanguageNone()),
VariableSetStatement(index_var, LanguageNone()),
self.resolve_input_deploy_function('keep'),
VariableSetStatement(filtered_var,
LanguageValue(EmptyArraySymbol())),
SimpleLoopStatement(
i_var, LanguageValue(0),
LanguageValue(UtilsArrayLength(array_var)),
LanguageConcat(
VariableSetStatement(index_var, i_var),
VariableSetStatement(entry_var,
ArrayIndex(array_var, i_var)),
IfStatement(
FunctionCall(
self.get_input_connection_function_name('keep')),
VariableSetStatement(
filtered_var,
UtilsArrayConcat(filtered_var, entry_var))))))
def deploy_output__increment(self):
increment_var = NodeOutputVariableName(self.id, 'increment')
return LanguageConcat(
self.deploy_state_init('value', LanguageValue(0)),
VariableSetStatement(
increment_var,
LanguageOperation(AddSymbol(),
self.deploy_state_value('value'),
LanguageValue(1))),
self.deploy_state_update('value', increment_var))
def deploy_output__mapped(self):
i_var = NodePrivateVariableName(self.id, 'i')
entry_var = NodeOutputVariableName(self.id, 'entry')
index_var = NodeOutputVariableName(self.id, 'index')
mapped_var = NodeOutputVariableName(self.id, 'mapped')
return LanguageConcat(
self.resolve_input_deploy('array'),
VariableSetStatement(entry_var, LanguageNone()),
VariableSetStatement(index_var, LanguageNone()),
self.resolve_input_deploy_function('value'),
VariableSetStatement(
mapped_var,
UtilsArrayClone(
self.get_input_connection_variable_name('array'))),
SimpleLoopStatement(
i_var, LanguageValue(0),
UtilsArrayLength(
self.get_input_connection_variable_name('array')),
LanguageConcat(
VariableSetStatement(index_var, i_var),
VariableSetStatement(
entry_var,
ArrayIndex(
self.get_input_connection_variable_name('array'),
i_var)),
VariableSetStatement(
ArrayIndex(mapped_var, i_var),
FunctionCall(
self.get_input_connection_function_name(
'value'))))))
def deploy_output__reduced(self):
array_var = self.get_input_connection_variable_name('array')
i_var = NodePrivateVariableName(self.id, 'i')
acc_var = NodeOutputVariableName(self.id, 'accumulator')
cur_var = NodeOutputVariableName(self.id, 'current')
return LanguageConcat(
self.resolve_input_deploy('array'),
VariableSetStatement(acc_var,
ArrayIndex(array_var, LanguageValue(0))),
VariableSetStatement(cur_var, LanguageNone()),
self.resolve_input_deploy_function('accumulator'),
SimpleLoopStatement(
i_var, LanguageValue(1), UtilsArrayLength(array_var),
LanguageConcat(
VariableSetStatement(cur_var, ArrayIndex(array_var,
i_var)),
VariableSetStatement(
acc_var,
FunctionCall(
self.get_input_connection_function_name(
'accumulator'))))),
VariableSetStatement(NodeOutputVariableName(self.id, 'reduced'),
acc_var))
def deploy_output__merged(self):
merged_var = NodeOutputVariableName(self.id, 'merged')
input_deploys = []
input_concats = []
for n in range(self.array_count):
input_deploys.append(self.resolve_input_deploy('in_%d' % n))
input_concats.append(
VariableSetStatement(
merged_var,
UtilsArrayConcat(merged_var, self.get_input_connection_variable_name('in_%d' % n))
)
)
return LanguageConcat(
*input_deploys,
VariableSetStatement(merged_var, LanguageValue(EmptyArraySymbol())),
*input_concats
)
def deploy_output__value(self):
num_var = self.get_input_connection_variable_name('number')
value_var = NodeOutputVariableName(self.id, 'value')
if_statements = []
for n in range(self.count):
if_statements.append(
IfStatement(LanguageOperation(CompareEqualsSymbol(), num_var,
LanguageValue(n)),
LanguageConcat(
self.resolve_input_deploy(f'in_{n}'),
VariableSetStatement(
value_var,
self.get_input_connection_variable_name(
f'in_{n}'))),
if_type='if' if n == 0 else
'elseif' if n != self.count - 1 else 'else'))
return LanguageConcat(self.resolve_input_deploy('number'),
VariableSetStatement(value_var, LanguageNone()),
*if_statements)
def deploy_output__object(self):
object_var = NodeOutputVariableName(self.id, 'object')
input_deploys = []
input_sets = []
for n in range(self.property_count):
input_deploys.append(self.resolve_input_deploy('key_%d' % n))
input_deploys.append(self.resolve_input_deploy('value_%d' % n))
input_sets.append(
VariableSetStatement(
ArrayIndex(
object_var,
self.get_input_connection_variable_name('key_%d' % n)
),
self.get_input_connection_variable_name('value_%d' % n)
)
)
return LanguageConcat(
*input_deploys,
VariableSetStatement(
object_var,
LanguageValue(EmptyDictSymbol())
),
*input_sets
)
def deploy_output__data(self):
return VariableSetStatement(NodeOutputVariableName(self.id, 'data'), LanguageValue(self.data))
def deploy_output__value(self):
return LanguageConcat(
self.deploy_state_init('value', LanguageValue(0)),
VariableSetStatement(NodeOutputVariableName(self.id, 'value'),
self.deploy_state_value('value')))
def __py__(self, c):
return FunctionCall(
VariableName('math.pow'), self.value,
LanguageOperation(DivideSymbol(), LanguageValue(1),
self.root)).__py__(c)