Method

@param string $casing = 'upper'

@return string
7171
public static function method(String $casing = 'upper') : String
    {
        return mb_convert_case(Server::data('requestMethod'), Helper::toConstant($casing, 'MB_CASE_'));
    }
470628
public function toUpperCaseFirst() {
		$first = $this->substring(0, 1);
		$rest = $this->substring(1);

		return new Text(mb_strtoupper($first, $this->encoding) . $rest, $this->encoding);
	}
1097881
public function toUpper()
        {
            $stringLen = strlen($this->dataStr);
            $p = 0;
            
            while ($p<$stringLen) {
                $mode = self::identifyMode(substr($this->dataStr, $p), $this->modeHint);
                if($mode == QR_MODE_KANJI) {
                    $p += 2;
                } else {
                    if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
                        $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
                    }
                    $p++;
                }
            }

            return $this->dataStr;
        }
268858
function camelCase($pString, $upperCaseFirst = FALSE)
    {
        $regEx = $upperCaseFirst
            ? '/(?:^|-)(.?)/'
            : '/(?:-)(.?)/';

        $filter = function ($p) {
            return \strtoupper($p[1]);
        };

        return \preg_replace_callback($regEx, $filter, $pString);
    }
1229658
static public function camelize($word,$upper=false)
 	{
		$word = strtolower($word);

		$preg = array(
			'/(.)(^|_|-)+(.)/e' => "strtolower('\\1').strtoupper('\\3')"
		);

		$word = preg_replace(array_keys($preg), array_values($preg), $word);
		if ($upper) return ucfirst($word);
		return $word;
	}
802328
public static function toPascalCase(string $string): string
    {
        $words = self::_prepStringForCasing($string);
        $string = implode('', array_map([
            static::class,
            'upperCaseFirst'
        ], $words));

        return $string;
    }
870497
def generate_uppercase_key(key, namespace=None):
    """"""
    if namespace:
        namespace = [part for part in listify(namespace) if part]
        key = '_'.join(namespace + [key])

    key = key.upper()
    return key
606991
public static function uppercase($string = false, $selector = false) {

        if ($string) {

            switch ($selector) {
                case 'first':
                    return ucfirst($string);
                case 'words':
                    return ucwords($string);
                default:
                    return strtoupper($string);
            }
        }

        return false;
    }
1231397
protected function _upperCaseFirst()
    {
        if (!$this->_isVoid()) {
            $first_char = $this->_first()->_upper();
            $other_chars = $this->sub(1, $this->int_count);

            return self::concat($first_char, $other_chars);
        }

        return $this;
    }
997712
public function toUpperCamelCase($string)
  {
      $string = str_replace(array('-', '_'), ' ', $string);
      $string = ucwords(strtolower($string));
      $string = str_replace(' ', '', $string);

      return $string;
  }
1108266
public function upperWords($delimiters = " \t\r\n\f\v")
    {
        return static::of(
            mb_ucwords($this->contents, $delimiters, $this->encoding),
            $this->encoding
        );
    }
1089830
public static function lowerCase($strText, $strEncoding = '')
    {

        if (is_null(self::$blnMbstring)) {
            self::$blnMbstring = extension_loaded('mbstring');
        }

        if (!self::$blnMbstring) {
            $strLowerCaseText = strtolower($strText);
        } else {
            if ($strEncoding == '') {
                $strLowerCaseText = mb_strtolower($strText);
            } else {
                $strLowerCaseText = mb_strtolower($strText, $strEncoding);
            }
        }

        return $strLowerCaseText;
    }
887470
public static function convertToPascalCase($word)
    {
        // separate into block for easier readability
        $word = str_replace('_', ' ', $word);
        $word = strtolower($word);
        $word = ucwords($word);
        return str_replace(' ', '', $word);
    }
490305
public static function UPPERCASE($mixedCaseString)
    {
        $mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);

        if (is_bool($mixedCaseString)) {
            $mixedCaseString = ($mixedCaseString) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
        }

        return PHPExcel_Shared_String::StrToUpper($mixedCaseString);
    }
1151612
protected function studlyCase($string)
    {
        return preg_replace_callback('/(?:^|(\w)-)(\w)/', function($match) {
            return $match[1] . strtoupper($match[2]);
        }, strtolower(addcslashes($string, '\\')));
    }
2800
public static function toCamelCase($str, $upperFirstChar = false)
    {
        $str = self::strtolower($str);

        if ($upperFirstChar) {
            $str = self::ucfirst($str);
        }

        return preg_replace_callback('/_+([a-z])/', function ($c) {
            return strtoupper($c[1]);
        }, $str);
    }
1223662
public static function upperCase(?string $string = null): ?string
    {
        if ($string === null) {
            return null;
        }

        return mb_strtoupper($string, 'UTF-8');
    }