Returns the object pointed by the result-type parameter "parameters"
@param _invocation
@return
165846
protected Map getParametersMap(ActionInvocation _invocation) {
    	Map map = (Map) _invocation.getStack().findValue(this.parameters);
    	if (map == null)
    		map = new HashMap();
		return map;
	}
1163747
public Invocation getInvocation(final RpcRequest request, InterfaceDescriptor<?> descriptor) {
		if (request == null) throw new NullPointerException("request");
		if (descriptor == null) throw new NullPointerException("descriptor");

		Invocation invocation = null;
		LinkedList<String> parts = splitPath(request.getRelativePath());

		while (!parts.isEmpty()) {
			String part = parts.removeFirst();

			// Find a method by a name.
			MethodDescriptor<?, ?> method = descriptor.getMethod(part);
			if (method == null) {
				throw RpcException.badRequest("Method is not found: " + part);
			}

			// Check the required HTTP method.
			if (method.isPost() && !request.isPost()) {
				throw RpcException.methodNotAllowed("Method not allowed, POST required");
			}

			// Parse arguments.
			List<Object> args = readArgs(method, parts, request.getQuery(), request.getPost());

			// Create a root invocation,
			// or a next invocation in a chain.
			invocation = invocation != null ? invocation.next(method, args.toArray())
			                                : Invocation.root(method, args.toArray());
			if (method.isTerminal()) {
				break;
			}

			// It's an interface method.
			// Get the next interface and proceed parsing the parts.
			descriptor = (InterfaceDescriptor<?>) method.getResult();
		}

		if (!parts.isEmpty()) {
			// No more interface descriptors in a chain, but the parts are still present.
			throw RpcException.badRequest("Failed to parse an invocation chain");
		}

		if (invocation == null) {
			throw RpcException.badRequest("Invocation chain required");
		}

		if (!invocation.getMethod().isTerminal()) {
			throw RpcException.badRequest("The last method must be a terminal one. "
					+ "It must return a data type or be void.");
		}

		return invocation;
	}
1081929
private List<InvocationMessage> makePayloadInvocations() {
    final MessageFactory f = MessageFactoryHolder.FACTORY;

    final List<InvocationMessage> invocationMessages = new ArrayList<>();
    for (final AbstractRequest<?, ?> invocation : this.state.invocations) {
      // RequestData is produced by the generated subclass
      final RequestData data = invocation.getRequestData();
      final InvocationMessage message = f.invocation().as();

      // Operation; essentially a method descriptor
      message.setOperation(data.getOperation());

      // The arguments to the with() calls
      final Set<String> refsToSend = data.getPropertyRefs();
      if (!refsToSend.isEmpty()) {
        message.setPropertyRefs(refsToSend);
      }

      // Parameter values or references
      final List<Splittable> parameters = new ArrayList<>(data.getOrderedParameters().length);
      for (final Object param : data.getOrderedParameters()) {
        parameters.add(EntityCodex.encode(this, param));
      }
      if (!parameters.isEmpty()) {
        message.setParameters(parameters);
      }

      invocationMessages.add(message);
    }
    return invocationMessages;
  }
478584
public static Object invoke(Method m, Object obj, Object[] params)
        throws InvocationTargetException, IllegalAccessException {
        try {
            return bounce.invoke(null, new Object[] {m, obj, params});
        } catch (InvocationTargetException ie) {
            Throwable t = ie.getCause();

            if (t instanceof InvocationTargetException) {
                throw (InvocationTargetException)t;
            } else if (t instanceof IllegalAccessException) {
                throw (IllegalAccessException)t;
            } else if (t instanceof RuntimeException) {
                throw (RuntimeException)t;
            } else if (t instanceof Error) {
                throw (Error)t;
            } else {
                throw new Error("Unexpected invocation error", t);
            }
        } catch (IllegalAccessException iae) {
            // this can't happen
            throw new Error("Unexpected invocation error", iae);
        }
    }
1291183
@Override
    public <T> Parameter<T> getParameter(int arg0, Class<T> arg1)
    {

        return query.getParameter(arg0, arg1);
    }
196150
@Override
    public Object getObject(String parameterName, Map<String,Class<?>> map) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
703281
@Override
  public Object invoke(final ELContext context, final Object base, final Object method,
      Class<?>[] paramTypes, final Object[] params) {
    if ((base == null) || (method == null)) {
      return null;
    }

    final MethodDescriptor[] methodDescriptors = getMethodDescriptors(context, base);

    if (methodDescriptors != null) {
      final Method m =
          findMethodOrThrow(method.toString(), paramTypes, params, false, methodDescriptors);
      paramTypes = m.getParameterTypes();
    }

    return super.invoke(context, base, method, paramTypes, params);
  }
1078215
static int getInvocationArgsCount(Node invocation) {
    if (invocation.isTaggedTemplateLit()) {
      Iterable<Node> args = new TemplateArgsIterable(invocation.getLastChild());
      return Iterables.size(args) + 1;
    } else {
      return invocation.getChildCount() - 1;
    }
  }
