/**
* Unserialize the given data
*
* @param string $string
* @throws \Cundd\PersistentObjectStore\Serializer\Exception if the data could not be unserialized
* @return mixed
*/
public function unserialize($string)
{
$data = parent::unserialize($string);
if ($data === NULL) {
return NULL;
}
$databaseIdentifier = ObjectUtility::valueForKeyPathOfObject(Constants::DATA_META_KEY . '.' . Constants::DATA_DATABASE_KEY, $data, '');
if ($databaseIdentifier) {
GeneralUtility::assertDatabaseIdentifier($databaseIdentifier);
}
return new Document($data, $databaseIdentifier);
}
/**
* Returns the configuration for the given key path
*
* @param string $keyPath
* @return mixed
*/
public function getConfigurationForKeyPath($keyPath)
{
return ObjectUtility::valueForKeyPathOfObject($keyPath, $this->configuration);
}
/**
* Sort the collection of objects by the given key
*
* @param Database|\Iterator|array $collection
* @param string $keyPath
* @param bool $descending
* @return SortResult
*/
public function sortCollectionByPropertyKeyPath($collection, $keyPath, $descending = FALSE)
{
$packedObjectsKey = 'objects';
$resultArray = array();
if (is_array($collection)) {
$dataCollectionRaw = SplFixedArray::fromArray($collection);
} else {
if ($collection instanceof SplFixedArray) {
$dataCollectionRaw = $collection;
} else {
if ($collection instanceof Database) {
// $dataCollectionRaw = $collection->getRawData();
$dataCollectionRaw = $collection->toFixedArray();
} else {
$dataCollectionRaw = SplFixedArray::fromArray(iterator_to_array($collection));
}
}
}
$dataCollectionCount = $dataCollectionRaw->getSize();
// Pack the objects grouped by the property value
$i = 0;
while ($i < $dataCollectionCount) {
$item = $dataCollectionRaw[$i];
// Fetch to property value
if ($item instanceof KeyValueCodingInterface) {
$propertyValue = $item->valueForKeyPath($keyPath);
} else {
$propertyValue = ObjectUtility::valueForKeyPathOfObject($keyPath, $item);
}
// Prepare the packed result array
if (is_float($propertyValue)) {
$propertyValue .= '';
} else {
if ($propertyValue !== NULL && !is_scalar($propertyValue)) {
throw new SortingException(sprintf('Could not sort by property key path %s, because one value is of type %s', $keyPath, gettype($propertyValue)), 1412021636);
}
}
if (!isset($resultArray[$propertyValue])) {
$resultArray[$propertyValue] = array($packedObjectsKey => array());
}
$resultArray[$propertyValue][$packedObjectsKey][] = $item;
$i++;
}
// Sort the objects
if (!$descending) {
$result = ksort($resultArray, $this->sortFlags);
} else {
$result = krsort($resultArray, $this->sortFlags);
}
if (!$result) {
throw new SortingException('Could not sort the database', 1412021636);
}
// Unpack the objects
$i = 0;
$j = 0;
$resultFixedArray = new SortResult($dataCollectionCount);
$resultArray = SplFixedArray::fromArray(array_values($resultArray));
$resultArrayCount = $resultArray->count();
while ($i < $resultArrayCount) {
$packedObjects = $resultArray[$i][$packedObjectsKey];
$item = current($packedObjects);
do {
$resultFixedArray[$j] = $item;
$j++;
} while ($item = next($packedObjects));
$i++;
}
if ($j != $dataCollectionCount) {
throw new SortingException(sprintf('Number of result items does not match the number of input items (%d/%d)', $j, $dataCollectionCount), 1412243235);
}
return $resultFixedArray;
}
/**
* Removes the given entry in the Index
*
* @param DocumentInterface|array $document
* @return $this
*/
public function deleteEntry($document)
{
$key = ObjectUtility::valueForKeyPathOfObject($this->getProperty(), $document);
if (!isset($this->map[$key])) {
throw new InvalidEntryException(sprintf('Entry \'%s\' not found to delete', $key), 1415047176);
}
unset($this->map[$key]);
return $this;
}
/**
* Returns the value for the given key path from the data
*
* @param string $keyPath
* @return mixed
*/
public function valueForKeyPath($keyPath)
{
if (!strpos($keyPath, '.')) {
return $this->valueForKey($keyPath);
}
return ObjectUtility::valueForKeyPathOfObject($keyPath, $this->getData());
}
/**
* Performs the comparison against the given test value
*
* @param mixed $testValue
* @return bool
*/
public function perform($testValue)
{
if ($testValue instanceof KeyValueCodingInterface) {
// $testValue = $testValue->getData();
$propertyValue = $testValue->valueForKeyPath($this->property);
// $propertyValue = $testValue->valueForKeyPath($this->getProperty());
} else {
$propertyValue = ObjectUtility::valueForKeyPathOfObject($this->property, $testValue);
// $propertyValue = ObjectUtility::valueForKeyPathOfObject($this->getProperty(), $testValue);
}
$operator = $this->getOperator();
switch ($operator) {
case PropertyComparisonInterface::TYPE_EQUAL_TO:
return $propertyValue === $this->getValue();
case PropertyComparisonInterface::TYPE_NOT_EQUAL_TO:
return $propertyValue !== $this->getValue();
case PropertyComparisonInterface::TYPE_LESS_THAN:
return $propertyValue < $this->getValue();
case PropertyComparisonInterface::TYPE_LESS_THAN_OR_EQUAL_TO:
return $propertyValue <= $this->getValue();
case PropertyComparisonInterface::TYPE_GREATER_THAN:
return $propertyValue > $this->getValue();
case PropertyComparisonInterface::TYPE_GREATER_THAN_OR_EQUAL_TO:
return $propertyValue >= $this->getValue();
case PropertyComparisonInterface::TYPE_LIKE:
return $this->performLike($propertyValue, $this->getValue());
case PropertyComparisonInterface::TYPE_CONTAINS:
return $this->performContains($propertyValue, $this->getValue());
case PropertyComparisonInterface::TYPE_IN:
return $this->performContains($this->getValue(), $propertyValue);
case PropertyComparisonInterface::TYPE_AND:
case PropertyComparisonInterface::TYPE_OR:
return $this->performLogical($testValue, $this->getOperator());
case PropertyComparisonInterface::TYPE_IS_NULL:
return is_null($propertyValue);
case PropertyComparisonInterface::TYPE_IS_EMPTY:
return !$propertyValue;
}
return FALSE;
}
