Get attribute value

@param array $params
@param bool  $processCallbacks Process `onGet` callbacks

@return $this
434015
public function getValue($params = [], $processCallbacks = true)
    {
        foreach ($this->defaultParams as $i => $defaultValue) {
            if (!isset($params[$i])) {
                $params[$i] = $defaultValue;
            }
        }

        // In case the value of this dynamic attribute is stored to DB, we pass the stored value as the last parameter to the function
        $params[] = $this->storedValue;
        $value = call_user_func_array($this->callable, $params);

        return $this->processGetValue($value, [], $processCallbacks);
    }
1017063
public function set($callback, $args = [])
    {
        if ($this->postTrigger) {
            if (isset($_POST[$this->postTrigger])) {
                $this->app->catch_runaway_callbacks = false;
                $this->triggered = $_POST[$this->postTrigger];

                $t = $this->app->run_called;
                $this->app->run_called = true;
                $ret = call_user_func_array($callback, $args);
                $this->app->run_called = $t;

                return $ret;
            }
        } else {
            if (isset($_GET[$this->urlTrigger])) {
                $this->app->catch_runaway_callbacks = false;
                $this->triggered = $_GET[$this->urlTrigger];

                $t = $this->app->run_called;
                $this->app->run_called = true;
                $this->owner->stickyGet($this->urlTrigger);
                $ret = call_user_func_array($callback, $args);
                //$this->app->stickyForget($this->name);
                $this->app->run_called = $t;

                return $ret;
            }
        }
    }
1331497
function(params) {

                            var that = this;
                            var paramsDefinition = this.getParamsDefinition();
                            var parameterProcessor = this.getParameterProcessor();

                            _.each(params, function(value, param) {
                                if (!(param in paramsDefinition)) {
                                    throw new Error('Parameter "' + param + '" does not defined!');
                                }
                                params[param] = parameterProcessor.process(value, paramsDefinition[param], param, that);
                            });

                            return params;
                        }
75743
public function ajax( $params ) {

		if ( ! isset( $params->step ) ) {
			return pods_error( __( 'Invalid upgrade process.', 'pods' ) );
		}

		if ( ! isset( $params->type ) ) {
			return pods_error( __( 'Invalid upgrade method.', 'pods' ) );
		}

		if ( ! method_exists( $this, $params->step . '_' . $params->type ) ) {
			return pods_error( __( 'Upgrade method not found.', 'pods' ) );
		}

		return call_user_func( array( $this, $params->step . '_' . $params->type ), $params );
	}
873915
public function get(string $property, $callback = false)
    {
        if (isset($this->processed[$property])) {
            if ($callback) {
                return \call_user_func($callback, $this->processed[$property]);
            }

            return $this->processed[$property];
        }

        return false;
    }
731015
static function executeCallback($callback, array $params = array()) {
    // If callback has @
    if (is_string($callback) && strpos($callback, '@') !== false) {
      // Split
      $arrCallback = explode('@', $callback);
      // Set object
      $object = class_exists($arrCallback[0]) ? (new $arrCallback[0]()) : null;
      // Set method
      $method = isset($arrCallback[0]) ? $arrCallback[0] : null;
      // Set callback
      $callback = array($object, $method);
    }
    // If not callable
    if ( ! is_callable($callback)) {
      // Throw error
      throw new InvalidCallback('Callback must be callable');
    }
    // Execute and return
    return call_user_func_array($callback, $params);
  }
992642
public function callback(array $params = null)
	{
		$this->cleanup();

		if(null === $params){
			if(!empty($_POST)){
				$params = $_POST;
			}
		}

		if (
			empty($params) ||
			empty($params['term']) ||
			empty($params['sign']) ||
			empty($params['type'])
		) {
			throw new GatewayException('Input params is failure');
		}

		$type = $params['type'];

		if(!isset(self::$customParams[$type])){
			throw new GatewayException('Undefined type value');
		}

		$sign = $this->sign($type, $params);

		if($sign !== $params['sign']){
			throw new GatewayException('Signature check fail');
		}

		$this->rawResponse = http_build_url($params);

		/** @var stdClass response */
		$this->response = (object)$params;

		if ($this->response->rc !== '00') {
			$this->error = array(
				'type'    => self::C_ERROR_PROCESSING,
				'message' => $this->response->message,
			);
		}

		return empty($this->error);

	}
