Called at the beggining of an operation
554323
function (t, timerName) {
            if (this.enabled) {
                var id = _.uniqueId('jt');
                this._startDate[id] = t || (+new Date());
                if (console.profile && timerName) {
                    this._timerConsoleName[id] = timerName;
                    console.profile(timerName);
                }
                return id;
            }
        }
222692
def call(procedure, args=nil, kwargs=nil, options={}, &callback)
      command = WampRails::Command::Call.new(procedure, args, kwargs, options, self)
      self._queue_command(command, callback)
    end
312389
function () {
			BaseController.prototype.onInit.call(this);

			// manually call the handler once at startup as device API won't do this for us
			this._onOrientationChange({
				landscape: Device.orientation.landscape
			});

			this.getRouter().getRoute("tools").attachPatternMatched(this._onMatched, this);
		}
659836
def call(operation_name, *args, **kwargs):
        

        logger.debug('VipsOperation.call: operation_name = %s', operation_name)
        # logger.debug('VipsOperation.call: args = %s, kwargs =%s',
        #              args, kwargs)

        # pull out the special string_options kwarg
        string_options = kwargs.pop('string_options', '')

        logger.debug('VipsOperation.call: string_options = %s', string_options)

        op = Operation.new_from_name(operation_name)

        arguments = op.get_args()
        # logger.debug('arguments = %s', arguments)

        # make a thing to quickly get flags from an arg name
        flags_from_name = {}

        # count required input args
        n_required = 0

        for name, flags in arguments:
            flags_from_name[name] = flags

            if ((flags & _INPUT) != 0 and
                    (flags & _REQUIRED) != 0 and
                    (flags & _DEPRECATED) == 0):
                n_required += 1

        if n_required != len(args):
            raise Error('unable to call {0}: {1} arguments given, '
                        'but {2} required'.format(operation_name, len(args),
                                                  n_required))

        # the first image argument is the thing we expand constants to
        # match ... look inside tables for images, since we may be passing
        # an array of image as a single param
        match_image = _find_inside(lambda x:
                                   isinstance(x, pyvips.Image),
                                   args)

        logger.debug('VipsOperation.call: match_image = %s', match_image)

        # set any string options before any args so they can't be
        # overridden
        if not op.set_string(string_options):
            raise Error('unable to call {0}'.format(operation_name))

        # set required and optional args
        n = 0
        for name, flags in arguments:
            if ((flags & _INPUT) != 0 and
                    (flags & _REQUIRED) != 0 and
                    (flags & _DEPRECATED) == 0):
                op.set(name, flags, match_image, args[n])
                n += 1

        for name, value in kwargs.items():
            if name not in flags_from_name:
                raise Error('{0} does not support argument '
                            '{1}'.format(operation_name, name))

            op.set(name, flags_from_name[name], match_image, value)

        # build operation
        vop = vips_lib.vips_cache_operation_build(op.pointer)
        if vop == ffi.NULL:
            raise Error('unable to call {0}'.format(operation_name))
        op = Operation(vop)

        # find all input images and gather up all the references they hold
        references = []

        def add_reference(x):
            if isinstance(x, pyvips.Image):
                # += won't work on non-local references
                for i in x._references:
                    references.append(i)

            return False

        _find_inside(add_reference, args)
        for key, value in kwargs.items():
            _find_inside(add_reference, value)

        # fetch required output args, plus modified input images
        result = []
        for name, flags in arguments:
            if ((flags & _OUTPUT) != 0 and
                    (flags & _REQUIRED) != 0 and
                    (flags & _DEPRECATED) == 0):
                result.append(op.get(name))

            if (flags & _INPUT) != 0 and (flags & _MODIFY) != 0:
                result.append(op.get(name))

        # fetch optional output args
        opts = {}
        for name, value in kwargs.items():
            flags = flags_from_name[name]

            if ((flags & _OUTPUT) != 0 and
                    (flags & _REQUIRED) == 0 and
                    (flags & _DEPRECATED) == 0):
                opts[name] = op.get(name)

        vips_lib.vips_object_unref_outputs(op.object)

        if len(opts) > 0:
            result.append(opts)

        # all output images need all input references
        def set_reference(x):
            if isinstance(x, pyvips.Image):
                x._references += references

            return False

        _find_inside(set_reference, result)

        if len(result) == 0:
            result = None
        elif len(result) == 1:
            result = result[0]

        logger.debug('VipsOperation.call: result = %s', result)

        return result
