Возвращает имя свойства и его локаль по полному имени свойства
@param $fullPropName полное имя свойства
@return array
160818
protected function splitFullPropName($fullPropName)
    {
        $propInfo = explode(ILocalizedProperty::LOCALE_SEPARATOR, $fullPropName);
        $propName = $propInfo[0];
        $localeId = isset($propInfo[1]) ? $propInfo[1] : null;

        return [$propName, $localeId];
    }
883229
protected function _getFullActionName()
    {
        if ($this->_fullActionName == null) {
            $this->_fullActionName = $this->_request->getFullActionName();
        }
        return $this->_fullActionName;
    }
1342922
private static function getFullNamespace($filename)
    {
        $lines = file($filename);
        $namespaceLine = preg_grep('/^namespace /', $lines);
        $namespaceLine = array_shift($namespaceLine);

        $match = array();
        preg_match('#(namespace)(\\s+)([A-Za-z0-9\\\\]+?)(\\s*);#sm', $namespaceLine, $match);

        $fullNamespace = $match['3'];

        return $fullNamespace;
    }
757501
public static function getShortBundleName($fullBundleName)
    {
        // Oops, given name of bundle is invalid
        if (!Regex::isValidBundleName($fullBundleName)) {
            if (!is_string($fullBundleName)) {
                $fullBundleName = gettype($fullBundleName);
            }

            throw new IncorrectBundleNameException($fullBundleName);
        }

        $matches = [];
        $pattern = Regex::getBundleNamePattern();
        preg_match($pattern, $fullBundleName, $matches);

        return $matches[1];
    }
241497
final public static function className(string $fullName = null): string
    {
        $fullName = $fullName ?: self::fullName();
        $fullName = str_replace('\\', '/', $fullName);

        return basename($fullName);
    }
1244104
public static function collectFromClassNode(ClassLike $classLikeNode, $fullClassName)
    {
        $properties = [];

        foreach ($classLikeNode->stmts as $classLevelNode) {
            if ($classLevelNode instanceof Property) {
                foreach ($classLevelNode->props as $classPropertyNode) {
                    $propertyName = $classPropertyNode->name->toString();
                    $properties[$propertyName] = new static(
                        $fullClassName,
                        $propertyName,
                        $classLevelNode,
                        $classPropertyNode
                    );
                }
            }
        }

        return $properties;
    }
690154
public function getFullSchema() {
		$authGroups = $this->getAuthGroupsList();
		$authSchema = [];
		$defaultSchema = $this->_getDefaultSchemaData();
		$extendSchema = $this->_modelConfigSettingsApp->getExtendSchemaData();
		if (!empty($authGroups)) {
			foreach ($authGroups as $authGroupField) {
				$authSchema[$authGroupField] = ['type' => 'string', 'default' => ''];
			}
		}

		$result = $defaultSchema + $authSchema + $extendSchema;

		return $result;
	}
205629
public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }
1206712
public function getFullName($fullData = null) {
		$result = $this->getEmptyText();
		if (empty($fullData)) {
			return $result;
		}

		$fieldsFullName = [
			[
				CAKE_LDAP_LDAP_ATTRIBUTE_SURNAME,
				CAKE_LDAP_LDAP_ATTRIBUTE_GIVEN_NAME,
				CAKE_LDAP_LDAP_ATTRIBUTE_MIDDLE_NAME
			],
			[
				CAKE_LDAP_LDAP_ATTRIBUTE_DISPLAY_NAME,
				CAKE_LDAP_LDAP_ATTRIBUTE_NAME
			]
		];
		$dataFullName = [];
		foreach ($fieldsFullName[0] as $field) {
			$dataItem = h(Hash::get($fullData, $field));
			if (!empty($dataItem)) {
				$dataFullName[] = mb_ucfirst($dataItem);
			}
		}
		if (count($dataFullName) == 3) {
			$result = implode(' ', $dataFullName);

			return $result;
		}

		foreach ($fieldsFullName[1] as $field) {
			$dataItem = h(Hash::get($fullData, $field));
			if (empty($dataItem)) {
				continue;
			}

			$result = mb_ucfirst($dataItem);
		}

		return $result;
	}
