PHP Function Get_Class_Methods

The php function get_class_methods returns an array of methods that have been defined for the class identified by name_of_class. The function is available in PHP5 and does not require a class to be explicitly loaded using include / require or classname = "" in the constructor. This makes it suitable for projects that need to find classes in a larger list of class instances, such as automated class documentation or generic object debuggers.

However this function also returns all inherited methods, so it is not appropriate for finding overridden static methods in a derived class. The solution is to use the __CLASS__ definition of PHP to pass the class name of the derived class to its base class. This can be done by making the derived class's constructor protected abstract and returning a call to this method in its local object scope.

In this example we have a Car class that has a static function called get_int(). The function is overridden in a Bar class that extends the Car class. We need to be able to determine what class a given call to the get_int() method is made from, in order to find out which overridden static method it is calling.

In this example, we have the constructor of the Car class set to return a call to the get_int() method in the Bar class, as shown below. We also use the php function strtolower() to convert all string values returned by get_class_methods into lower case. This ensures that the string returned by get_class_methods is valid, and that it can be used in an array. This array is then sorted to identify the call that we need to take.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

get_class_methods example

'flipimage',
            'flopimage',
            'readimage',
            'readimageblob',
        );

        // Now, test for deep requirements within Imagick.         if ( ! defined( 'imagick::COMPRESSION_JPEG' ) ) {
            return false;
        }

        $class_methods = array_map( 'strtolower', get_class_methods( 'Imagick' ) );
        if ( array_diff( $required_methods, $class_methods ) ) {
            return false;
        }

        return true;
    }

    /** * Checks to see if editor supports the mime-type specified. * * @since 3.5.0 * * @param string $mime_type * @return bool */
parent::setUp();

    // Construct a state object used for testing logger assertions.     $this->state = new State(new KeyValueMemoryFactory());

    // Create a mock logger to set a flag in the resulting state.     $logger = $this->prophesize('Drupal\Core\Logger\LoggerChannelInterface');
    // Safely ignore the cron success message.     $logger->info('Cron run completed.')->shouldBeCalled();
    // Set a flag to track when a message is logged by adding a callback     // function for each logging method.     foreach (get_class_methods(LoggerInterface::class) as $logger_method) {
      $logger->{$logger_method}(Argument::cetera())->will(function D) {
        \Drupal::state()->set('cron_test.message_logged', TRUE);
      });
    }

    // Create a logger factory to produce the resulting logger.     $logger_factory = $this->prophesize('Drupal\Core\Logger\LoggerChannelFactoryInterface');
    $logger_factory->get(Argument::exact('cron'))->willReturn($logger->reveal());

    // Create a mock time service.     $time = $this->prophesize('Drupal\Component\Datetime\TimeInterface');

    
$message = $error->getMessage();
        preg_match('/^Call to undefined method (.*)::(.*)\(\)$/', $message, $matches);
        if (!$matches) {
            return null;
        }

        $className = $matches[1];
        $methodName = $matches[2];

        $message = sprintf('Attempted to call an undefined method named "%s" of class "%s".', $methodName, $className);

        if ('' === $methodName || !class_exists($className) || null === $methods = get_class_methods($className)) {
            // failed to get the class or its methods on which an unknown method was called (for example on an anonymous class)             return new UndefinedMethodError($message, $error);
        }

        $candidates = [];
        foreach ($methods as $definedMethodName) {
            $lev = levenshtein($methodName, $definedMethodName);
            if ($lev <= \strlen($methodName) / 3 || str_contains($definedMethodName, $methodName)) {
                $candidates[] = $definedMethodName;
            }
        }

        
$message = $this->_messageTemplates[$messageKey];

        if (null !== ($translator = $this->getTranslator())) {
            if ($translator->isTranslated($messageKey)) {
                $message = $translator->translate($messageKey);
            } else {
                $message = $translator->translate($message);
            }
        }

        if (is_object($value)) {
            if (!in_array('__toString', get_class_methods($value))) {
                $value = get_class($value) . ' object';
            } else {
                $value = $value->__toString();
            }
        } else {
            $value = implode((array) $value);
        }

        if ($this->getObscureValue()) {
            $value = str_repeat('*', strlen($value));
        }

        

  protected function getMockSource() {
    $this->createMock('\Iterator');

    $class = 'Drupal\migrate\Plugin\migrate\source\SourcePluginBase';
    $source = $this->getMockBuilder($class)
      ->disableOriginalConstructor()
      ->onlyMethods(get_class_methods($class))
      ->getMockForAbstractClass();
    $source->expects($this->once())
      ->method('rewind')
      ->willReturn(TRUE);
    $source->expects($this->any())
      ->method('initializeIterator')
      ->willReturn([]);
    $source->expects($this->any())
      ->method('valid')
      ->will($this->onConsecutiveCalls(TRUE, FALSE));

    

    $this->assertSame('en', $this->entity->language()->getId());
  }

  /** * Setup for the tests of the ::load() method. */
  public function setupTestLoad() {
    // Base our mocked entity on a real entity class so we can test if calling     // Entity::load() on the base class will bubble up to an actual entity.     $this->entityTypeId = 'entity_test_mul';
    $methods = get_class_methods(EntityTestMul::class);
    unset($methods[array_search('load', $methods)]);
    unset($methods[array_search('loadMultiple', $methods)]);
    unset($methods[array_search('create', $methods)]);
    $this->entity = $this->getMockBuilder(EntityTestMul::class)
      ->disableOriginalConstructor()
      ->onlyMethods($methods)
      ->getMock();

  }

  /** * @covers ::load * * Tests Entity::load() when called statically on a subclass of Entity. */
