Converts from an array of user.branch.firstName=>abc, to standard objects
{
user:{
branch:{
firstName:abc
}
}
}

@param string[] $input

@return \stdClass
@throws Exception
770850
public function convert(array $input) {
        //Convert to objects
        if (isSet($input['XDEBUG_SESSION_START'])) unset($input['XDEBUG_SESSION_START']);
        $returnVar = new \stdClass();
        foreach($input as $name => $value) {
            $parts = explode($this->getDelimiter(), $name);
            $currentPart = $returnVar;
            $count = sizeOf($parts);
            foreach($parts as $key => $part) {
                //Ignore all that have a blank part
                if($part == '') {
                    break;
                }
                if($key + 1 == $count) {
                    $currentPart->{$part} = $value;
                } else {
                    $part = ucfirst($part);
                    if(!isset($currentPart->{$part})) {
                        $item = new \stdClass();
                        $currentPart->{$part} = $item;
                    } else {
                        //Account for the url of ?employeeType&employeeType.name=1099 with employeeType and employeeType.name
                        if(!is_object($currentPart->{$part})) {
                            throw new Exception('You cannot pass in both ' . $part . ', and ' . implode('.', $parts), 400);
                        }
                    }
                    $currentPart = $currentPart->{$part};
                }
            }
        }
        return $returnVar;
    }
1283187
public static function toArray($input = false) {

        if ($input) {

            switch (Data::type($input)) {
                case 'array':
                    $array = $input;
                    break;
                case 'object':
                    $array = self::arrayToObject($input);
                    break;
            }

            if (Validate::isObject($input)) {

                return $input;
            }
        }

        return false;
    }
1189501
public function clean($input)
	{
		// Nothing to escape for non-string scalars, or for already processed values
		if (is_bool($input) or is_int($input) or is_float($input) or $this->parent->isCleaned($input))
		{
			return $input;
		}

		if (is_string($input))
		{
			$input = $this->cleanString($input);
		}

		elseif (is_array($input) or ($input instanceof \Iterator and $input instanceof \ArrayAccess))
		{
			$input = $this->cleanArray($input);
		}

		elseif ($input instanceof \Iterator or get_class($input) == 'stdClass')
		{
			$input = $this->cleanObject($input);
		}

		elseif (is_object($input))
		{
			// Check if the object is whitelisted and just return when that's the case
			foreach ($this->parent->getConfig('whitelistedClasses', array()) as $class)
			{
				if (is_a($input, $class))
				{
					return $input;
				}
			}

			// Throw exception when it wasn't whitelisted and can't be converted to String
			if (! method_exists($input, '__toString'))
			{
				throw new \RuntimeException('Object class "'.get_class($input).'" could not be converted to string or '.
					                            'sanitized as ArrayAccess. Whitelist it in security.whitelisted_classes in [application]/config/security.php '.
					                            'to allow it to be passed unchecked.');
			}

			$input = $this->cleanString(strval($input));
		}

		// mark this variable as cleaned
		$this->parent->isClean($input);

		return $input;
	}
1068427
private function parseContext($name, array $input, $default = [])
    {
        if (isset($input[$name])) {
            if (!is_array($input[$name])) {
                throw new Exception(sprintf("'%s' must be an instance of '%s'.", $name, 'array'));
            }

            foreach ($input[$name] as $key => &$value) {
                if (is_int($key)) {
                    // Remove the data if it has no property name.
                    // If you try to pass a non-associative array as context, this will wipe that data.
                    unset($input[$name][$key]);
                    continue;
                }

                if (null === $value || is_bool($value)) {
                    $value = var_export($value, true);
                }

                // jsonify arrays and serializable classes
                if (is_array($value) || $value instanceof JsonSerializable) {
                    $value = json_encode($value, JSON_PRETTY_PRINT);
                }

                // stringify scalars and stringable classes
                if (is_scalar($value) || (is_object($value) && is_callable([$value, '__toString']))) {
                    $value = (string) $value;

                } elseif (is_object($value)) {
                    $value = sprintf('[object] %s', get_class($value));
                }

                if (is_resource($value)) {
                    $value = '[resource]';
                }
            }

            return $input[$name];
        }

        return $default;
    }
376812
public static function getCreateOperation($input, $fields) {
		$operation = new CreateTransactionOperation(static::getClass(), $input, $fields);
		$operation->setSQLAdapter(static::getSQLAdapter());
		return $operation;
	}
376742
public function input($filename, $input)
    {
        if (substr($filename, strlen($this->_settings['ext']) * -1) !== $this->_settings['ext']) {
            return $input;
        }
        if (!class_exists('lessc')) {
            throw new \Exception('Cannot not load "lessc" class. Make sure it is installed.');
        }
        $lc = new lessc($filename);
        return $lc->parse();
    }
131105
protected function convertArrayToSnakeCase(array $input):array
    {
        $converted = [];

        foreach ($input as $key => $value) {
            $converted[snake_case($key)] = $value;
        }

        return $converted;
    }
36453
public static function fromProtobuf($input, $object = NULL, &$start = 0, $end = NULL)
	{
		if ($object === null) {
			$object = new ClassWithNoProperty();
		}

		if ($end === null) {
			$end = strlen($input);
		}

		while ($start < $end) {
			$tag = Binary::decodeVarint($input, $start);
			$wireType = $tag & 0x7;
			$number = $tag >> 3;
			switch ($number) {
				default:
					switch ($wireType) {
						case 0:
							Binary::decodeVarint($input, $start);
							break;
						case 1:
							$start += 8;
							break;
						case 2:
							$start += Binary::decodeVarint($input, $start);
							break;
						case 5:
							$start += 4;
							break;
						default:
							throw new ProtobufException('Unexpected wire type ' . $wireType . '.', $number);
					}
			}
		}

		return $object;
	}
