Gets the implementation class name of a registered custom numeric DQL function.

@param string $name

@return string|null
432477
public function getCustomNumericFunction($name)
    {
        $name = strtolower($name);

        return isset($this->_attributes['customNumericFunctions'][$name])
            ? $this->_attributes['customNumericFunctions'][$name]
            : null;
    }
1094287
public function getParameterTemplate($name)
    {
        if ($this->hasParametersTemplates()) {
            foreach ($this->getParametersTemplates() as $parameterTemplate) {
                if ($parameterTemplate->name === $name) {
                    return $parameterTemplate;
                }
            }
        }
        return null;
    }
1010966
public function getProperty($name) {
    $name = ltrim($name, '$');

    $properties = $this
      ->getProperties()
      ->filter(function (ClassMemberNode $property) use ($name) {
        return ltrim($property->getName(), '$') === $name;
      });
    return $properties->isEmpty() ? NULL : $properties[0];
  }
357076
protected static function getAlgorithm($name)
    {
        if (!isset(self::$algorithms[$name])) {
            self::$algorithms[$name] = new $name();
        }

        return self::$algorithms[$name];
    }
932549
public static function getModelClass($name)
    {
        // If the name contains a backslash it is already fully qualified. However in some cases
        // a model might be replaced by a new class and so we must first look to see if this model is
        // mapped and if so return it's replacement instead.
        if (stripos($name, "\\") !== false) {
            $newName = self::getModelNameFromClass($name);

            if ($newName === null) {
                // $name hasn't been registered as a model object. Play safe and return the
                // same class name passed to us.
                return '\\' . ltrim($name, '\\');
            }

            $name = $newName;
        }

        if (self::$modelClassesCache == null) {
            self::$modelClassesCache = [];

            $schemas = self::getAllSchemas();

            self::$modelNamesCache = [];

            foreach ($schemas as $schema) {
                self::$modelClassesCache = array_merge(self::$modelClassesCache, $schema->models);
                self::$modelNamesCache = array_merge(self::$modelNamesCache, $schema->modelClassNames);
            }
        }

        if (isset(self::$modelClassesCache[$name])) {
            return '\\' . ltrim(self::$modelClassesCache[$name], '\\');
        }

        return null;
    }
480720
public function getRepository($name = null)
    {
        $doctrine = $this->getDoctrine();

        if ($name) {
            return $doctrine->getRepository($name);
        }

        return $doctrine->getRepository($this->getClass());
    }
1060396
protected function findPaymentMethodMapperByName($name)
    {
        if (array_key_exists($name, $this->registeredMethodMappers)) {
            return $this->registeredMethodMappers[$name];
        }

        return null;
    }
434974
public function getMethod($name) {
    $methods = $this
      ->getMethods()
      ->filter(function (InterfaceMethodNode $method) use ($name) {
        return $method->getName()->getText() === $name;
      });
    return $methods->isEmpty() ? NULL : $methods[0];
  }
694857
function &classNamed($name)
    {
        $class = NULL;
        $pos = strrpos($name, '\\');
        if ($pos != FALSE) {
            $package = substr($name, 0, $pos);
            $name = substr($name, $pos + 1);
        }
        if (isset($package)) {
            if (isset($this->_packages[$package])) {
                $class =& $this->_packages[$package]->findClass($name);
            }
        } else {
            $packages = $this->_packages; // we do this copy so as not to upset the internal pointer of the array outside this scope
            foreach ($packages as $packageName => $package) {
                $class =& $package->findClass($name);
                if ($class != NULL) break;
            }
        }

        return $class;
    }
1255297
protected function getPropertyClassName($name)
    {
        $name = ucfirst($name);
        if (!$this->php7ClassNames) {
            return $name;
        }

        if (substr($name, -8) == 'Property') {
            return $name;
        }

        return $name.'Property';
    }
720889
public static function lookupName($name) {
        // Do we really want to return NULL here? or FFFD
        return isset(HTML5_Entities::$byName[$name]) ? HTML5_Entities::$byName[$name] : null;
    }
1133824
public function getType($name)
    {
        $map = $this->getTypeMap();
        return isset($map[$name]) ? $map[$name] : NULL;
    }
814496
public function getParameter($name)
    {
        $name = (string)$name;
        return array_key_exists($name, $this->_params) ? $this->_params[$name] : null;
    }
845428
protected function getValidClass($type, $name)
    {
        $logging = \Plop\Plop::getInstance();;
        $w = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_1234567890\\';
        if (!is_string($name) || strspn($name, $w) !== strlen($name)) {
            $logging->debug(
                'Skipping %(type)s algorithm "%(name)s" (invalid class name)',
                array('type' => $type, 'name' => $name)
            );
            return null;
        }

        // Non-existing classes.
        $class = "\\fpoirotte\\Pssht\\$type$name";
        if (!class_exists($class)) {
            if (!interface_exists($class)) {
                $logging->debug(
                    'Skipping %(type)s algorithm "%(name)s" (class does not exist)',
                    array('type' => $type, 'name' => $name)
                );
            }
            return null;
        }

        // Abstract classes.
        $reflector = new \ReflectionClass($class);
        if ($reflector->isAbstract()) {
            return null;
        }

        // Classes that implement AvailabilityInterface
        // where the algorithm is not currently available.
        $iface = '\\fpoirotte\\Pssht\\AvailabilityInterface';
        if ($reflector->implementsInterface($iface) && !$class::isAvailable()) {
            $logging->debug(
                'Skipping %(type)s algorithm "%(name)s" (not available)',
                array('type' => $type, 'name' => $name)
            );
            return null;
        }

        // Classes that do not implement the proper interface.
        $iface = $this->interfaces[$type];
        if ($iface !== null && !$reflector->implementsInterface($iface)) {
            $logging->debug(
                'Skipping %(type)s algorithm "%(name)s" (invalid interface)',
                array('type' => $type, 'name' => $name)
            );
            return null;
        }

        return $class;
    }
231263
public function find($name)
    {
        return $this->first(function ($action) use ($name) {
            return class_basename($action) === studly_case($name);
        });
    }
880120
public function getQueryParameter($name)
    {
        return isset($this->query[$name]) ? $this->query[$name] : null;
    }
672933
public function getClassName($name)
    {
        if (!isset($this->mapping[$name])) {
            throw new \InvalidArgumentException(sprintf('Could not find "%s"', $name));
        }

        return $this->mapping[$name];
    }