Hydrate the public properties

@param $data
12707
public function hydrate($data)
  {
    parent::hydrate($data);
    $this->values = ValueAs::arr($this->values);
  }
1242834
public function setData($data)
	{
		if( is_null($data) )
		{
			$data = new stdClass();
		}

		if( $data instanceof stdClass )
		{
			$this->data = $data;
		}
		else
		{
			$this->data = (object) $data;
		}
		
		$this->id = $this->data->{$this->idKey};
		$this->type = $this->data->{$this->typeKey};

		$dataVars = get_object_vars($this->data);
		foreach ($this->guarded as $guardedProperty)
		{
			if( array_key_exists($guardedProperty, $dataVars) )
			{
				$this->protected[$guardedProperty] = $this->data->$guardedProperty;
				unset($this->data->$guardedProperty);
			}
		}
	}
352326
public function hydrate(array $data, $object)
    {
        if (is_object($object)) {
            $hydrator = $this->getHydrator(get_class($object));
        } else {
            $hydrator = $this->getHydrator($object);
            $object = $hydrator->createEmptyInstance($object, $data);
        }

        return $hydrator->hydrate($data, $object);
    }
783082
public function hydrate( array $data, $object )
    {
        $type = $object->paragraph->type;

        if ( isset( $data['paragraph-' . $type] ) )
        {
            $this->getParagraphMapper()
                 ->hydrate( (array) $data['paragraph-' . $type],
                            $object->paragraph );
        }

        $propertyHydrator = $this->getHydrateSimpleProperties();

        foreach ( $object->rules as $key => $rule )
        {
            if ( isset( $data['customize-' . $key] ) )
            {
                $ruleData = array(
                    'properties' => (array) $data['customize-' . $key],
                );

                $propertyHydrator->hydrate( $ruleData, $rule );
            }
        }

        return $object;
    }
109358
private function hydrateDataObject($data)
    {
        $dataObject = new MetadataDataObjectOracle(
            new MetaDataColumnCollection(),
            new MetaDataRelationCollection()
        );

        $tableName = $data['TABLE_NAME'];
        $owner     = $data['OWNER'];

        $dataObject->setName($owner . '/' . $tableName);
        $columnDataObject = new MetaDataColumn();

        $statement = $this->pdo->prepare(
            sprintf(
                "SELECT COLUMN_NAME as name, NULLABLE as  nullable, DATA_TYPE as type, DATA_LENGTH as length
                FROM SYS.ALL_TAB_COLUMNS
                WHERE TABLE_NAME = '%s' and OWNER= '%s'",
                $tableName,
                $owner
            )
        );
        $statement->execute(array());

        $allFields   = $statement->fetchAll(PDO::FETCH_ASSOC);
        $identifiers = $this->getIdentifiers($owner, $tableName);

        foreach ($allFields as $metadata) {
            $column = clone $columnDataObject;

            $type = $metadata['type'];

            if (isset($this->typeConversion[$type]) === true) {
                $type = $this->typeConversion[$type];
            }

            $column->setName($metadata['name'])
                   ->setType($type)
                   ->setLength(
                       isset($metadata['length']) === true ?
                       $metadata['length'] :
                       null
                   );
            if (in_array($metadata['name'], $identifiers) === true) {
                $column->setPrimaryKey(true);
            }

            $dataObject->appendColumn($column);
        }

        return $dataObject;
    }
757518
public function hydrate(array $data, $object)
    {
        if (isset($data['name'])) {
            $object->setName($data['name']);
        }
        if (isset($data['facts_timestamp'])) {
            $object->setReportedAt(new \DateTime($data['facts_timestamp']));
        }
        return $object;
    }
867467
protected function processProperties($data)
    {

        // Will hold the properties we are sending back
        $properties = [];

        // All of these are split on space
        $items = explode(' ', $data);

        // Iterate over the items
        foreach ($items as $item) {
            // Explode and make sure we always have 2 items in the array
            list($key, $value) = array_pad(explode('=', $item, 2), 2, '');

            // Convert spaces and other character changes
            $properties[$key] = utf8_encode(str_replace(
                [
                    '\\s', // Translate spaces
                ],
                [
                    ' ',
                ],
                $value
            ));
        }

        return $properties;
    }
