Gets the entityType value for this ChangeHistoryValue.

@return entityType
334903
public com.google.api.ads.admanager.axis.v201808.ChangeHistoryEntityType getEntityType() {
        return entityType;
    }
274902
public function getLoggerEntityStorage() {
    // TODO: Delete this, after deprecated 'logger_entity' deleting
    // and create instance in __construct.
    if ($this->loggerEntityStorage) {
      return $this->loggerEntityStorage;
    }

    $this->loggerEntityStorage = $this->entityTypeManager
      ->getStorage($this->getLoggerEntityTypeName());
    return $this->loggerEntityStorage;
  }
1320780
protected function getHistoryRoute(EntityTypeInterface $entity_type) {
    if ($entity_type->hasLinkTemplate('version-history')) {
      $route = new Route($entity_type->getLinkTemplate('version-history'));
      $route
        ->setDefaults([
          '_title' => "{$entity_type->getLabel()} revisions",
          '_controller' => '\Drupal\openy_upgrade_tool\Controller\OpenyUpgradeLogController::revisionOverview',
        ])
        ->setRequirement('_permission', 'access openy upgrade log revisions')
        ->setOption('_admin_route', TRUE);

      return $route;
    }
  }
155502
public function getHistory()
    {
        $dqb = $this->_em->createQueryBuilder();
        $dqb->select(array('j'))
            ->from('PlaygroundCore\Entity\Cronjob', 'j')
            ->where($dqb->expr()->in('j.status', array(
                self::STATUS_SUCCESS, self::STATUS_MISSED, self::STATUS_ERROR,
            )))
            ->orderBy('j.scheduleTime', 'ASC');

        return $dqb->getQuery()->getResult();
    }
945741
@Override
  public Integer getCamundaHistoryTimeToLive() {
    String ttl = getCamundaHistoryTimeToLiveString();

    if (ttl != null) {
      return Integer.valueOf(ttl);
    }
    return null;
  }
213898
public com.google.api.ChangeType getChangeType() {
    @SuppressWarnings("deprecation")
    com.google.api.ChangeType result = com.google.api.ChangeType.valueOf(changeType_);
    return result == null ? com.google.api.ChangeType.UNRECOGNIZED : result;
  }
183265
public function revisionEntityAction()
    {
        $this->mapAllAuditedClasses();

        $page = (int)$this->getEvent()->getRouteMatch()->getParam('page');
        $revisionEntityId = (int) $this->getEvent()->getRouteMatch()->getParam('revisionEntityId');

        $revisionEntity = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager()
            ->getRepository('SoliantEntityAudit\\Entity\\RevisionEntity')->find($revisionEntityId);

        if (!$revisionEntity)
            return $this->plugin('redirect')->toRoute('audit');

        $repository = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager()
            ->getRepository('SoliantEntityAudit\\Entity\\RevisionEntity');

        return array(
            'page' => $page,
            'revisionEntity' => $revisionEntity,
            'auditService' => $this->getServiceLocator()->get('auditService'),
        );
    }
653070
public function getDbValue()
    {
        $value = $this->getValue();
        if (is_null($value)) {
            // Process default value
            $value = $this->getDefaultValue();
            if ($this->isInstanceOf($value, AbstractEntity::class)) {
                if (!$value->exists()) {
                    $value->save();
                }

                $value = $value->id;
            }

            return $this->processToDbValue($value);
        }

        // Save if new or if updating is allowed
        if (!$value->exists() || $this->getUpdateExisting()) {
            $value->save();
        }

        return $this->processToDbValue($value->id);
    }
1287836
public function getEntityName()
    {
        if (null == $this->entityName) {
            $this->setEntityName(get_class($this->getEntity()));
        }
        return $this->entityName;
    }
985694
def entity_data(self, entity_type, entity_id, history_index):
        
        return self.entity_history(entity_type, entity_id)[history_index]
95730
protected function whatToDoWithEntity(): int
    {
        $this->checkEntityIsInConfig();

        $entityConfig = $this->configEntities[$this->entity];

        $actions = 0;
        if (array_key_exists('cols', $entityConfig)) {
            switch ($entityConfig['action']) {
                case 'update':
                    $actions |= self::UPDATE_TABLE;
                    break;
                case 'insert':
                    $actions |= self::INSERT_TABLE;
                    break;
            }
        }

        return $actions;
    }
