Returns the class used to hydrate rows for this table.

@return string
769103
public function getEntityClass()
    {
        if (!$this->_entityClass) {
            $default = Entity::class;
            $self = get_called_class();
            $parts = explode('\\', $self);

            if ($self === __CLASS__ || count($parts) < 3) {
                return $this->_entityClass = $default;
            }

            $alias = Inflector::classify(Inflector::underscore(substr(array_pop($parts), 0, -5)));
            $name = implode('\\', array_slice($parts, 0, -1)) . '\\Entity\\' . $alias;
            if (!class_exists($name)) {
                return $this->_entityClass = $default;
            }

            $class = App::className($name, 'Model/Entity');
            if (!$class) {
                throw new MissingEntityException([$name]);
            }

            $this->_entityClass = $class;
        }

        return $this->_entityClass;
    }
231432
public function getClasses()
    {
        $classes = $this->getAttribute("class");
        return (strlen($classes) > 0) ? trim($this->removeMultipleSpaces($classes)) : "";
    }
761513
public function classIsContainer()
    {
        if ( $this->ClassIsContainer === null )
        {
            $object = $this->object();
            $class = $object->contentClass();
            $this->ClassIsContainer = $class->attribute( 'is_container' );
        }
        return $this->ClassIsContainer;
    }
1316495
public function getHydrator()
    {
        if ($this->hydrator) {
            return $this->hydrator;
        }
        return $this->hydrator = new Hydrator($this->metaCacheDir, $this->metaDirs);
    }
542890
public function getParentClass()
    {
        $parentClass = $this->getBehaviorContent('parentClass');
        return null === $parentClass ? ($this->getTable()->getBaseQueryClass() != "" ? $this->getTable()->getBaseQueryClass() : 'ModelCriteria') : $parentClass;
    }
127143
protected function hydrate()
    {
        $properties = $this->propertiesFromAttributes() + $this->unmanagedProperties;

        $attributesName = $this->entityMap->getAttributesArrayName();

        if (isset($properties[$attributesName])) {
            $properties[$attributesName] = $this->entityMap->getAttributeNamesFromColumns($properties[$attributesName]);
        } else {
            $properties[$attributesName] = $this->entityMap->getAttributeNamesFromColumns($properties);
        }

        // In some case, attributes will miss some properties, so we'll just complete the hydration
        // set with the original object properties
        $missingProperties = array_diff_key($this->properties, $properties);

        foreach (array_keys($missingProperties) as $missingKey) {
            $properties[$missingKey] = $this->properties[$missingKey];
        }

        $this->hydrator->hydrate($properties, $this->entity);

        $this->touched = false;
    }
305510
public static function hydrate(stdClass $patch)
    {
        $hydrated = new PatchEntity();

        if (isset($patch->id)) {
            $hydrated->setId($patch->id);
        }

        if (isset($patch->description)) {
            $hydrated->setDescription($patch->description);
        }

        if (isset($patch->examples) && is_array($patch->examples)) {
            $hydrated->setExamples($patch->examples);
        }

        if (isset($patch->type)) {
            $hydrated->setType(TypeHydrator::hydrate($patch->type));
        }

        if (isset($patch->language)) {
            $hydrated->setLanguage(LanguageHydrator::hydrate($patch->language));
        }

        if (isset($patch->parent)) {
            $hydrated->setParent(PatchHydrator::hydrate($patch->parent));
        }

        return $hydrated;
    }
763178
protected function createClass()
	{
		$cols = $this->numOfColumns;
		if ($cols === self::COLUMNS_NONE) {
			return 'col';
		} elseif ($cols === self::COLUMNS_AUTO) {
			return 'col-auto';
		} else {
			// number
			if ($this->row->gridBreakPoint != NULL) {
				return 'col-' . $this->row->gridBreakPoint . '-' . $this->numOfColumns;
			} else {
				return 'col-' . $this->numOfColumns;
			}
		}
	}
1150325
public function hydrate($row)
    {
        $class = $this->_class;
        $ret = $class::fromArray($this->unmarshal($row));
        $ret->events()->trigger('afterHydrate', $ret);

        return $ret;
    }