971054
public function hydrate(array $data): void
    {
        if (!$data) {
            return;
        }

        if ($this->hydrationProperties === null || $this->hydrationSetters === null) {
            $reflection = new \ReflectionClass($this);
            $this->hydrationProperties = array_map(function ($v) {
                return $v->name;
            }, $reflection->getProperties(\ReflectionProperty::IS_PUBLIC));

            $this->hydrationSetters = array_filter(array_map(function ($v) {
                return strpos($v->name, 'set') === 0 ? $v->name : null;
            }, $reflection->getMethods(\ReflectionMethod::IS_PUBLIC)));
        }

        $camelCaseConvert = function ($v) {
            if (strpos($v, '_') === false) {
                return $v;
            }

            $v = explode('_', $v);

            $first = array_shift($v);
            $v = array_map('ucfirst', $v);

            return $first . implode('', $v);
        };

        foreach ($data as $key => $value) {
            if (in_array($key, $this->hydrationProperties, true)) {
                $this->{$key} = $value;
            } else {
                $camelCaseKey = $camelCaseConvert($key);
                $setter = 'set' . ucfirst($camelCaseKey);

                if ($camelCaseKey !== $key && in_array($camelCaseKey, $this->hydrationProperties, true)) {
                    $this->{$camelCaseKey} = $value;
                } elseif (in_array($setter, $this->hydrationSetters, true)) {
                    $this->$setter($value);
                } else {
                    throw new \OutOfBoundsException(sprintf(
                        'Invalid attribute provided "%s"',
                        $key
                    ));
                }
            }
        }
    }
115814
public function importProperties($data)
    {
        $data->each(function ($value, $key) {
            $key = camel_case($key);

            if (! property_exists($this, $key)) {
                $this->$key = $value;
            }
        });
    }
686367
public function hydrate(array $data, $object)
    {
        if (!$object instanceof SecretQuestion) {
            throw new \Exception('$object must be an instance of SecretQuestion');
        }

        return parent::hydrate($data, $object);
    }
1238494
public function hydrate(array $data, $object)
    {
        if (!$object instanceof User) {
            throw new \Exception('$object must be an instance of User');
        }

        return parent::hydrate($data, $object);
    }
179683
public function hydrate(array $data, $object)
    {
        if (!$object instanceof TicketSubject) {
            throw new \InvalidArgumentException('$object must be an instance of TicketSubject');
        }

        return parent::hydrate($data, $object);
    }
194155
public function hydrate(AbstractModel $object, $data = [])
    {
        if (!empty($data)) {
            foreach ($data as $k => $v) {

                if (in_array($k, $object::$properties)) {

                    $method = $this->camelize(
                        sprintf('set_%s', $k)
                    );

                    if (!is_callable([$object, $method])) {
                        throw new RuntimeException(sprintf(
                            'Trying to call method "%s" on "%s" but it does not exist or is private.',
                            $method,
                            get_class($object)
                        ));
                    } else {
                        $object->$method($v);
                    }
                }
            }
        }

        return $object;
    }
1021143
public function hydrate($object, $data)
    {
        if (is_array($data)) {
            foreach ($data as $key => $value) {
                // Check setMethod
                if (!$this->callSetter($object, $this->toCamelCase($key), $value)) {
                    // If no setter is defined, we reinject into array
                    $data[$key] = $value; // Change data with subObject
                }
            }
        }

        return $object;
    }
86618
public function update($data)
    {
        if (count($this) == 0) {
            return;
        }
        $ids = $this->getPrimaryKeyList();
        $updater = new $this->className();
        $updater->in($updater->getPrimaryKey(), $ids)->update($data);
    }
606782
public function hydrate($value, $data = [])
    {
        // Search for defined configuration key in DB
        $findKey = $this->objectManager->getRepository(get_class($value))->findOneBy([
            'section' => $value->getSection(),
            'option' => $value->getOption()
        ]);

        // If key exists, update it
        if ($findKey instanceof AppConfigEntity) {
            $findKey->setValue($value->getValue());
            $value = $findKey;
        }

        return $value;
    }
1321723
public function hydrate(array $data, $object)
    {
        parent::hydrate($data, $object);

        foreach ($this->getFreeValuesKeys() as $key) {
            if (isset($data[$key])) {
                $object->set($key, $data[$key]);
            }
        }

        return $object;
    }