1019503
public BaseField getHistorySourceDate()
    {
        if (m_fldSourceHistoryDate == null)
        {
            if (m_iSourceDateSeq != null)
                m_fldSourceHistoryDate = this.getOwner().getField(m_iSourceDateSeq);
            else if (this.getHistoryRecord() instanceof VirtualRecord)
                m_fldSourceHistoryDate = this.getOwner().getField(VirtualRecord.LAST_CHANGED);
        }
        return m_fldSourceHistoryDate;
    }
452377
public function getChangeType()
    {
        if (!class_exists($this->ObjectClass)) {
            throw new UnexpectedDataException("Invalid Class '{$this->ObjectClass}' in ChangeSetItem #{$this->ID}");
        }

        // Unversioned classes have no change type
        if (!$this->isVersioned()) {
            return self::CHANGE_NONE;
        }

        // Get change versions
        if ($this->VersionBefore || $this->VersionAfter) {
            $draftVersion = $this->VersionAfter; // After publishing draft was written to stage
            $liveVersion = $this->VersionBefore; // The live version before the publish
        } else {
            $draftVersion = Versioned::get_versionnumber_by_stage(
                $this->ObjectClass,
                Versioned::DRAFT,
                $this->ObjectID,
                false
            );
            $liveVersion = Versioned::get_versionnumber_by_stage(
                $this->ObjectClass,
                Versioned::LIVE,
                $this->ObjectID,
                false
            );
        }

        // Version comparisons
        if ($draftVersion == $liveVersion) {
            $type = self::CHANGE_NONE;
        } elseif (!$liveVersion) {
            $type = self::CHANGE_CREATED;
        } elseif (!$draftVersion) {
            $type = self::CHANGE_DELETED;
        } else {
            $type = self::CHANGE_MODIFIED;
        }
        $this->extend('updateChangeType', $type, $draftVersion, $liveVersion);
        return $type;
    }
338629
public function getPersistence()
    {
        if (null === $this->persistence) {
            $this->persistence = (isset($this->options['persistence']) && $this->options['persistence'] == true);
        }
        
        return $this->persistence;
    }
1168818
public static CmsEntity getEntity() {

        if ((INSTANCE == null) || (INSTANCE.m_entityObserver == null)) {
            CmsDebugLog.getInstance().printLine("handling external registration");
            if (isObserverExported()) {
                return CmsEntityBackend.createFromNativeWrapper(nativeGetEntity());
            } else {
                throw new RuntimeException("Editor is not initialized yet.");
            }
        } else {
            return INSTANCE.getCurrentEntity();
        }
    }
933784
public function getEntity()
    {

        // primary key only
        $references = $this->getReferences();

        // debug // print_r( $references->map(function($e){ return $e->get('fullyQualifiedName');}) );
        foreach( $references as $reference ) {

            // only manage references where the reference column is the primary key
            if( $reference->isPrimaryKey() ) {
                return array(
                    'entity' => 'normality',
                    'normality' => $reference->getRelation()->getEntityName(),
                );
            }

        }

        // datatypes we understand and have defined objects for
        // have a helper method in Entity::staticHelper
        switch( $this->getType()->name ) {

            case 'StockState':

                return array (
                    'entity' => 'StockState',
                );

            case 'hstore':

                return array(
                    'entity' => 'Hstore',
                );

            case 'json':

                return array(
                    'entity' => 'Json',
                );

            case 'inet':

                return array(
                    'entity' => 'Inet',
                );

            case 'timestamp':

                return array(
                    'entity' => 'DateTime',
                );

            case 'tsrange':

                return array(
                    'entity' => 'DateRange',
                );

            case 'oid':

                return array(
                    'entity' => 'PgLargeObject',
                );

        }

        return array();

    }
562644
public function getCurrentType()
    {
        if (null !== $index = $this->getCurrencyIndex()) {
            return $index->getType();
        }

        $types = $this->repository->listIndexableEntityTypes();
        $type = array_shift($types);

        return $type;
    }