get_class - PHP code example

The php Function Get_Class

The php function get_class is used to return the name of a class. It is an essential function for object oriented programming. Object inheritance is a key feature of many languages including PHP. It allows public methods, class properties and constants to be overridden by classes that extend them. Class B in the following script extends class A and reimplements the sortArray method from A. This override makes class A’s method a public method in B.

The problem with this is that you can only receive inherited methods in the context where the caller has class reference control. That means that if you are calling a static function from another class, the name of the calling class will be returned and not the class being called. This is because of Late Static Binding.

In PHP 5, you can use the __CLASS__ constant to pass the name of the calling class to a static function in an extended class. This is the only way to get a static function name in an extended class to work correctly.

However, if you are calling this from outside of the class, or from a function within the same class, or from a variable, then it raises a TypeError error. As of PHP 8.0, this function will now only return an object if the input is not null or an integer. This change is to make the function compatible with namespaces.

get_class example

->getMockForAbstractClass();
    $browserkit_client->expects($this->once())
      ->method('getClient')
      ->willReturn($expected);

    // Because the driver is a BrowserKitDriver, we'll get back a client.     $driver = new BrowserKitDriver($browserkit_client);
    $btb = $this->mockBrowserTestBaseWithDriver($driver);

    $ref_gethttpclient = new \ReflectionMethod($btb, 'getHttpClient');

    $this->assertSame(get_class($expected), get_class($ref_gethttpclient->invoke($btb)));
  }

  /** * @covers ::getHttpClient */
  public function testGetHttpClientException() {
    // A driver type that isn't BrowserKitDriver. This should cause a     // RuntimeException.     $btb = $this->mockBrowserTestBaseWithDriver(new \stdClass());

    $ref_gethttpclient = new \ReflectionMethod($btb, 'getHttpClient');

  }

  /** * Tests that revision translations are correctly detected. * * @covers \Drupal\Core\Entity\ContentEntityStorageBase::isAnyStoredRevisionTranslated */
  public function testIsAnyStoredRevisionTranslated() {
    /** @var \Drupal\Core\Entity\ContentEntityStorageInterface $storage */
    $storage = $this->entityTypeManager->getStorage('entity_test_mul');
    $method = new \ReflectionMethod(get_class($storage), 'isAnyStoredRevisionTranslated');

    // Check that a non-revisionable new entity is handled correctly.     $entity = EntityTestMul::create();
    $this->assertEmpty($entity->getTranslationLanguages(FALSE));
    $this->assertFalse($method->invoke($storage, $entity));
    $entity->addTranslation('it');
    $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
    $this->assertFalse($method->invoke($storage, $entity));

    // Check that not yet stored translations are handled correctly.     $entity = EntityTestMul::create();

    protected function serializeEntity($entity)
    {
        if ($entity === null) {
            return [];
        }

        if ($entity instanceof Proxy) {
            $entity->__load();
            $className = get_parent_class($entity);
        } else {
            $className = \get_class($entity);
        }
        if (!\is_string($className)) {
            throw new RuntimeException('Could not get class name');
        }
        $metadata = $this->getClassMetadata($className);
        $data = [];
        $inflector = new Inflector(new NoopWordInflector(), new NoopWordInflector());

        foreach ($metadata->fieldMappings as $field => $mapping) {
            if (!($metadata->reflFields[$field] instanceof ReflectionProperty)) {
                throw new InvalidArgumentException(sprintf('Expected an instance of %s', ReflectionProperty::class));
            }

$this->setPlugin($plugin);
    }

    /** * @return array */
    public function toArray()
    {
        $listener = $this->listener;
        if (\is_array($listener)) {
            if ($listener[0] instanceof Enlight_Singleton) {
                $listener[0] = \get_class($listener[0]);
            }
            $listener = implode('::', $listener);
        }

        return [
            'name' => $this->name,
            'listener' => $listener,
            'position' => $this->position,
        ];
    }

        }

        // Entity Insertions         foreach ($uow->getScheduledEntityInsertions() as $category) {
            if (!($category instanceof Category)) {
                continue;
            }

            $category = $this->setPathForCategory($category);

            $md = $em->getClassMetadata(\get_class($category));
            $uow->recomputeSingleEntityChangeSet($md, $category);
        }

        // Entity updates         foreach ($uow->getScheduledEntityUpdates() as $category) {
            if (!($category instanceof Category)) {
                continue;
            }

            $changeSet = $uow->getEntityChangeSet($category);

