Gibt den (lcfirst) LowerCase Name für einen Klassennamen zurück

OID => oid
OIDMeta => oidMeta
SomeClassName => someClassName

@param $className ohne Namespace
541461
public function propertyName($className) {
    if (!is_string($className) || mb_strpos($className, '\\') !== FALSE) {
      throw new \InvalidArgumentException(sprintf("ClassName %s kann nicht zu propertyName umgewandelt werden. Er muss ein String sein und darf nur der ClassName sein", \Psc\Code\Code::varInfo($className)));
    }
    
    // 1. Fall: Klasse ist CamelCase. wichtig ist hierbei dass das erste a klein ist
    if (Preg::match($className, '/^[A-Z]{1}[a-z]{1}/') > 0) {
      return lcfirst($className);
    }
    
    // 2. Fall: Klassename ist eine Abkürzung. Z. B. OID (aka: der ganze String sind Großbuchstaben)
    if (Preg::match($className, '/^[A-Z]+$/')) {
      return mb_strtolower($className);
    }
    
    // 3. Fall: KlassenName ist mixed sowas wie OIDMeta
    // teile auf in m[1] = 'OID' m[2] = 'Meta'
    $m = array();
    if (Preg::match($className, '/^([A-Z]+)([A-Z]{1}[a-z]{1}.*)$/', $m) > 0) {
      return mb_strtolower($m[1]).$m[2];
    }
    
    throw new \RuntimeException(sprintf("Kein matching Case für ClassName '%s'", $className));
  }
878948
public function createAliasName(string $className): string
    {
        $alias = lcfirst(preg_replace('~^.*\\\\~', '', $className));
        if (!isset($this->aliasCount[$alias])) {
            $this->aliasCount[$alias] = 1;
        }

        return $alias . $this->aliasCount[$alias]++;
    }
150358
public function classToTableName($className)
    {
        $className = $this->getRelativeClass($className);
        $className = ltrim(strtolower(preg_replace('/[A-Z]/', '_$0', $className)), '_');

        return $this->prefix . $className;
    }
917747
private static function classBelongsToNamespace($className, $namespaces)
    {
        $belongsToNamespace = false;
        $check = array_values($namespaces);
        $lcClassName = strtolower(ltrim($className, '\\'));

        foreach ($check as $namespace) {
            if (false !== strpos($lcClassName, strtolower($namespace))) {
                $belongsToNamespace = true;
                continue;
            }
        }
        return $belongsToNamespace;
    }
928307
protected final function fileName(string $className): string
    {
        $fileName = "";
        if (array_key_exists($className, $this->className)) {
            $fileName = $this->className[$className];
            $this->removeClass($className);
        }
        return $fileName;
    }
722375
public function loadClass($className)
    {
        if (null === $this->namespace
            || $this->namespace.$this->namespaceSeparator === substr(
                $className,
                0,
                strlen($this->namespace.$this->namespaceSeparator)
            )) {
            $fileName = '';
            if (false !== ($lastNsPos = strripos($className, $this->namespaceSeparator))) {
                $namespace = substr($className, 0, $lastNsPos);
                $className = substr($className, $lastNsPos + 1);
                $fileName =
                    str_replace($this->namespaceSeparator, DIRECTORY_SEPARATOR, $namespace) .
                    DIRECTORY_SEPARATOR;
            }
            $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . $this->fileExtension;
            require $this->getFullPath($fileName);
        }
    }
809582
public static function load($className)
    {
        $namespace = __NAMESPACE__ . '\\';
        $length    = strlen($namespace);

        //        if (substr($className, 0, $length) !== $namespace) {
        if (0 !== strpos($className, $namespace)) {
            return;
        }

        // init() must have been called before
        assert(self::$libDir !== null);

        require self::$libDir . substr($className, $length) . self::EXTENSION;
    }
583623
public function resolveClassName($className)
    {
        $className = Inflector::id2camel($className, '_');
        if (isset($this->aliases[$className])) {
            return $this->aliases[$className];
        }
        foreach ($this->namespaces as $namespace) {
            $resolvedClassName = $namespace . '\\' . $className;
            if (class_exists($resolvedClassName)) {
                return $this->aliases[$className] = $resolvedClassName;
            }
        }
        return $className;
    }
566834
protected function removeRootNamespace($classname)
    {
        $namespaces = $this->splitNamespaces($classname);
        if (count($namespaces) > 1) {
            $classname = implode('\\', array_slice($namespaces, 1));
        }

        return $classname;
    }
936421
public function addClass($className)
    {
        if(strlen($className) < 1)
        {
            throw new HTMLTagException("Class name is empty");
        }

        if(!$this->hasClass($className))
        {
            $classes = $this->getClasses() . " " . $this->removeMultipleSpaces(trim($className));
            $this->setAttribute("class",trim($classes));
        }

        return $this;
    }
1113030
public function loadClass($className)
    {
        $found = false;
        $nsSep = $this->namespace.$this->namespaceSeparator;
        if (null === $this->namespace || $nsSep === substr($className, 0, strlen($nsSep))) {
            $fileName = '';
            if (false !== ($lastNsPos = strripos($className, $this->namespaceSeparator))) {
                $namespace = substr($className, 0, $lastNsPos);
                $className = substr($className, $lastNsPos + 1);
                $fileName  = str_replace($this->namespaceSeparator, DIRECTORY_SEPARATOR, $namespace);
                $fileName .= DIRECTORY_SEPARATOR;
            }
            $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . $this->fileExtension;
            $filePath  = stream_resolve_include_path($this->includePath . DIRECTORY_SEPARATOR . $fileName);
            if ($filePath) {
                /** @noinspection PhpIncludeInspection */
                require $filePath;
                $found = true;
            }
        }
        return $found;
    }
702337
public function setClass($classname) {
		$this->class      = trim($classname, '\\');
		$this->reflection = null;
		
		$this->reset();
		
		return $this;
	}
779223
public static function mapClassNameToFileName($className)
    {
        $arr = preg_split('/(?=[A-Z])/', $className);
        unset($arr[0]); // remove the first element ('')
        $fileName = static::getCurrentTimestamp() . '_' . strtolower(implode($arr, '_')) . '.php';

        return $fileName;
    }
1158492
public static function getInstance($className)
    {
        if (!isset(self::$instances[$className])) {
            self::$instances[$className] = new self($className);
        }

        return self::$instances[$className];
    }
1258433
public function classname_to_path( $classname ) {
		// Convert the namespace to a sub-directory path
		if ( strpos( $classname, '\\' ) !== false) {
			$classname = str_replace( '\\', DIRECTORY_SEPARATOR, $classname );
		}

		return $classname;
	}
1137280
public function getClassAliasName($className)
    {
        /*
         * Sanitize input: class names in namespaces should not, but may include a leading backslash
         */
        $className = ltrim($className, '\\');
        $classAlias = array_search($className, $this->classMap);

        if ($classAlias === false) {
            $classAlias = null;
        }

        return $classAlias;
    }
43812
public function getFullName($className)
    {
        $isFunction = $this->currentMethod && $this->currentMethod instanceof FunctionDefinition;
        $namespace = $isFunction ? $this->currentMethod->getNamespace() : $this->classDefinition->getNamespace();

        return fqcn($className, $namespace, $this->aliasManager);
    }