Set the data class property.

@since  1.0.0

@return object $data The license data class property.
191539
private function setData() {
		if ( $license = $this->getLicense() ) {
			$data = json_decode(
				openssl_decrypt(
					$license->data,
					$license->cipher,
					$license->key,
					0,
					urldecode( $license->iv )
				)
			);
		}

		return $this->data = $data;
	}
1036680
public function setData(array $data)
    {
        foreach ($data as $key => $val) {
            $setter = $this->setter($key);
            if (is_callable([ $this, $setter ])) {
                $this->{$setter}($val);
            } else {
                $this->{$key} = $val;
            }
        }

        return $this;
    }
921713
private function setData(array $data = null)
    {
        if (null === $data || count($data) === 0) {
            $data = new \stdClass();
        }

        $this->data = $data;

        return $this;
    }
955210
protected function _setData(array $data)
    {
        $pmk = $this->getPrimaryKey();
        if (!empty($data)) {
            if (!isset($data[$pmk]) && !is_null($this->$pmk)) {
                $data[$pmk] = $this->$pmk;
            }
            return $data;
        }
        $columns = Manager::getInstance()->get($this)->getColumns();
        foreach (array_keys($columns) as $property) {
            $key = trim($property, '_');
            if ($key == $pmk && !$this->$pmk) {
                continue;
            }
            $data[$key] = $this->$property;
        }

        return $data;
    }
206374
public function setData($data)
    {
        // setData() expects array, but we can't prevent users from providing other types.
        // So instead of an exception we just want this input filter to be invalid...
        try {
            parent::setData($data);
            $this->invalidData = null;
            $this->invalidDataTypeException = null;
        } catch (InputFilterInvalidArgumentException $e) {
            $this->invalidData = $data;
            $this->invalidDataTypeException = $e;
        }

        return $this;
    }
714477
public function setData($data = [])
    {
        $this->data = $data;
        $this->debug->info(__FUNCTION__, 'setData: ', $this->data);

        return $this;
    }
499944
public function create($data)
    {
        $propertyDescriptor = new PropertyDescriptor();
        $propertyDescriptor->setNamespace(substr((string) $data->getFqsen(), 0, -strlen($data->getName()) - 3));
        $propertyDescriptor->setFullyQualifiedStructuralElementName($data->getFqsen());
        $propertyDescriptor->setName($data->getName());
        $propertyDescriptor->setVisibility((string) $data->getVisibility() ?: 'public');
        $propertyDescriptor->setStatic($data->isStatic());
        $propertyDescriptor->setDefault($data->getDefault());

        $this->assembleDocBlock($data->getDocBlock(), $propertyDescriptor);
        $propertyDescriptor->setLine($data->getLocation()->getLineNumber());

        return $propertyDescriptor;
    }
513234
public function getData() : \stdClass
    {
        $output = new \stdClass();

        foreach ($this->data as $key => $property) {
            if ($this->options['lowercase']) {
                $key = strtolower($key);
            }

            $output->{$key} = $property;
        }

        return $output;
    }
1165428
public function set_data($data) {
        $purpose = $this->get_persistent();

        $count = 0;
        foreach ($this->existingoverrides as $override) {
            $overridedata = $this->convert_existing_data_to_values($override->to_record());
            foreach ($overridedata as $key => $value) {
                $keyname = "roleoverride_{$key}[{$count}]";
                $data->$keyname = $value;
            }
            $count++;
        }

        parent::set_data($data);
    }
456573
public function setRelatedData($data)
    {
        if (is_array($data)) {
            foreach ($data as $count => $event) {
                if (isset($event['remove']) && $event['remove']) {
                    $this->removeOnEvent($event['event']);

                } else {
                    $this->attachOnEvent($event['event'], $event['priority'], $event['propertyset']);
                }
            }
        }

        return $this;
    }
1010641
public function getData() : \stdClass
    {
        $output = new \stdClass();

        $propertyNames = array_keys($this->defaultProperties);
        foreach ($propertyNames as $property) {
            $key = strtolower($property);

            if (array_key_exists($key, $this->data)) {
                $output->{$key} = $this->data[$key];
            } elseif ('parent' !== $key) {
                $output->{$key} = $this->defaultProperties[$property];
            }
        }

        // Don't want to normally do this, just if it exists in the data file
        // for our test runs
        if (array_key_exists('patternid', $this->data)) {
            $output->patternid = $this->data['patternid'];
        }

        return $output;
    }
359564
protected function setData($data = [])
    {
        $defaults = [
            'content'  => '',
            'data'     => null,
        ];

        $this->data = array_merge($defaults, $data);

        return $this;
    }
1123917
protected function setData()
    {
        // If it's already an array of arrays, we're good to go
        if (is_array(reset($this->data))) {
            return $this->setArrayOfArraysData();
        }

        $column_width = $this->getColumnWidth($this->data);
        $row_count    = $this->getMaxRows($column_width);

        return array_chunk($this->data, $row_count);
    }
955543
public function setData(array $data)
    {
        parent::setData($data);

        if (isset($data['page'])) {
            $this->setPage($data['page']);
        }

        if (isset($data['per_page'])) {
            $this->setNumPerPage($data['per_page']);
        }

        if (isset($data['num_per_page'])) {
            $this->setNumPerPage($data['num_per_page']);
        }

        return $this;
    }
114720
private function fromStdObject(\stdClass $data, $class)
    {
        $reflection   = $this->getReflection($class);
        $object       = $this->getClassInstance($data, $reflection);
        $map          = $this->getPropertyMap($class);
        $this->handleAssociations($data, $object, $reflection, $map['associations'], $map['meta']);
        $this->handleProperties($data, $object, $reflection, $map['fields']);

        return $object;
    }
1111440
public function setData($Data)
    {
        if (! is_object($Data) || ! $Data instanceof Data) {
            throw new \InvalidArgumentException(
                'The Data Interface must be a valid Data Object'
            );
        }
        $this->Data = $Data;

        return true;
    }
1293627
public function getDataType()
    {
        if (!is_array($this->dataType)) {
            $dataType = get_class($this->dataType);

            return new $dataType();
        }

        return $this->dataType;
    }