Call helloWorld
@param name String name
@return String helloworld
4991
public String helloWorld(String name)
   {
      if (mc == null)
         associate();

      return mc.helloWorld(name);
   }
706173
public static function __callstatic($name, $params)
    {
        if (!in_array($name, static::getDisplayableStructures())) {
            throw new Exception("Unknown structure function name $name");
        }

        // target string is expected to be:
        $target       = $params[0][0];
        $functionName = '__' . $name;

        return static::$functionName($target);
    }
1048667
public static function __callstatic($name, $params)
    {

        $matches = static::isBackgroundCall($name);

        if (null === $matches) {
            throw new Exception("Unknown background color function name $name");
        }

        $colorName   = $matches[2];
        $knownColors = static::getKnownColors();
        $colorID     = $knownColors[$colorName];

        if (!$colorID) {
            throw new Exception("Unknown background color name $name");
        }

        $color = static::color($colorID);

        // target string is expected to be:
        $targetString = $params[0][0];

        $element = new TextElement($targetString);
        $element->setBackgroundColor($color);

        return $element->render();
    }
285964
public function getCallable($name)
     {
         if (method_exists($this, $name)) {
             return call_user_func([$this, $name]);
         } else {
             throw new InvalidArgumentException('Undefined property: '.get_class($this)."::$name");
         }
     }
408892
public function callExtension($name, array $params = [])
    {
        $extension = $this->getExtension($name);

        // call_user_func_array seems to be slow
        switch (count($params)) {
            case 0:
                $result = call_user_func($extension);
                break;
            case 1:
                $result = call_user_func($extension, $params[0]);
                break;
            case 2:
                $result = call_user_func($extension, $params[0], $params[1]);
                break;
            case 3:
                $result = call_user_func($extension, $params[0], $params[1], $params[2]);
                break;
            case 4:
                $result = call_user_func($extension, $params[0], $params[1], $params[2], $params[3]);
                break;
            default:
                $result = call_user_func_array($extension, $params);
                break;
        }

        $this->callListeners($name, $result);

        return $result;
    }
1095540
protected function callGlobalFunction(string $name, ?array $arguments = null)
    {
        if (function_exists($name)) {
            return call_user_func_array($name, $arguments ?? []);
        }

        throw new \ErrorException(
            sprintf("Undefined global function (%s) called!", $name));
    }
1298651
public static function get($name)
	{
		$args = func_get_args();
		if (!empty($args))
		{
			unset($args[0]);
		}
		if (isset(self::$list[$name]))
		{
			array_unshift($args, self::$list[$name]);
			return call_user_func_array('sprintf', $args);
		}
		else
		{
			return $name;
		}
	}
987840
def getCallSetByName(self, name):
        
        if name not in self._callSetNameMap:
            raise exceptions.CallSetNameNotFoundException(name)
        return self._callSetNameMap[name]
286451
public function get(string $name): ?string
    {
        $key = strtolower($name);
        if (!isset($this->headers[$key])) {
            return null;
        }

        return $this->headers[$key][1];
    }
732508
protected function callHooks($name)
    {
        $hooks = Arr::get($this->hooks, $name, []);

        foreach ($hooks as $func) {
            if (!$func instanceof Closure) {
                continue;
            }

            $response = call_user_func($func, $this);

            if ($response instanceof Response) {
                return $response;
            }
        }
    }
1329645
public function _call($name, $arguments)
    {
        $object = $this->getObject();
    	try
    	{
			$method = new \ReflectionMethod($object, $name);
		} catch (\Exception $e)
		{
		    if (method_exists($object, '__call'))
		    {
		        return call_user_func_array(array($object, '__call'), (array) $arguments);
		    } else
		    {
                throw new \Exception('Unable to invoke method ' . $name . ' on object of class ' . get_class($object));
		    }
		    return null;
		}

		$method->setAccessible(true);
		return $method->invokeArgs($object, $arguments);
    }
589233
static function get($name)
    {
        $name = StringHelper::toLittleCamelCase($name);
        
        $value = null;
        
        if (method_exists(get_called_class(), $name)) {
            $value = static::$name();
        }
        
        if (is_array($value)) {
            $value = implode('<br>', $value);
        }
        
        return $value;
    }
771049
public static String localName(String name) {
		int ix = name.lastIndexOf(Manager.HIERARCHY_DELIMITER);
		if (ix == -1) {
			return name;
		}
		return name.substring(ix + 1);
	}
34414
public static function __callstatic($name, $params)
    {
        $matches = static::isFigletCall($name);

        if (null === $matches) {
            throw new Exception("Unknown figlet function name $name");
        }

        $fontName = $matches[2];

        // target string is expected to be:
        $targetString = $params[0][0];

        return static::render($targetString, $fontName);
    }
1362723
public static String name(String name, String... names) {
        final StringBuilder builder = new StringBuilder();
        append(builder, name);
        if (names != null) {
            for (String s : names) {
                append(builder, s);
            }
        }
        return builder.toString();
    }
805156
public static function get(string $name)
    {
        return (isset($_GET[$name]) && $_GET[$name] != '') ? $_GET[$name] : '';
    }
870649
public function oneWayCall($name, $arguments = null)
    {
        Actor::call($this->actorName, $name, $arguments, true, $this->beginId);
    }