1186993
protected function runOperations() {
		foreach( $this->operations as $operation ) {
			$operation->setTransactionOperationSet($this);
			$operation->runIfValid();
		}
	}
423835
@Override
    public Void call() {
        if (shouldAnalyze()) {
            LOGGER.debug("Begin Analysis of '{}' ({})", dependency.getActualFilePath(), analyzer.getName());
            try {
                analyzer.analyze(dependency, engine);
            } catch (AnalysisException ex) {
                LOGGER.warn("An error occurred while analyzing '{}' ({}).", dependency.getActualFilePath(), analyzer.getName());
                LOGGER.debug("", ex);
                exceptions.add(ex);
            } catch (Throwable ex) {
                LOGGER.warn("An unexpected error occurred during analysis of '{}' ({}): {}",
                        dependency.getActualFilePath(), analyzer.getName(), ex.getMessage());
                LOGGER.error("", ex);
                exceptions.add(ex);
            }
        }
        return null;
    }
824485
def initiate(self, aspect=None, view=None, parent=None, officer=None):
        """"""

        def got_view(view):
            if view is None:
                return None
            return init(view)

        def init(view):
            self.view = view
            d = self.call_mro("init")
            d.addCallback(retrieve_reference)
            d.addCallback(update_reference)
            return d

        def retrieve_reference(_param):
            if callable(self._model_reference):
                context = self.make_context()
                return self._model_reference(self.source, context)
            return self._model_reference

        def update_reference(reference):
            self.reference = reference
            return self

        if officer is not None:
            self.officer = IOfficer(officer)
        self.aspect = IAspect(aspect) if aspect is not None else None
        if self._model_view is not None:
            if callable(self._model_view):
                context = self.make_context(view=view)
                d = self._model_view(None, context)
                return d.addCallback(got_view)
            return init(self._model_view)
        return init(view)
1130952
void prepare() {
		if (Op.COUNT)
			Op.nofinstances = 0;
		this.compile(this.tokentree);
		/*
		 * if (this.operations.type == Op.CLOSURE &&
		 * this.operations.getChild().type == Op.DOT) { // .* Op anchor =
		 * Op.createAnchor(isSet(this.options, SINGLE_LINE) ? 'A' : '@');
		 * anchor.next = this.operations; this.operations = anchor; }
		 */
		if (Op.COUNT)
			System.err.println("DEBUG: The number of operations: "
					+ Op.nofinstances);

		this.minlength = this.tokentree.getMinLength();

		this.firstChar = null;
		if (!isSet(this.options, PROHIBIT_HEAD_CHARACTER_OPTIMIZATION)
				&& !isSet(this.options, XMLSCHEMA_MODE)) {
			RangeToken firstChar = Token.createRange();
			int fresult = this.tokentree.analyzeFirstCharacter(firstChar,
					this.options);
			if (fresult == Token.FC_TERMINAL) {
				firstChar.compactRanges();
				this.firstChar = firstChar;
				if (DEBUG)
					System.err
							.println("DEBUG: Use the first character optimization: "
									+ firstChar);
			}
		}

		if (this.operations != null
				&& (this.operations.type == Op.STRING || this.operations.type == Op.CHAR)
				&& this.operations.next == null) {
			if (DEBUG)
				System.err.print(" *** Only fixed string! *** ");
			this.fixedStringOnly = true;
			if (this.operations.type == Op.STRING)
				this.fixedString = this.operations.getString();
			else if (this.operations.getData() >= 0x10000) { // Op.CHAR
				this.fixedString = REUtil.decomposeToSurrogates(this.operations
						.getData());
			} else {
				char[] ac = new char[1];
				ac[0] = (char) this.operations.getData();
				this.fixedString = new String(ac);
			}
			this.fixedStringOptions = this.options;
			this.fixedStringTable = new BMPattern(this.fixedString, 256, isSet(
					this.fixedStringOptions, IGNORE_CASE));
		} else if (!isSet(this.options, PROHIBIT_FIXED_STRING_OPTIMIZATION)
				&& !isSet(this.options, XMLSCHEMA_MODE)) {
			Token.FixedStringContainer container = new Token.FixedStringContainer();
			this.tokentree.findFixedString(container, this.options);
			this.fixedString = container.token == null ? null : container.token
					.getString();
			this.fixedStringOptions = container.options;
			if (this.fixedString != null && this.fixedString.length() < 2)
				this.fixedString = null;
			// This pattern has a fixed string of which length is more than one.
			if (this.fixedString != null) {
				this.fixedStringTable = new BMPattern(this.fixedString, 256,
						isSet(this.fixedStringOptions, IGNORE_CASE));
				if (DEBUG) {
					System.err
							.println("DEBUG: The longest fixed string: "
									+ this.fixedString.length()
									+ "/" // +this.fixedString
									+ "/"
									+ REUtil.createOptionString(this.fixedStringOptions));
					System.err.print("String: ");
					REUtil.dumpString(this.fixedString);
				}
			}
		}
	}