887725
public function col_fullnameuser($event) {
        // Get extra event data for origin and realuserid.
        $logextra = $event->get_logextra();

        // Add username who did the action.
        if (!empty($logextra['realuserid'])) {
            $a = new stdClass();
            if (!$a->realusername = $this->get_user_fullname($logextra['realuserid'])) {
                $a->realusername = '-';
            }
            if (!$a->asusername = $this->get_user_fullname($event->userid)) {
                $a->asusername = '-';
            }
            if (empty($this->download)) {
                $params = array('id' => $logextra['realuserid']);
                if ($event->courseid) {
                    $params['course'] = $event->courseid;
                }
                $a->realusername = html_writer::link(new moodle_url('/user/view.php', $params), $a->realusername);
                $params['id'] = $event->userid;
                $a->asusername = html_writer::link(new moodle_url('/user/view.php', $params), $a->asusername);
            }
            $username = get_string('eventloggedas', 'report_log', $a);

        } else if (!empty($event->userid) && $username = $this->get_user_fullname($event->userid)) {
            if (empty($this->download)) {
                $params = array('id' => $event->userid);
                if ($event->courseid) {
                    $params['course'] = $event->courseid;
                }
                $username = html_writer::link(new moodle_url('/user/view.php', $params), $username);
            }
        } else {
            $username = '-';
        }
        return $username;
    }
435606
public static function calculate_course_names($courseid, $fullname, $shortname) {
        global $CFG, $DB;

        $currentfullname = '';
        $currentshortname = '';
        $counter = 0;
        // Iteratere while the name exists
        do {
            if ($counter) {
                $suffixfull  = ' ' . get_string('copyasnoun') . ' ' . $counter;
                $suffixshort = '_' . $counter;
            } else {
                $suffixfull  = '';
                $suffixshort = '';
            }
            $currentfullname = $fullname.$suffixfull;
            $currentshortname = substr($shortname, 0, 100 - strlen($suffixshort)).$suffixshort; // < 100cc
            $coursefull  = $DB->get_record_select('course', 'fullname = ? AND id != ?',
                    array($currentfullname, $courseid), '*', IGNORE_MULTIPLE);
            $courseshort = $DB->get_record_select('course', 'shortname = ? AND id != ?', array($currentshortname, $courseid));
            $counter++;
        } while ($coursefull || $courseshort);

        // Return results
        return array($currentfullname, $currentshortname);
    }
579933
private function findName ($full_name)
	{
		$partsA = explode("/", $full_name);
		$partsB = explode(".", $partsA[count($partsA) - 1]); 
		$name = null;
		for ($i=0; $i < count($partsB) - 1; $i++) 
		{ 
			if ($i == 0) 
			{
				$name .= $partsB[$i];			
			} 
			else 
			{
				$name .= ".";			
				$name .= $partsB[$i];			
			}
		}
		$this->name = $name;
	}
458539
public function setNames($firstname, $lastname, $fullname)
    {

        $names = array(0 => '', 1 => '');
        if (!empty($fullname)) {
            $this->fullname = trim($fullname);
            $names = preg_split("/[\s]+/", $this->fullname, 2);
        }
        if (!empty($firstname)) {
            $this->firstname = trim($firstname);
            $names[0] = $this->firstname;
        } else if (!empty($names[0])) {
            $this->firstname = $names[0];
        } else {
            $this->firstname = 'User';
        }
        if (!empty($lastname)) {
            $this->lastname = trim($lastname);
            $names[1] = $this->lastname;
        } else if (!empty($names[1])) {
            $this->lastname = $names[1];
        } else {
            $this->lastname = $this->ltiUserId;
        }
        if (empty($this->fullname)) {
            $this->fullname = "{$this->firstname} {$this->lastname}";
        }

    }
89805
public function getFor(string $paramName): array
    {
        if (isset($this->errors[$paramName])) {
            return $this->errors[$paramName];
        }

        return [];
    }
724625
public static function parseClass($fullClassName)
    {
        $classFileName  = self::locateClassFile($fullClassName);
        $namespaceParts = explode('\\', $fullClassName);
        $className      = array_pop($namespaceParts);
        $namespaceName  = join('\\', $namespaceParts);

        // we have a namespace node somewhere
        $namespace      = self::parseFileNamespace($classFileName, $namespaceName);
        $namespaceNodes = $namespace->stmts;

        foreach ($namespaceNodes as $namespaceLevelNode) {
            if ($namespaceLevelNode instanceof ClassLike && $namespaceLevelNode->name == $className) {
                $namespaceLevelNode->setAttribute('fileName', $classFileName);

                return $namespaceLevelNode;
            }
        }

        throw new \InvalidArgumentException("Class $fullClassName was not found in the $classFileName");
    }
1237613
protected function getFullPath($fileName)
    {
        ;
        $fileName = trim($fileName);
        if (realpath($fileName) && !(basename($fileName) === $fileName)) {
            return realpath($fileName);
        }
        $fullName = join(DIRECTORY_SEPARATOR, array($this->configurationFileDir, $fileName));
        
        if (file_exists($fullName)) {
            return $fullName;
        }
        throw new WURFL_WURFLException("The specified path '" . $fullName . "' does not exist");
    }
1034817
public static function ofObjectType($fullName)
    {
        $result = self::of($fullName);
        if (!($result instanceof ObjectType))
            throw new InvalidArgumentException("Argument 'fullName' does not describe a class or interface.");
        return $result;
    }