1061919
protected function gatherOutput(array $processes, Closure $callback)
    {
        foreach ($processes as $host => $process) {
            $methods = [
                Process::OUT => 'getIncrementalOutput',
                Process::ERR => 'getIncrementalErrorOutput',
            ];

            foreach ($methods as $type => $method) {
                $output = $process->{$method}();

                if (! empty($output)) {
                    $callback($type, $host, $output);
                }
            }
        }
    }
647503
public CallbackResult<V> processCallbacks(Chunk chunk, Object... params)
	{
		//true = cancel => return
		Set<BlockPos> coords = ChunkBlockHandler.get().chunks(chunk).get(chunk);
		return processListeners(coords, chunk, params);
	}
440805
public function getValue($params = [], $processCallbacks = true)
    {
        if ($this->isNull($this->value) && !$this->isNull($this->defaultValue)) {
            $this->value = $this->getDefaultValue();
        }

        return $this->processGetValue($this->value, $params, $processCallbacks);
    }
76262
protected function createStringCallback($callback, array $parameters)
    {
        if (function_exists($callback)) {
            return $this->createCallableCallback($callback, $parameters);
        } else {
            return $this->createClassesCallback($callback, $parameters);
        }
    }
1295386
public function resolveCallback(Closure $callback, $params = [])
    {
        $reflectionParameter = new ReflectionFunction($callback);

        $dependencies = $reflectionParameter->getParameters();

        return $this->getDependencies($dependencies, $params);
    }
684965
protected function renderAttr($attributes = false, $params = false)
    {
        $attrStr = '';

        if (isset($attributes['callback'])) {
            $callbackParams = [$this];

            if ($params !== false) {
                array_push($callbackParams, $params);
            }

            call_user_func_array($attributes['callback'], $callbackParams);
        }

        if (is_array($attributes)) {
            foreach ($attributes as $attr => $value) {
                if (is_string($value)) {
                    $attrStr .= ' '.$attr.'="'.$value.'"';
                }
            }
        }

        return $attrStr;
    }
1017936
protected function processArgs(array $args) {
		foreach ($args as &$arg) {
			if (is_array($arg)) {
				$arg = $this->processArgs($arg);
				continue;
			}
			
			if ($arg instanceof Argument\ArgumentInterface) {
				$arg = $arg->getValue();
			}
		}
		unset($arg);
		
		return $args;
	}
123205
function(params, headers, callback) {
        var url;
        url = this.client.url(false);
        return this.client.get(url, params, headers, callback);
      }
988201
public static function queryString($params, $parent = null, $callback = 'rawurlencode', $ignoreNonValues = true)
    {
        $params = self::flattenRequestVars($params, $parent);
        $ret = [];
        foreach ($params as $pair) {
            list($name, $value) = $pair;
            if (!$value && $ignoreNonValues) {
                continue;
            }
            if ($callback) {
                $value = call_user_func($callback, $value);
            }
            $ret[] = sprintf('%s=%s', $name, $value);
        }
        return implode('&', $ret);
    }
511136
public function get(array $params) {
        $this->_requireDataType($params);

        if (array_get($params, 'datatype') === self::METHOD_DICTIONARY) {
            return $this->getDictionary();
        } elseif (array_get($params, 'relatedType') && array_get($params, 'id')) {
            list($response, $httpCode) = $this->_getRelatedResults($params);
        } elseif (array_get($params, 'id')) {
            list($response, $httpCode) = $this->_getSingleResult($params);
        } else {
            list($response, $httpCode) = $this->_getIndex($params);
        }

        return $this->_formatResponse($response, $httpCode);
    }