728618
public function perform()
    {
        /** @var CommandDeclaration $declaration */
        $declaration = $this->createDeclaration(compact('alias'));

        $declaration->setAlias($this->argument('alias') ?? $this->argument('name'));
        $declaration->setDescription((string)$this->option('description'));

        $this->writeDeclaration($declaration);
    }
172791
def build_operation_chain(stack)
      empty_op = EmptyOperation.new(nil)

      stack.reverse.reduce(empty_op) do |next_op, current_op|
        klass, args, block = current_op

        if Class === klass
          klass.new(next_op, *args, &block)
        elsif Proc === klass
          lambda do |env|
            next_op.call(klass.call(env, *args))
          end
        else
          raise StandardError, "Invalid operation, doesn't respond to `call`: #{klass.inspect}"
        end
      end
    end
1013943
protected function onInit()
    {
        $this->filePath = Utility::get($this->params, "filePath");
        $this->fieldSeparator = Utility::get($this->params, "fieldSeparator", ",");
        $this->charset = Utility::get($this->params, "charset");
        $this->precision = Utility::get($this->params, "precision", 100);
        $this->firstRowData = Utility::get($this->params, "firstRowData", false);
    }
440409
private void doProcessNext()
	{
		int _position = getPosition();
		Node _current = getSource().item(_position);

		if (getActionPool().containsKey(_current.getNodeName()))
		{
			getActionPool().get(_current.getNodeName()).execute(_current, _position);
		}
		else if (getActionPool().containsKey(NODE_NAME__DEFAULT))
		{
			getActionPool().get(NODE_NAME__DEFAULT).execute(_current, _position);
		}
		// else do nothing...

		// done
		_position++;
		setPosition(_position);
	}
795874
def and_call_through
      if @base_object.is_a? Class
        @plan = Proc.new do |object, *args, &block|
          if original_method
            if original_method.is_a? UnboundMethod
              bound_method = original_method.bind(object)
              bound_method.call(*args, &block)
            else
              original_method.call(*args, &block)
            end
          else
            base_object.send(:method_missing, method_name, *args, &block)
          end
        end
      else
        @plan = Proc.new do |*args, &block|
          if original_method
            original_method.call(*args, &block)
          else
            base_object.send(:method_missing, method_name, *args, &block)
          end
        end
      end

      self
    end
477316
def on(method, *args, &block)

      if [:initialize, :before, :setup, :after].include? method
        raise "#{method} should not be called directly"
      end

      buffer  = [] # Container for the response buffer  
      threads = [] # Container for the execution threads

  		@registry.each do |s|
        if s.respond_to?(method.to_sym, false)
          threads << Thread.new do 
            responder = DispatchResponder.new(s)
          
            responder.trap(@timeout) do 
              if s.method(method.to_sym).arity == 0
                s.send(method, &block)
              else
                s.send(method, *args, &block)
              end
            end

            responder.finalize

            buffer << responder.to_h
          end
  			end
  		end

      threads.map(&:join)

      buffer
  	end
487760
protected function initializeCallQueues()
    {
        $this->inputs = new \Slab\Sequencer\CallQueue();
        $this->operations = new \Slab\Sequencer\CallQueue();
        $this->outputs = new \Slab\Sequencer\CallQueue();
    }
1075060
def step(self):
        """"""
        op = self.code[self.instruction_pointer]
        self.instruction_pointer += 1
        op(self)
540589
def call(args = [])
      object, meth = @when_called[0, 2]
      meth ||= :call
      options = proxy_option_struct

      case object
      when Proc then object.call(args, options)
      when Class then meth != :call ? object.new.send(meth, args, options) : object.new(args, options)
      else object.send(meth, args, options) if object
      end
    end