return $object->$item;
        }
    }

    static $cache = [];

    $class = \get_class($object);

    // object method     // precedence: getXxx() > isXxx() > hasXxx()     if (!isset($cache[$class])) {
        $methods = get_class_methods($object);
        sort($methods);
        $lcMethods = array_map(function D$value) { return strtr($value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'); }, $methods);
        $classCache = [];
        foreach ($methods as $i => $method) {
            $classCache[$method] = $method;
            $classCache[$lcName = $lcMethods[$i]] = $method;

            if ('g' === $lcName[0] && 0 === strpos($lcName, 'get')) {
                $name = substr($method, 3);
                $lcName = substr($lcName, 3);
            } elseif ('i' === $lcName[0] && 0 === strpos($lcName, 'is')) {
                
if (\count($alternatives) > 0) {
            $message .= sprintf(', did you mean "%s"?', implode('", "', $alternatives));
        } else {
            $message .= sprintf('. Available methods: "%s".', implode('", "', $collection));
        }

        return $message;
    }

    private function getClassMethodsWithoutMagicMethods($classOrObject): array
    {
        $methods = get_class_methods($classOrObject);

        return array_filter($methods, fn (string $method) => 0 !== strncmp($method, '__', 2));
    }
}

    public function __construct()
    {
        $this->day_pcre = '(' . implode('|', array_keys($this->day)) . ')';
        $this->month_pcre = '(' . implode('|', array_keys($this->month)) . ')';

        static $cache;
        if (!isset($cache[get_class($this)]))
        {
            $all_methods = get_class_methods($this);

            foreach ($all_methods as $method)
            {
                if (strtolower(substr($method, 0, 5)) === 'date_')
                {
                    $cache[get_class($this)][] = $method;
                }
            }
        }

        foreach ($cache[get_class($this)] as $method)
        {
if (\count($alternatives) > 0) {
            $message .= sprintf(', did you mean "%s"?', implode('", "', $alternatives));
        } else {
            $message .= sprintf('. Available methods: "%s".', implode('", "', $collection));
        }

        return $message;
    }

    private function getClassMethodsWithoutMagicMethods($classOrObject): array
    {
        $methods = get_class_methods($classOrObject);

        return array_filter($methods, fn (string $method) => 0 !== strncmp($method, '__', 2));
    }
}
return $resource;
    }

    /** * @return resource */
    private function createStream(RequestInterface $request, array $options)
    {
        static $methods;
        if (!$methods) {
            $methods = \array_flip(\get_class_methods(__CLASS__));
        }

        if (!\in_array($request->getUri()->getScheme(), ['http', 'https'])) {
            throw new RequestException(\sprintf("The scheme '%s' is not supported.", $request->getUri()->getScheme()), $request);
        }

        // HTTP/1.1 streams using the PHP stream wrapper require a         // Connection: close header         if ($request->getProtocolVersion() == '1.1'
            && !$request->hasHeader('Connection')
        ) {
            
$lock->expects($this->once())
      ->method('release')
      ->with($lock_name);
    $lock->expects($this->exactly(2))
      ->method($this->anything());
    $container->set('lock', $lock);

    $cache_tag_invalidator = $this->createMock('Drupal\Core\Cache\CacheTagsInvalidator');
    $container->set('cache_tags.invalidator', $cache_tag_invalidator);

    \Drupal::setContainer($container);
    $methods = get_class_methods('Drupal\comment\Entity\Comment');
    unset($methods[array_search('preSave', $methods)]);
    unset($methods[array_search('postSave', $methods)]);
    $methods[] = 'invalidateTagsOnSave';
    $comment = $this->getMockBuilder('Drupal\comment\Entity\Comment')
      ->disableOriginalConstructor()
      ->onlyMethods($methods)
      ->getMock();
    $comment->expects($this->once())
      ->method('isNew')
      ->willReturn(TRUE);
    $comment->expects($this->once())
      
// Implementation should support the passed mime type.         if ( isset( $args['mime_type'] ) &&
            ! call_user_func(
                array( $implementation, 'supports_mime_type' ),
                $args['mime_type']
            ) ) {
            continue;
        }

        // Implementation should support requested methods.         if ( isset( $args['methods'] ) &&
            array_diff( $args['methods'], get_class_methods( $implementation ) ) ) {

            continue;
        }

        // Implementation should ideally support the output mime type as well if set and different than the passed type.         if (
            isset( $args['mime_type'] ) &&
            isset( $args['output_mime_type'] ) &&
            $args['mime_type'] !== $args['output_mime_type'] &&
            ! call_user_func( array( $implementation, 'supports_mime_type' ), $args['output_mime_type'] )
        ) {
            
$message = $error->getMessage();
        preg_match('/^Call to undefined method (.*)::(.*)\(\)$/', $message, $matches);
        if (!$matches) {
            return null;
        }

        $className = $matches[1];
        $methodName = $matches[2];

        $message = sprintf('Attempted to call an undefined method named "%s" of class "%s".', $methodName, $className);

        if ('' === $methodName || !class_exists($className) || null === $methods = get_class_methods($className)) {
            // failed to get the class or its methods on which an unknown method was called (for example on an anonymous class)             return new UndefinedMethodError($message, $error);
        }

        $candidates = [];
        foreach ($methods as $definedMethodName) {
            $lev = levenshtein($methodName, $definedMethodName);
            if ($lev <= \strlen($methodName) / 3 || str_contains($definedMethodName, $methodName)) {
                $candidates[] = $definedMethodName;
            }
        }

        
Home | Imprint | This part of the site doesn't use cookies.