1366737
public function getModelClass()
    {
        $map = config('db-exporter.model.map');

        $namespace = config('db-exporter.model.namespace');
        $class     = snake_case($this->getTable()->getTableName());

        foreach ($map as $item) {
            // Find matching table name
            $tablePattern = '/' . str_replace('/', '\/', $item['tablePattern']) . '/';
            if (preg_match($tablePattern, $this->table->getTableName()) === 1) {

                $namespace = $item['namespace'];

                if ($item['className'] !== null) {
                    $pattern     = '/' . str_replace('/', '\/', $item['className']['pattern']) . '/';
                    $replacement = $item['className']['replacement'];
                    echo $replacement;
                    $class = preg_replace($pattern, $replacement, $class);
                }
                break;
            }
        }

        return $namespace . '\\' . studly_case(str_singular($class));
    }
477797
protected function getStyleClass()
    {
        $classes = array_merge([
            $this->getBaseStyleClass(),
            $this->getSize(),
            $this->getColor(),
        ], $this->extraClass);

        return implode(' ', array_filter(array_unique($classes, SORT_STRING)));
    }
817258
public function getIdentClass_v2() {
		$class = new StdClass;
		$class->surname = $this->getLastName();
		$class->givenName = $this->getFirstName();
		$class->dateOfBirth = $this->getBirthday();
		$class->minimumAge = $this->getMinimumAge();

		return $class;
	}
466207
protected function getHydrationCacheId()
    {
        $parameters = array();

        foreach ($this->getParameters() as $parameter) {
            $parameters[$parameter->getName()] = $this->processParameterValue($parameter->getValue());
        }

        $sql                    = $this->getSQL();
        $queryCacheProfile      = $this->getHydrationCacheProfile();
        $hints                  = $this->getHints();
        $hints['hydrationMode'] = $this->getHydrationMode();

        ksort($hints);

        return $queryCacheProfile->generateCacheKeys($sql, $parameters, $hints);
    }
564362
public static function hydrate(stdClass $sink)
    {
        $hydrated = new SinkEntity();

        if (isset($sink->id)) {
            $hydrated->setId($sink->id);
        }

        if (isset($sink->line)) {
            $hydrated->setLine($sink->line);
        }

        if (isset($sink->start_line)) {
            $hydrated->setStartLine($sink->start_line);
        }

        if (isset($sink->end_line)) {
            $hydrated->setEndLine($sink->end_line);
        }

        if (isset($sink->name)) {
            $hydrated->setName($sink->name);
        }

        if (isset($sink->file)) {
            $hydrated->setFile(FileHydrator::hydrate($sink->file));
        }

        if (isset($sink->function)) {
            $hydrated->setFunction(CustomFunctionHydrator::hydrate($sink->function));
        }

        if (isset($sink->class)) {
            $hydrated->setClass(CustomClassHydrator::hydrate($sink->class));
        }

        if (isset($sink->start_column)) {
            $hydrated->setStartColumn($sink->start_column);
        }

        if (isset($sink->end_column)) {
            $hydrated->setEndColumn($sink->end_column);
        }

        if (isset($sink->type)) {
            $hydrated->setType(TypeHydrator::hydrate($sink->type));
        }

        if (isset($sink->taint)) {
            $hydrated->setTaint(TaintHydrator::hydrate($sink->taint));
        }

        return $hydrated;
    }
232736
public function getDeclaringClass()
    {
        if (is_array($this->routineName) === false) {
            return null;
        }
        
        $refClass     = parent::getDeclaringClass();
        $moufRefClass = new MoufReflectionClass($refClass->getName());
        return $moufRefClass;
    }
1020040
public function getClassName()
    {
        return ($this->tableName() === null) ? self::pluralize(self::stripclassName()) : $this->tableName();
    }
989612
public function getHydratorFor($objectClass)
    {
        if (! isset($this->hydratorInstances[$objectClass])) {

            $this->hydratorInstances[$objectClass] = $this->createHydratorFor($objectClass);
        }

        return $this->hydratorInstances[$objectClass];
    }