Bind the data into this object.

@param   mixed   $values       The data array or object.
@param   boolean $replaceNulls Replace null or not.

@return  static Return self to support chaining.
190087
public function bind($values, $replaceNulls = false)
    {
        if ($values === null) {
            return $this;
        }

        // Check properties type.
        if (!is_array($values) && !is_object($values)) {
            throw new \InvalidArgumentException(sprintf('Please bind array or object, %s given.', gettype($values)));
        }

        // If is Traversable, get iterator.
        if ($values instanceof \Traversable) {
            $values = iterator_to_array($values);
        } elseif (is_object($values)) {
            // If is object, convert it to array
            $values = get_object_vars($values);
        }

        // Bind the properties.
        foreach ($values as $field => $value) {
            // Check if the value is null and should be bound.
            if ($value === null && !$replaceNulls) {
                continue;
            }

            // Set the property.
            $this->offsetSet($field, $value);
        }

        return $this;
    }
844181
public function loadValues(array $values)
    {
        foreach ($values as $name => $value) {
            $argument = $this->getArgument($name, static::MODE_RETURN_NULL);

            if (null !== $argument) {
                $argument->setValue($value);
            }
        }

        return $this;
    }
1070273
public function forceUpdate(array $values)
    {
        $dao = $this->getEntityDao();

        $dao->setValues($values);

        $dao->update();

        return $this;
    }
1236782
private function setValues($values)
    {
        if (! empty($values)) {
            if ($this->canHaveMultipleValues()) {
                $this->addValues($values);
            } elseif ($this->canHaveValue()) {
                $this->addValue($values);
            }
        }

        return $this;
    }
1264500
public function setValues($values)
    {
        if (!$this->rows) {
            throw new \Exception('You must setRows() before setValues');
        }
        $this->values = $values;

        $valueCount = count($values);
        $fieldCount = count($this->rows);

        // Build the Placeholder String
        $placeholders = [];
        for ($i = 0; $i < $valueCount; $i++) {
            $placeholders[] = '(' . rtrim(str_repeat('?,', $fieldCount), ',') . ')';
        }
        $this->bindString = implode(',', $placeholders);

        // Build the Flat Value Array
        $valueList = [];
        foreach ($values as $value) {
            if (is_array($value)) {
                foreach ($value as $v) {
                    $valueList[] = $v;
                }
            } else {
                $valueList[] = $values;
            }
        }
        $this->valuesFlattened = $valueList;
        unset($valueList);

        return $this;
    }
1094611
public function unshift(...$values)
    {
        $this->forceCollection();
        $values = array_map([$this, 'unbox'], $values);
        array_unshift($this->data, ...$values);

        return $this;
    }
1369751
public function bind($key, $value = null)
    {
        $data = $key;

        if (!is_array($key)) {
            $data = array($key => $value);
        }

        foreach ($data as $key => $value) {
            $this->binds[$key] = $value;
        }

        return $this;
    }
414132
public function execute($values=null)
    {
        $ok = false;
        set_error_handler(array($this->_pdooci,"errorHandler"));
        try {
            $auto = $this->_pdooci->getAutoCommit() ? \OCI_COMMIT_ON_SUCCESS : \OCI_NO_AUTO_COMMIT;

            if ($values && sizeof($values)>0) {
                foreach ($values as $key => $val) {
                    $parm = $key;
                    if (preg_match('/^\d+$/', $key)) {
                        $parm ++;
                    }
                    $this->bindParam($parm, $values[$key]);
                    $this->_pdooci->setError();
                }
            }
            $ok = \oci_execute($this->_stmt, $auto);
            if (!$ok) {
                $this->_pdooci->setError($this->_stmt);
                $error = $this->_pdooci->errorInfo();
                throw new \PDOException($error[2]);
            } else {
                if (count($this->_bindsLob)) {
                    foreach ($this->_bindsLob as $param => $bind) {
                        $ok = $bind['lob']->save($bind['value']);
                        if (!$ok) {
                            $error = $this->_pdooci->errorInfo();
                            $e = new \PDOException($error[2], $error[1]);
                            $e->errorInfo = $error;
                            throw $e;
                        }
                    }
                }
            }
        } catch (\PDOException $e) {
            throw $e;
        } catch (\Exception $e) {
            throw new \PDOException($e->getMessage());
        }
        restore_error_handler();
        return $ok;
    }
391498
protected function filterNullValues(array $values)
    {
        $result = array_filter(
            $values,
            function($val) {
                return $val || 0 === $val || false === $val;
            }
        );

        return $result;
    }
1243862
private function bindValues(array $values)
    {
        $this->bindedParameters = array();
        $this->bindedTypes = array();
        $this->bindedValues = array();

        foreach ($values as $parameter => $value) {
            if (is_int($parameter)) {
                $parameter++;
            }

            $this->bindValue($parameter, $value);
        }
    }
1371186
protected function setEmptyNullablesToNull(array $values): array
	{
		$nullables = $this->getNullableColumns();

		foreach($values as $column => $value)
		{
			if($value === '' && in_array($column, $nullables))
			{
				$values[$column] = null;
			}
		}

		return $values;
	}
199598
public function unshift(...$values): Sequence
    {
        $this->resolver->values(function (\DS\Map $values): void {
            $this->items->unshift(...$values->values());
        }, $values);

        return $this;
    }
813599
public function push(...$values)
    {
        foreach ($values as $value) {
            $this->offsetSet(null, $value);
        }

        return $this;
    }
890369
public function setValue($values = [])
    {
        $this->initializeElements();

        foreach ($this->getElements() as $element) {
            $element->setValue(false);
        }

        if ($values instanceof Collection) {
            foreach ($values as $value) {
                $id = $value->getId();
                $this->getElement($id)->setValue(true);
            }
        } else {
            foreach ((array)$values as $key => $value) {
                $this->getElement($key)->setValue(true);
            }
        }

        return $this;
    }
1097186
public function setValuesRaw($values = array())
    {
        foreach ($values as $key => $value) {
            $this->setRaw($key, $value);
        }

        return $this;
    }
298657
public function setValues(array $values)
    {
        $this->getValidator()->validateRequired($values, $this->required);
        $this->values = array_merge($this->values, $values);
        
        return $this;
    }
835858
public function setValues(array $values = array(), $ignore_unknown = false)
    {
        foreach ($values as $name => $value) {
            try {
                $this->getRow($name)->setValue($value);
            } catch (\InvalidArgumentException $e) {
                if (!$ignore_unknown) {
                    throw $e;
                }
            }
        }

        return $this;
    }