30755
public function invoke(MethodInvocation $invocation)
    {
        /** @var \Ytake\LaravelAspect\Annotation\QueryLog $annotation */
        $annotation = $invocation->getMethod()->getAnnotation($this->annotation);
        $this->subscribeQueryLog();
        $result = $invocation->proceed();
        $logFormat = $this->queryLogFormatter($annotation, $invocation);
        $logger = static::$logger;
        if ($logger instanceof LogManager) {
            if (!is_null($annotation->driver)) {
                $logger = $logger->driver($annotation->driver);
            }
            $logger->addRecord($logFormat['level'], $logFormat['message'], $logFormat['context']);
        }
        $this->queryLogs = [];

        return $result;
    }
1362638
public static Object[] call(Method method, Object[][] params,
                              InetSocketAddress[] addrs,
                              UserGroupInformation ticket, Configuration conf)
    throws IOException {

    Invocation[] invocations = new Invocation[params.length];
    for (int i = 0; i < params.length; i++)
      invocations[i] = new Invocation(method, null, params[i]);
    Client client = CLIENTS.getClient(conf);
    try {
    Writable[] wrappedValues =
      client.call(invocations, addrs, method.getDeclaringClass(), ticket);

    if (method.getReturnType() == Void.TYPE) {
      return null;
    }

    Object[] values =
      (Object[])Array.newInstance(method.getReturnType(), wrappedValues.length);
    for (int i = 0; i < values.length; i++)
      if (wrappedValues[i] != null)
        values[i] = ((ObjectWritable)wrappedValues[i]).get();
    
    return values;
    } finally {
      CLIENTS.stopClient(client);
    }
  }
636294
public InvocationHandler getInvocationHandler(Object proxy) {
        Field field = getInvocationHandlerField();
        try {
            return (InvocationHandler) field.get(proxy);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException("Object is not a proxy of correct type", e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
509447
public function invoke(MethodInvocation $invocation)
    {
        $ro = $invocation->proceed();
        if (! $ro instanceof ResourceObject) {
            throw new ReturnValueIsNotResourceObjectException(\get_class($invocation->getThis()));
        }

        if ($ro->code >= Code::BAD_REQUEST) {
            return $this;
        }

        foreach ($this->commands as $command) {
            $command->command($invocation, $ro);
        }

        return $ro;
    }
1334129
def parse_invocation(self, invocation, controller_tag):
        
        if invocation.endswith('/'):
            invocation = invocation[:-1]
        if not invocation.startswith('/'):
            invocation = '/' + invocation
        if invocation == '':
            invocation = '/'

        all_programs = self.get_urls(controllers=[controller_tag])

        matching_paths = set()
        for program_path in sorted(all_programs):
            if invocation.startswith(program_path):
                matching_paths.add(program_path)

        longest = ""
        for path in matching_paths:
            longest = path if len(path) > len(longest) else longest

        matching_path = longest

        program = self.get_program(matching_path, controller=controller_tag)

        if not matching_path:
            raise ProgramNotFound("Can't find %s" % invocation)

        program_name = matching_path.split('/')[-1]
        path = "/".join(matching_path.split('/')[:-1]) + '/'
        args_fragment = invocation[len(matching_path):]

        superformat = None
        if args_fragment.startswith('.'):
            # args_fragment will be something like ".html/arg1/arg2" or just ".html"
            superformat = args_fragment.split('/')[0][1:]
            args = args_fragment.split('/')[1:]
            args_fragment = '/'.join(args)
        else:
            args = args_fragment.split("/")[1:] if args_fragment else []
            args_fragment = args_fragment[1:] if (args_fragment and args_fragment[0] =='/') else args_fragment

        return {
            'program': program,
            'program_name': program_name,
            'superformat': superformat,
            'superformat_mime': super_accept_to_mimetype(superformat),
            'args': args,
            'raw_args': args_fragment,
            'path': path,
            'invocation': invocation,
        }
1298173
def get_method_invocation_code(c, method)
      target = method.singleton ? get_complete_class_name(c) : instance_name(c)
      "#{target}.#{method.name}#{to_params_part(method.params)}#{get_block_code(method)}"
    end
369312
@Override
    public Object invoke(Object[] allVals) throws InvocationTargetException {
        Object[] vals;
        Object tmp;

        vals = new Object[paraParaCount];
        System.arraycopy(allVals, idx, vals, 0, vals.length);
        tmp = para.invoke(vals);

        vals = new Object[baseParaCount];
        System.arraycopy(allVals, 0, vals, 0, idx);
        vals[idx] = tmp;
        System.arraycopy(allVals, idx + paraParaCount, vals, idx + 1, vals.length - (idx + 1));

        return base.invoke(vals);
    }
288965
public static int getNumParametersForInvocation(InvokeInstruction inv, ConstantPoolGen cpg) {
        SignatureParser sigParser = new SignatureParser(inv.getSignature(cpg));
        return sigParser.getNumParameters();
    }
294334
public Invocation getLastInvocation() {
        OngoingStubbingImpl ongoingStubbing = ((OngoingStubbingImpl) mockingProgress().pullOngoingStubbing());
        List<Invocation> allInvocations = ongoingStubbing.getRegisteredInvocations();
        return allInvocations.get(allInvocations.size() - 1);
    }