returns the name of the class, if the reflected callback is an object (except Closure)

@return string
975115
public function getClassName()
    {
        if ($this->isMethod() || $this->isInvokedObject()) {
            $callable = $this->explodeCallable();
            if ($this->isInstanceMethod() || $this->isInvokedObject()) {
                return get_class($callable[0]);
            }
            return $callable[0];
        }
        return '';
    }
322668
public function getClass()
    {
        try {
            $class = parent::getClass();
        } catch (\Exception $e) {
            return null;
        }
        return is_object($class) ? new ClassReflection($class->getName()) : null;
    }
70287
public function getName()
    {
        if (empty($this->name)) {
            $this->name = strstr((new \ReflectionClass(get_class($this)))->getShortName(), 'Provider', true);
        }

        return $this->name;
    }
328724
public static function name()
    {
        $class = get_called_class();
        if (!isset(self::$names[$class])) {
            self::$names[$class] = self::generateName($class);
        }

        return self::$names[$class];
    }
1442
public function getName()
    {
        if ($this->_name === null) {
            $this->_name = ((new \ReflectionClass($this))->getShortName());
        }
        
        return $this->_name;
    }
847722
private function classNameReference() {
    switch ($this->currentType) {
      case T_STRING:
      case T_NS_SEPARATOR:
      case T_NAMESPACE:
        $namespace_path = $this->name();
        if ($this->currentType === T_DOUBLE_COLON) {
          $node = $this->staticMember($namespace_path);
          return $this->dynamicClassNameReference($node);
        }
        else {
          return $namespace_path;
        }
      case T_STATIC:
        $static_node = $this->mustMatchToken(T_STATIC);
        if ($this->currentType === T_DOUBLE_COLON) {
          $node = $this->staticMember($static_node);
          return $this->dynamicClassNameReference($node);
        }
        else {
          return $static_node;
        }
      default:
        if ($this->currentType === '$' && !$this->isLookAhead('{')) {
          return $this->dynamicClassNameReference($this->indirectReference());
        }
        $var_node = $this->referenceVariable();
        if ($this->currentType === T_DOUBLE_COLON) {
          $var_node = $this->staticMember($var_node);
        }
        return $this->dynamicClassNameReference($var_node);
    }
  }
1324746
public function getName()
    {
        if (!$this->name) {
            if ($this->config['name']) {
                return $this->name = $this->config['name'];
            }

            $ref = new \ReflectionClass(static::class);

            $name = substr($ref->getShortName(), 0, -10);

            return $this->name = strtolower($name);
        }

        return $this->name;
    }
1253219
final private function getRefClass()
    {
        if ($this->refClass === null) {
            $this->refClass = new \ReflectionClass($this);
        }

        return $this->refClass;
    }
626382
public function resolveClassname()
    {
        $resolver = $this->smd->getNameResolver();
        if ( $resolver && is_callable($resolver) ) {
            return call_user_func_array($resolver, [$this]);
        }
        return $this->getDottedClassname();
    }
886254
private function getClass($mixed = null)
        {
            if (is_object($mixed)) {
                return get_class($mixed);
            }

            if (!is_null($mixed)) {
                return $mixed;
            }

            return $this->getCalledClass();
        }
461526
protected function getMockName()
    {
        if ($this->customClassName) {
            return $this->getClassName($this->customClassName);
        }

        return $this->getClassName() . $this->mockUnique;
    }
362739
public function get_callback_reflection() {
		if ( is_array( $this->callback ) ) {
			return new \ReflectionMethod( $this->callback[0], $this->callback[1] );
		} else {
			return new \ReflectionFunction( $this->callback );
		}
	}
813323
public static function get_name() {
        // Override in subclass with real lang string.
        $parts = explode('\\', get_called_class());
        if (count($parts) !== 3) {
            return get_string('unknownevent', 'error');
        }
        return $parts[0].': '.str_replace('_', ' ', $parts[2]);
    }
698640
public function getClass()
    {
        return $this->refl->isAbstract()
            ? null
            : new ParsedClass(
                (string) $this->refl->getDocComment(),
                $this->getCleanReflectionName(),
                $this->refl->getNamespaceName(),
                $this->getMethods()
            );
    }
1270593
private function getType()
    {
        if ($class = $this->reflection->getClass()) {
            return $class->name;
        }
        if ($this->reflection->isArray()) {
            return 'array';
        }
        if (version_compare(phpversion(), '7.0', '>=')
            and $type = $this->reflection->getType()
        ) {
            return $type;
        }
        return '';
    }
557475
public function getName()
    {
        $fqdnClassName = get_class($this);
        $className = substr($fqdnClassName, strrpos($fqdnClassName, '\\') + 1);
        return str_replace("Service", "", $className);
    }
1076832
public function getName()
    {
        return isset($this->name) && $this->name ? $this->name : class_basename($this);
    }