Adds a transformation step to this description
354841
public void addStep(String operationName, List<String> sourceFields, String targetField,
            Map<String, String> parameters) {
        TransformationStep step = new TransformationStep();
        step.setOperationName(operationName);
        step.setSourceFields(sourceFields.toArray(new String[sourceFields.size()]));
        step.setTargetField(targetField);
        step.setOperationParams(parameters);
        steps.add(step);
    }
671623
def _process_transform(self, data, transform, step_size):
    '''
    
    '''
    if isinstance(transform, (list,tuple,set)):
      return { t : self._transform(data,t,step_size) for t in transform }
    elif isinstance(transform, dict):
      return { tn : self._transform(data,tf,step_size) for tn,tf in transform.items() }
    return self._transform(data,transform,step_size)
1198187
def _expand_inputs(step, steps=None):
    
    if steps is None:
        steps = set()

    for arg in step._kwargs.values():
        if isinstance(arg, Step):
            _expand_inputs(arg, steps=steps)
        elif util.is_instance_collection(arg, Step):
            for s in util.get_collection_values(arg):
                _expand_inputs(s, steps=steps)

    steps.add(step)
    return steps
61255
function mutate(entities, operationDescription, transformation) {
    if (!operationDescription) {
        return object;
    }

    return entities.map(item => {
        Object.keys(operationDescription)
            .forEach(key => transformation(item, key, operationDescription[key]));

        return item;
    });
}
1170026
def add_step(self, value_map):
        
        if len(self.trace) == 0:
            raise PyrtlError('error, simulation trace needs at least 1 signal to track '
                             '(by default, unnamed signals are not traced -- try either passing '
                             'a name to a WireVector or setting a "wirevector_subset" option)')
        for wire in self.trace:
            tracelist = self.trace[wire]
            wirevec = self._wires[wire]
            tracelist.append(value_map[wirevec])
607930
private void updateAdd()
    {
        if (willAdd)
        {
            for (final Featurable featurable : toAdd)
            {
                featurables.add(featurable);
                for (final HandlerListener listener : listeners)
                {
                    listener.notifyHandlableAdded(featurable);
                }
                if (featurable.hasFeature(Transformable.class))
                {
                    final Transformable transformable = featurable.getFeature(Transformable.class);
                    transformable.teleport(transformable.getX(), transformable.getY());
                }
            }
            toAdd.clear();
            willAdd = false;
        }
    }
543041
public function addTransformation($name, $transformation) {
        if ($transformation instanceof Transformation) {
            $this->handlers[$name] = $transformation;
        } else {
            $this->transformations[$name] = $transformation;
        }

        return $this;
    }
761715
def trigger_step(step, input, output, output_by_tag)
      arguments = step['arguments'] || {}

      # TODO: Move to a normal object: TriggerArgument
      step['arguments'] = transform_arguments(arguments, output, input)
      step['arguments'] = add_config_argument(arguments)

      # TODO: Move to a normal object: TriggerArgument
      output = plugin_manager.action_from_step(step)
      output_by_tag[step['tag']] = output if step.key? 'tag'

      output.merge(output_by_tag)
    end
585343
def add_time_step(self, **create_time_step_kwargs):
    
    ts = time_step.TimeStep.create_time_step(**create_time_step_kwargs)
    assert isinstance(ts, time_step.TimeStep)
    self._time_steps.append(ts)
390119
@NonNull
  public RequestCreator transform(@NonNull List<? extends Transformation> transformations) {
    data.transform(transformations);
    return this;
  }
419842
public ParallelTransformation addTransformations(Transformation<?, ?>... transformations)
	{
		for (Transformation<?, ?> transformation : transformations)
		{
			duration = Math.max(duration, transformation.totalDuration());
			listTransformations.add(transformation);
		}

		return this;
	}
141779
def add_step(self, setting, duration):
        
        if len(self._prog_steps) < 10:
            self._prog_steps.append(ProgramStep(self, setting, duration))
        else:
            raise IndexError("Maximum of 10 steps are allowed")
725610
function( el, idx ) {
            var data = el.dataset,
                step = {
                    translate: {
                        x: lib.util.toNumber( data.x ),
                        y: lib.util.toNumber( data.y ),
                        z: lib.util.toNumber( data.z )
                    },
                    rotate: {
                        x: lib.util.toNumber( data.rotateX ),
                        y: lib.util.toNumber( data.rotateY ),
                        z: lib.util.toNumber( data.rotateZ || data.rotate ),
                        order: validateOrder( data.rotateOrder )
                    },
                    scale: lib.util.toNumber( data.scale, 1 ),
                    transitionDuration: lib.util.toNumber(
                        data.transitionDuration, config.transitionDuration
                    ),
                    el: el
                };

            if ( !el.id ) {
                el.id = "step-" + ( idx + 1 );
            }

            stepsData[ "impress-" + el.id ] = step;

            css( el, {
                position: "absolute",
                transform: "translate(-50%,-50%)" +
                           translate( step.translate ) +
                           rotate( step.rotate ) +
                           scale( step.scale ),
                transformStyle: "preserve-3d"
            } );
        }
1045161
public Object transformObject(TransformationDescription description, Object source) throws InstantiationException,
        IllegalAccessException, ClassNotFoundException {
        return transformObject(description, source, null);
    }
756508
def _transform_row(self, in_row, out_row):
        
        tmp_row = {}

        for step in self._steps:
            park_info, ignore_info = step(in_row, tmp_row, out_row)
            if park_info or ignore_info:
                return park_info, ignore_info

        return None, None
715653
def adapt_step!(parsed_step)
      # Saving off the original data
      parsed_step['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))

      # Removing parsed data for child elements in order to avoid duplicating data
      parsed_step['cuke_modeler_parsing_data'][:argument] = nil

      parsed_step['keyword'] = parsed_step.delete(:keyword)
      parsed_step['name'] = parsed_step.delete(:text)
      parsed_step['line'] = parsed_step.delete(:location)[:line]


      step_argument = parsed_step[:argument]

      if step_argument
        case step_argument[:type]
          when :DocString
            adapt_doc_string!(step_argument)
            parsed_step['doc_string'] = parsed_step.delete(:argument)
          when :DataTable
            adapt_step_table!(step_argument)
            parsed_step['table'] = parsed_step.delete(:argument)
          else
            raise(ArgumentError, "Unknown step argument type: #{step_argument[:type]}")
        end
      end
    end
522823
def _add_step(self, pos):
        
        self._steps.append(pos)
        self._rec_x = pos[0]
        self._rec_y = pos[1]