621615
public static function jsonDecode($input)
    {
        $obj = json_decode($input);
        if (function_exists('json_last_error') && $errno = json_last_error()) {
            JWT::_handleJsonError($errno);
        } else if ($obj === null && $input !== 'null') {
            throw new \DomainException('Null result with non-null input');
        }
        return $obj;
    }
972810
public function import($data)
    {
        if (isset($data['OXUSERNAME'])) {
            $id = $data['OXID'];
            $userName = $data['OXUSERNAME'];

            $user = oxNew(\OxidEsales\Eshop\Application\Model\User::class, "core");
            $user->oxuser__oxusername = new \OxidEsales\Eshop\Core\Field($userName, \OxidEsales\Eshop\Core\Field::T_RAW);

            if ($user->exists($id) && $id != $user->getId()) {
                throw new Exception("USER $userName already exists!");
            }
        }

        return parent::import($data);
    }
379392
public function import($input)
    {
        if (is_array($input)) {
            $this->fromArray($input);
        }
        else {
            $this->fromString($input);
        }

        return $this;
    }
67812
public static function toMap($input)
    {
        Arguments::define(Boa::map())->check($input);

        if ($input instanceof MapInterface) {
            return $input;
        }

        if (is_array($input) || $input instanceof ArrayObject) {
            return new ArrayMap($input);
        }

        if ($input instanceof ArrayAccess) {
            return new ArrayAccessMap($input);
        }

        throw new CoreException('Unable to build Map');
    }
204062
public function convert($input)
    {
        if (is_string($input) === false) {
            throw new \InvalidArgumentException('Expected a string value at Parsedown converter.');
        }

        $converter = new \ParsedownExtra();

        return $converter->text($input);
    }
1127834
protected function parseInput($input, array $options = array())
    {
        if ($this->dynamicSettingParser->isDynamicSetting($input)) {
            $parsedSettings = $this->dynamicSettingParser->parseDynamicSetting($input);
            $input = $this->configResolver->getParameter(
                $parsedSettings['param'],
                $parsedSettings['namespace'],
                $parsedSettings['scope']
            );

            if (is_array($input)) {
                $collection = $this->createAssetCollection(array(), $options);
                foreach ($input as $file) {
                    $collection->add(parent::parseInput($file, $options));
                }

                return $collection;
            }
        }

        return parent::parseInput($input, $options);
    }
1292171
public function prepare($input)
    {
        $form = $this->buildNestedForm($this->column, $this->builder);

        return $form->setOriginal($this->original, $this->getKeyName())->prepare($input);
    }
916428
public static function getConfiguration(string $input) {
    list($oldrev, $newrev, $refname) = explode(' ', $input);
    list(,, $branch) = explode('/', $refname);
    return new ParserVariableConfiguration($oldrev, $newrev, $refname, $branch);
  }
103057
public static function fromProtobuf($input, $object = NULL, &$start = 0, $end = NULL)
	{
		if ($object === null) {
			$object = new ServiceDescriptorProto();
		}

		if ($end === null) {
			$end = strlen($input);
		}

		while ($start < $end) {
			$tag = Binary::decodeVarint($input, $start);
			$wireType = $tag & 0x7;
			$number = $tag >> 3;
			switch ($number) {
				case 1:
					if ($wireType !== 2) {
						throw new ProtobufException('Unexpected wire type ' . $wireType . ', expected 2.', $number);
					}
					$length = Binary::decodeVarint($input, $start);
					$expectedStart = $start + $length;
					if ($expectedStart > $end) {
						throw new ProtobufException('Not enough data.');
					}
					$object->name = substr($input, $start, $length);
					$start += $length;
					if ($start !== $expectedStart) {
						throw new ProtobufException('Unexpected start. Expected ' . $expectedStart . ', got ' . $start . '.', $number);
					}
					break;
				case 2:
					if ($wireType !== 2) {
						throw new ProtobufException('Unexpected wire type ' . $wireType . ', expected 2.', $number);
					}
					if (!(isset($object->method) && is_array($object->method))) {
						$object->method = array();
					}
					$length = Binary::decodeVarint($input, $start);
					$expectedStart = $start + $length;
					if ($expectedStart > $end) {
						throw new ProtobufException('Not enough data.');
					}
					$object->method[] = MethodDescriptorProtoMeta::fromProtobuf($input, null, $start, $start + $length);
					if ($start !== $expectedStart) {
						throw new ProtobufException('Unexpected start. Expected ' . $expectedStart . ', got ' . $start . '.', $number);
					}
					break;
				case 3:
					if ($wireType !== 2) {
						throw new ProtobufException('Unexpected wire type ' . $wireType . ', expected 2.', $number);
					}
					$length = Binary::decodeVarint($input, $start);
					$expectedStart = $start + $length;
					if ($expectedStart > $end) {
						throw new ProtobufException('Not enough data.');
					}
					$object->options = ServiceOptionsMeta::fromProtobuf($input, null, $start, $start + $length);
					if ($start !== $expectedStart) {
						throw new ProtobufException('Unexpected start. Expected ' . $expectedStart . ', got ' . $start . '.', $number);
					}
					break;
				default:
					switch ($wireType) {
						case 0:
							Binary::decodeVarint($input, $start);
							break;
						case 1:
							$start += 8;
							break;
						case 2:
							$start += Binary::decodeVarint($input, $start);
							break;
						case 5:
							$start += 4;
							break;
						default:
							throw new ProtobufException('Unexpected wire type ' . $wireType . '.', $number);
					}
			}
		}

		return $object;
	}