@param mixed $emptyValue

@return mixed
187625
private static function askRequiredValue(StyleInterface $io, ContextElement $element, $emptyValue)
    {
        if (null === $emptyValue) {
            return $element->askString($io);
        }

        if (false === $emptyValue) {
            return $element->askBool($io);
        }

        if ([] === $emptyValue) {
            return $element->askIterable($io);
        }

        return $emptyValue;
    }
109199
private static function getValueFromSymbol($stringValue): Suit
    {
        $values = array_values(static::$symbols);
        $key = array_search($stringValue, $values, true);

        return static::makeSuit($key + 100);
    }
880935
public function getHeaderValue($name, $defaultValue = null)
    {
        $header = $this->getHeader($name);
        if ($header !== null) {
            return $header->getValue();
        }
        return $defaultValue;
    }
1276692
protected function getTypedValue ($rawValue) {
		if (gettype($rawValue) == "array") {
			foreach ($rawValue as $key => $value) {
				$rawValue[$key] = $this->getTypedValue($value);
			}
			return $rawValue; // array
		} else if (mb_strlen($rawValue) > 0) {
			if (is_numeric($rawValue)) {
				return $this->getTypedValueFloatOrInt($rawValue);
			} else {
				return $this->getTypedSpecialValueOrString($rawValue);
			}
		} else {
			return $this->getTypedSpecialValueOrString($rawValue);
		}
	}
238744
public function create($initialValue = 0)
    {
        $initialValue = (int) $initialValue;

        $this->db->insert($this->table, array('name' => $this->name, 'value' => $initialValue));

        return $initialValue;
    }
1033872
public function get($key, $defaultValue = array())
    {
        $this->populateFlash($key);

        if ($this->has($key)) {
            return $this->data[$key];
        }

        return $defaultValue;
    }
555210
public function optionalItem($key, $defaultValue = null)
    {
        if (!$this->hasItem($key)) {
            return $defaultValue;
        }

        return $this->getItem($key);
    }
789407
public function get($key, $defaultValue = null)
    {
        if (!isset($this->keyToIndexMap[$key]) && 2 === func_num_args()) {
            return $defaultValue;
        }

        return $this->value($key);
    }
21652
public function get($key, $defaultValue = null)
    {
        $keyExists = true;
        $parts     = $this->getPath($key);
        $node      = $this->getFromCache();

        foreach($parts as $part) {
            $part = trim($part);

            if (!is_array($node) || !array_key_exists($part, $node)) {
                $keyExists = false;
                break;
            }

            $node = &$node[$part];
        }

        if ($keyExists) {
            return $node;
        } else {
            return $defaultValue;
        }
    }
756241
public function getTaxonomyRequirement($taxonomyName, $emptyValue = 'none')
    {
        $this->deprecationWarn(__FUNCTION__, 'singleTaxonomy');

        return $this->singleTaxonomy($taxonomyName, $emptyValue);
    }
1033737
public function &get($property)
    {
        if (!strlen((string)$property)) {
            throw new InvalidArgumentException('Cannot get an empty property');
        }

        $value = null;
        $method = static::_accessor($property, 'get');

        if (isset($this->_properties[$property])) {
            $value =& $this->_properties[$property];
        }

        if ($method) {
            $result = $this->{$method}($value);

            return $result;
        }

        return $value;
    }
1157150
final public static function box($plainValue): self
    {
        foreach (static::valueNames() as $name) {
            if (self::constant($name) === $plainValue) {
                return self::__callStatic($name, []);
            }
        }

        $message = sprintf('Value %s is not within %s enumeration.', $plainValue, static::class);
        throw new InvalidArgumentException($message);
    }
94124
final public function formatYesNo($nullConvertValue = null)
    {
        $convertedValue = is_null($this->value) ? $nullConvertValue : $this->value;
        if(is_null($convertedValue)) {
            return null;
        } else {
            return $convertedValue ? 'Yes' : 'No';
        }
    }
172765
protected function getParam($param = null, $defaultValue = null)
    {
        $request = $this->getRequest();
        if ($param === null) {
            return array_merge($request->getQuery(), $request->getParams());
        }

        $value = $request->getParam($param);
        if ($value === null) {
            return $request->getQuery($param, $defaultValue);
        }

        return $value;
    }
453774
public function getGet($name = null, $defaultValue = null) 
    {
        if ($name === null) {
            return $_GET;
        }
        return (isset($_GET[$name])) ? $_GET[$name] : $defaultValue;
    }
1083448
public function getValue()
    {
        $values = array();
        foreach ($this as $child) {
            $value = $child->getValue();
            if (null !== $value) {
                if ($child instanceof HTML_QuickForm2_Container
                    && !$child->prependsName()
                ) {
                    $values = self::arrayMerge($values, $value);
                } else {
                    $name = $child->getName();
                    if (!strpos($name, '[')) {
                        $values[$name] = $value;
                    } else {
                        $tokens   =  explode('[', str_replace(']', '', $name));
                        $valueAry =& $values;
                        do {
                            $token = array_shift($tokens);
                            if (!isset($valueAry[$token])) {
                                $valueAry[$token] = array();
                            }
                            $valueAry =& $valueAry[$token];
                        } while (count($tokens) > 1);
                        $valueAry[$tokens[0]] = $value;
                    }
                }
            }
        }
        return empty($values)? null: $this->applyFilters($values);
    }
1337446
public static function values($withEmpty = false) {
        static $list = [];

        $className = static::class;
        if (!isset($list[$className])) {
            $list[$className] = [];
            foreach (static::constants() as $value => $code) {
                $value = Inflector::humanize(strtolower($value), true);
                $list[$className][$code] = static::t($value);
            }
        }

        return ($withEmpty ? ['' => static::emptyValue()] : [])
            + $list[$className];
    }