'text_post_update_add_required_summary_flag' => '9.0.0',
    'text_post_update_add_required_summary_flag_form_display' => '10.0.0',
  ];
}

/** * Add allowed_formats setting to existing text fields. */
function text_post_update_allowed_formats(&$sandbox = NULL) {
  \Drupal::classResolver(ConfigEntityUpdater::class)
    ->update($sandbox, 'field_config', function DFieldConfigInterface $field_config) {
      $class = get_class($field_config);
      // Deal only with text fields and descendants.       if (is_a($class, TextItemBase::class, TRUE)) {
        // Get the existing allowed_formats setting.         $allowed_formats = $field_config->get('settings.allowed_formats');
        if (!is_array($allowed_formats) && empty($allowed_formats)) {
          // Save default value if existing value not present.           $field_config->set('settings.allowed_formats', []);
          return TRUE;
        }
      }
      return FALSE;
    });

  /** * @covers ::load * * Tests Entity::load() when called statically on a subclass of Entity. */
  public function testLoad() {
    $this->setupTestLoad();

    $class_name = get_class($this->entity);

    $entity_type_repository = $this->getMockForAbstractClass(EntityTypeRepositoryInterface::class);
    $entity_type_repository->expects($this->once())
      ->method('getEntityTypeFromClass')
      ->with($class_name)
      ->willReturn($this->entityTypeId);

    $storage = $this->createMock(EntityStorageInterface::class);
    $storage->expects($this->once())
      ->method('load')
      ->with(1)

->addTag('container.service_locator')
        ;

        (new ServiceLocatorTagPass())->process($container);

        /** @var ServiceLocator $locator */
        $locator = $container->get('foo');

        $this->assertSame(CustomDefinition::class, $locator('bar')::class);
        $this->assertSame(CustomDefinition::class, $locator('baz')::class);
        $this->assertSame(CustomDefinition::class, $locator('some.service')::class);
        $this->assertSame(CustomDefinition::class, \get_class($locator('inlines.service')));
    }

    public function testServiceWithKeyOverwritesPreviousInheritedKey()
    {
        $container = new ContainerBuilder();

        $container->register('bar', TestDefinition1::class);
        $container->register('baz', TestDefinition2::class);

        $container->register('foo', ServiceLocator::class)
            ->setArguments([[

catch (PluginNotFoundException $e) {
        // For BC reasons, we must allow attempting to stub a non-existent         // migration.       }
      catch (MigrateException $e) {
        throw $e;
      }
      catch (MigrateSkipRowException $e) {
        throw $e;
      }
      catch (\Exception $e) {
        throw new MigrateException(sprintf('%s was thrown while attempting to stub: %s', get_class($e), $e->getMessage()), $e->getCode(), $e);
      }
    }
    if ($destination_ids) {
      if (count($destination_ids) == 1) {
        return reset($destination_ids);
      }
      else {
        return $destination_ids;
      }
    }
  }

        if (false === $type) {
            return $node;
        }

        $expression = $node->getNode('expr');

        if ($this->isSafeFor($type, $expression, $env)) {
            return $node;
        }

        $class = \get_class($node);

        return new $class($this->getEscaperFilter($type, $expression), $node->getTemplateLine());
    }

    private function preEscapeFilterNode(FilterExpression $filter, Environment $env): FilterExpression
    {
        $name = $filter->getNode('filter')->getAttribute('value');

        $type = $env->getFilter($name)->getPreEscape();
        if (null === $type) {
            return $filter;
        }

  protected function setUp($import_test_views = TRUE): void {
    parent::setUp($import_test_views);

    $this->installEntitySchema('media');
    $this->installEntitySchema('file');
    $this->installSchema('file', 'file_usage');
    $this->installEntitySchema('user');
    $this->installConfig(['field', 'system', 'image', 'file', 'media']);

    if ($import_test_views) {
      ViewTestData::createTestViews(get_class($this), ['media_test_views']);
    }

    $this->testMediaType = $this->createMediaType('test');
  }

  /** * Tests the media_revision_user relationship. */
  public function testRevisionUser() {
    $primary_author = $this->createUser();
    $secondary_author = $this->createUser();

/** * Function must be public to call on caused exceptions * * @param array $causes Array that gets filled. * * @return void */
    public function getCauseMessage(&$causes)
    {
        $trace = $this->getTraceSafe();
        $cause = array('class'   => get_class($this),
                       'message' => $this->message,
                       'file' => 'unknown',
                       'line' => 'unknown');
        if (isset($trace[0])) {
            if (isset($trace[0]['file'])) {
                $cause['file'] = $trace[0]['file'];
                $cause['line'] = $trace[0]['line'];
            }
        }
        $causes[] = $cause;
        if ($this->cause instanceof PEAR_Exception) {

        $this->location = new SourceLocation;
    }

    /** * Returns node type * * @return string */
    public function getType()
    {
        $class = explode("\\", get_class($this));
        return array_pop($class);
    }

    /** * Sets leading comments array * * @param Comment[] $comments Comments array * * @return $this */
    public function setLeadingComments($comments)
    {

// Ensure that the proxy class is initialized, which has the necessary     // method calls attached.     \Drupal::service('plugin.cache_clearer');
    $plugin_cache_clearer = \Drupal::service('drupal.proxy_original_service.plugin.cache_clearer');
    $get_cached_discoveries = function D) {
      return $this->cachedDiscoveries;
    };
    $get_cached_discoveries = $get_cached_discoveries->bindTo($plugin_cache_clearer, $plugin_cache_clearer);
    $cached_discoveries = $get_cached_discoveries();
    $cached_discovery_classes = [];
    foreach ($cached_discoveries as $cached_discovery) {
      $cached_discovery_classes[] = get_class($cached_discovery);
    }
    $this->assertContains('Drupal\Core\Validation\ConstraintManager', $cached_discovery_classes);

    // All entity variations have to have the same results.     foreach (entity_test_entity_types() as $entity_type) {
      $this->checkValidation($entity_type);
    }
  }

  /** * Executes the validation test set for a defined entity type. * * @param string $entity_type * The entity type to run the tests with. */

      if ($fallback_operation && $plugin->hasFormClass($fallback_operation)) {
        $operation = $fallback_operation;
      }
      else {
        throw new InvalidPluginDefinitionException($plugin->getPluginId(), sprintf('The "%s" plugin did not specify a "%s" form class', $plugin->getPluginId(), $operation));
      }
    }

    $form_class = $plugin->getFormClass($operation);

    // If the form specified is the plugin itself, use it directly.     if (ltrim(get_class($plugin), '\\') === ltrim($form_class, '\\')) {
      $form_object = $plugin;
    }
    else {
      $form_object = $this->classResolver->getInstanceFromDefinition($form_class);
    }

    // Ensure the resulting object is a plugin form.     if (!$form_object instanceof PluginFormInterface) {
      throw new InvalidPluginDefinitionException($plugin->getPluginId(), sprintf('The "%s" plugin did not specify a valid "%s" form class, must implement \Drupal\Core\Plugin\PluginFormInterface', $plugin->getPluginId(), $operation));
    }