Returns className.

@param string $prefix  Prefix
@param string $name    Name
@param bool   $ucfirst First letter - caps

@return string
497522
public static function getClassName($prefix, $name, $ucfirst = false)
  {
    if (substr($prefix, -1, 1) == "\\") {
      $className = $prefix;
    } else {
      $className = $prefix . "_";
    }
    $className .= $name;
    
    if ($ucfirst) {
      $result = "";
      
      $nsPath = explode("\\", $className);
      $name = array_pop($nsPath);
      
      if (sizeof($nsPath)) {
        for ($i = 0; $i < sizeof($nsPath); $i++) {
          $nsPath[$i] = ucfirst(strtolower($nsPath[$i]));
        }
        $result .= implode("\\", $nsPath);
      }
      if (strlen($result) && substr($result, -1, 1) != "\\") {
        $result .= "\\";
      }
      
      $dirPath = explode("_", $name);
      for ($i = 0; $i < sizeof($dirPath); $i++) {
        $dirPath[$i] = ucfirst(strtolower($dirPath[$i]));
      }
      $result .= implode("_", $dirPath);
      
    } else {
      $result = $className;
    }

    return $result;
  }
657205
public function getAttribute( $name, $prefix )
	{
		return $this->hasAttribute( $name, $prefix )
			? $this->attributes[ "$prefix:$name" ]
			: (
				$this->hasAttributeGroup( $name, $prefix )
					? $this->attributeGroups[ "$prefix:$name" ]
					: false
			  );
	}
134871
public function getClassName($name)
    {
        $name = $this->_formatName($name);
        if ($this->_useStaticRegistry
            && isset(self::$_staticLoadedPlugins[$this->_useStaticRegistry][$name])
        ) {
            return self::$_staticLoadedPlugins[$this->_useStaticRegistry][$name];
        } elseif (isset($this->_loadedPlugins[$name])) {
            return $this->_loadedPlugins[$name];
        }

        return false;
    }
1276845
protected function createClassName(string $name): string
    {
        $result = str_replace('_', ' ', $name);

        return str_replace(' ', '', ucwords($result));
    }
649344
public static function camelCase($word, bool $ucFirstWord = true): string
    {
        static $words = [];
        
        if (!isset($words[$word])) {
            $words[$word] = str_replace(' ', '', ucwords(strtr($word, '_', ' ')));
            if (!$ucFirstWord) {
                substr_replace($words[$word], $word{0}, 0, 1);
            }
        }
        return $words[$word];
    }
951736
public function getFirstName() : ?string 
    {
        if ( ! $this->hasFirstName()) {
            $this->setFirstName($this->getDefaultFirstName());
        }
        return $this->firstName;
    }
727791
private function getCommandClassName($name)
    {
        $name = mb_convert_case($name[0], MB_CASE_UPPER, 'utf-8') . mb_substr($name, 1, mb_strlen($name));
        
        $drivername = $this->getDriverName();
        $classnameLocal = sprintf('\Intervention\Image\%s\Commands\%sCommand', $drivername, ucfirst($name));
        $classnameGlobal = sprintf('\Intervention\Image\Commands\%sCommand', ucfirst($name));

        if (class_exists($classnameLocal)) {
            return $classnameLocal;
        } elseif (class_exists($classnameGlobal)) {
            return $classnameGlobal;
        }

        throw new \Intervention\Image\Exception\NotSupportedException(
            "Command ({$name}) is not available for driver ({$drivername})."
        );
    }
284247
protected function determinePrefix($prefix) {
        if (is_object($prefix)) {
            $reflector = new ReflectionClass($prefix);

            return $reflector->getShortName();
        }

        return $prefix;
    }
471152
private function getFullClassName($name)
    {
        if ($name instanceof Name) {
            if ($name->isFullyQualified()) {
                return $name->toString();
            }
        }

        $name = (string)$name;

        if (isset($this->namespace->uses[$name])) {
            return $this->namespace->uses[$name];
        }

        if ($this->namespace->name) {
            return $this->namespace->name . '\\' . $name;
        }

        return $name;
    }
252566
public function getFullName($firstNameFirst = true)
    {
        $beginning = $this->lastName;
        $finish = $this->firstName;

        if ($firstNameFirst) {
            $beginning = $this->firstName;
            $finish = $this->lastName;
        }

        return trim(sprintf('%s %s', $beginning, $finish));
    }
501679
public function _prefix($name, $prefix)
    {
        list($alias, $field) = $this->undot($name);
        return $alias ? $name : "{$prefix}.{$field}";
    }
628691
protected static function keyToMethodName($keyName, $capitalizeFirstCharacter = false)
    {
        $str = str_replace(' ', '', ucwords(str_replace('_', ' ', $keyName)));
        if (!$capitalizeFirstCharacter) {
            $str = lcfirst($str);
        }
        return $str;
    }
872260
public static function normalizeClassname(string $name): string
    {
        $name = self::normalizeReservedKeywords($name, 'Type');

        return ucfirst(self::camelCase($name, '{[^a-z0-9]+}i'));
    }
376051
public function getFirst($name)
    {
        $names = func_get_args();

        foreach ($names as $name) {
            if (isset($this->data[$name])) {
                return $this->data[$name];
            }
        }
    }
1184414
private function getSafeName(string $name) : string
    {
        $name = preg_replace('/[^A-Za-z0-9-]/', '_', $name);
        if (strlen($name) > 64) {
            if (str_word_count($name) > 1 && preg_match_all('/\b(\w)/', $name, $m)) {
                // Create an "acronym" from first letters
                $short = implode('', $m[1]);
            } else {
                $short = md5($name);
            }
            $short .= "_";
            $remaining = 64 - strlen($short);
            $nextSpace = strpos($name, " ", (strlen($name)-$remaining))
                ? : strpos($name, "_", (strlen($name)-$remaining));

            $newName = $nextSpace === false
                ? $short
                : $short . substr($name, $nextSpace);
        } else {
            $newName = $name;
        }

        $newName = preg_replace('/[^A-Za-z0-9-]+/', '_', $newName);
        $newName = trim($newName, "_");
        return $newName;
    }
590005
protected function convertToFullQualifyClassName($name)
    {
        if (Str::contains($name, '/')) {
            $name = str_replace('/', '\\', $name);
        }

        if (Str::startsWith($name, '\\')) {
            $name = substr($name, 1);
        }
        else {
            $name = $this->getDefaultNamespace().'\\'.$name;
        }

        return $this->filterFullQualifyClassName($name, function ($part) {
            return ucfirst($part);
        });
    }
557853
protected function resolveNameValue($name)
    {
    	if ($name === null) return null;

    	if ($prefixName = $this->getPrefixName()) {

    		$name = $prefixName . $name;
    	}

    	return $name;
    }