PHP FlowQuery::getContext方法代码示例

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation
  * @return void
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     $output = array();
     $outputNodePaths = array();
     $until = array();
     foreach ($flowQuery->getContext() as $contextNode) {
         $prevNodes = $this->getPrevForNode($contextNode);
         if (isset($arguments[0]) && !empty($arguments[0])) {
             $untilQuery = new FlowQuery($prevNodes);
             $untilQuery->pushOperation('filter', array($arguments[0]));
             $until = $untilQuery->get();
         }
         if (isset($until) && !empty($until)) {
             $until = end($until);
             $prevNodes = $this->getNodesUntil($prevNodes, $until);
         }
         if (is_array($prevNodes)) {
             foreach ($prevNodes as $prevNode) {
                 if ($prevNode !== NULL && !isset($outputNodePaths[$prevNode->getPath()])) {
                     $outputNodePaths[$prevNode->getPath()] = TRUE;
                     $output[] = $prevNode;
                 }
             }
         }
     }
     $flowQuery->setContext($output);
     if (isset($arguments[1]) && !empty($arguments[1])) {
         $flowQuery->pushOperation('filter', array($arguments[1]));
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation
  * @return mixed
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     if (!isset($arguments[0]) || empty($arguments[0])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('sort() needs property name by which nodes should be sorted', 1332492263);
     } else {
         $nodes = $flowQuery->getContext();
         $sortByPropertyPath = $arguments[0];
         $sortOrder = 'DESC';
         if (isset($arguments[1]) && !empty($arguments[1]) && in_array($arguments[1], array('ASC', 'DESC'))) {
             $sortOrder = $arguments[1];
         }
         $sortedNodes = array();
         $sortSequence = array();
         $nodesByIdentifier = array();
         /** @var Node $node  */
         foreach ($nodes as $node) {
             $propertyValue = $node->getProperty($sortByPropertyPath);
             // \TYPO3\Flow\var_dump($propertyValue);
             if ($propertyValue instanceof \DateTime) {
                 $propertyValue = $propertyValue->getTimestamp();
             }
             $sortSequence[$node->getIdentifier()] = $propertyValue;
             $nodesByIdentifier[$node->getIdentifier()] = $node;
         }
         if ($sortOrder === 'DESC') {
             arsort($sortSequence);
         } else {
             asort($sortSequence);
         }
         foreach ($sortSequence as $nodeIdentifier => $value) {
             $sortedNodes[] = $nodesByIdentifier[$nodeIdentifier];
         }
         $flowQuery->setContext($sortedNodes);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation
  * @return void
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     $output = array();
     $outputNodePaths = array();
     foreach ($flowQuery->getContext() as $contextNode) {
         $siteNode = $contextNode->getContext()->getCurrentSiteNode();
         $parentNodes = $this->getParents($contextNode, $siteNode);
         if (isset($arguments[0]) && !empty($arguments[0] && isset($parentNodes[0]))) {
             $untilQuery = new FlowQuery(array($parentNodes[0]));
             $untilQuery->pushOperation('closest', array($arguments[0]));
             $until = $untilQuery->get();
         }
         if (isset($until) && is_array($until) && !empty($until) && isset($until[0])) {
             $parentNodes = $this->getNodesUntil($parentNodes, $until[0]);
         }
         if (is_array($parentNodes)) {
             foreach ($parentNodes as $parentNode) {
                 if ($parentNode !== null && !isset($outputNodePaths[$parentNode->getPath()])) {
                     $outputNodePaths[$parentNode->getPath()] = true;
                     $output[] = $parentNode;
                 }
             }
         }
     }
     $flowQuery->setContext($output);
     if (isset($arguments[1]) && !empty($arguments[1])) {
         $flowQuery->pushOperation('filter', $arguments[1]);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation.
  * First argument is property to filter by, must be of reference of references type.
  * Second is object to filter by, must be Node.
  * @return mixed
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     if (!isset($arguments[0]) || empty($arguments[0])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('FilterByReference() needs reference property name by which nodes should be filtered', 1332492263);
     } elseif (!isset($arguments[1]) || empty($arguments[1])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('FilterByReference() needs object by which nodes should be filtered', 1332493263);
     } else {
         $nodes = $flowQuery->getContext();
         $filterByPropertyPath = $arguments[0];
         /** @var Node $object  */
         $object = $arguments[1];
         $filteredNodes = array();
         /** @var Node $node  */
         foreach ($nodes as $node) {
             $propertyValue = $node->getProperty($filterByPropertyPath);
             if (is_array($propertyValue)) {
                 if (in_array($object, $propertyValue)) {
                     $filteredNodes[] = $node;
                 }
             } else {
                 if ($object == $propertyValue) {
                     $filteredNodes[] = $node;
                 }
             }
         }
         $flowQuery->setContext($filteredNodes);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation.
  * First argument is property to filter by, must be DateTime.
  * Second is Date operand, must be DateTime object.
  * And third is a compare operator: '<' or '>', '>' by default
  * @return mixed
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     if (!isset($arguments[0]) || empty($arguments[0])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('filterByDate() needs property name by which nodes should be filtered', 1332492263);
     } elseif (!isset($arguments[1]) || empty($arguments[1])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('filterByDate() needs date value by which nodes should be filtered', 1332493263);
     } else {
         $nodes = $flowQuery->getContext();
         $filterByPropertyPath = $arguments[0];
         $date = $arguments[1];
         $compareOperator = '>';
         if (isset($arguments[2]) && !empty($arguments[2]) && in_array($arguments[2], array('<', '>'))) {
             $compareOperator = $arguments[2];
         }
         $filteredNodes = array();
         /** @var Node $node  */
         foreach ($nodes as $node) {
             $propertyValue = $node->getProperty($filterByPropertyPath);
             if ($compareOperator == '>') {
                 if ($propertyValue > $date) {
                     $filteredNodes[] = $node;
                 }
             }
             if ($compareOperator == '<') {
                 if ($propertyValue < $date) {
                     $filteredNodes[] = $node;
                 }
             }
         }
         $flowQuery->setContext($filteredNodes);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments Ignored for this operation
  * @return void
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     $context = $flowQuery->getContext();
     if (isset($context[0])) {
         $flowQuery->setContext(array($context[0]));
     } else {
         $flowQuery->setContext(array());
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments Ignored for this operation
  * @return void
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     $context = $flowQuery->getContext();
     if (count($context) > 0) {
         $flowQuery->setContext(array(end($context)));
     } else {
         $flowQuery->setContext(array());
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments filter arguments for this operation
  * @return void|integer with the number of elements
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     if (count($arguments) == 0) {
         return count($flowQuery->getContext());
     } else {
         $flowQuery->pushOperation('count', array());
         $flowQuery->pushOperation('filter', $arguments);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments A mandatory start and optional end index in the context, negative indices indicate an offset from the start or end respectively
  * @return void
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     $context = $flowQuery->getContext();
     if (isset($arguments[0]) && isset($arguments[1])) {
         $context = array_slice($context, (int) $arguments[0], (int) $arguments[1] - (int) $arguments[0]);
     } elseif (isset($arguments[0])) {
         $context = array_slice($context, (int) $arguments[0]);
     }
     $flowQuery->setContext($context);
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments A mandatory start and optional end index in the context, negative indices indicate an offset from the start or end respectively
  * @return void
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     $context = $flowQuery->getContext();
     if ($context instanceof \Iterator) {
         $context = iterator_to_array($context);
     }
     if (isset($arguments[0]) && isset($arguments[1])) {
         $context = array_slice($context, (int) $arguments[0], (int) $arguments[1] - (int) $arguments[0]);
     } elseif (isset($arguments[0])) {
         $context = array_slice($context, (int) $arguments[0]);
     }
     $flowQuery->setContext($context);
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the elements to add (as array in index 0)
  * @return void
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     $output = array();
     foreach ($flowQuery->getContext() as $element) {
         $output[] = $element;
     }
     if (isset($arguments[0])) {
         foreach ($arguments[0] as $element) {
             $output[] = $element;
         }
     }
     $flowQuery->setContext($output);
 }

 /**
  * Evaluate the property name filter by traversing to the child object. We only support
  * nested objects right now
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $query
  * @param string $propertyNameFilter
  * @return void
  */
 protected function evaluatePropertyNameFilter(\TYPO3\Eel\FlowQuery\FlowQuery $query, $propertyNameFilter)
 {
     $resultObjects = array();
     $resultObjectHashes = array();
     foreach ($query->getContext() as $element) {
         $subProperty = \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($element, $propertyNameFilter);
         if (is_object($subProperty) && !isset($resultObjectHashes[spl_object_hash($subProperty)])) {
             $resultObjectHashes[spl_object_hash($subProperty)] = TRUE;
             $resultObjects[] = $subProperty;
         }
     }
     $query->setContext($resultObjects);
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the context index to fetch from
  * @return mixed
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     $context = $flowQuery->getContext();
     if (isset($arguments[0])) {
         $index = $arguments[0];
         if (isset($context[$index])) {
             return $context[$index];
         } else {
             return null;
         }
     } else {
         return $context;
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param \TYPO3\Eel\FlowQuery\FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the property path to use (in index 0)
  * @return mixed
  */
 public function evaluate(\TYPO3\Eel\FlowQuery\FlowQuery $flowQuery, array $arguments)
 {
     if (!isset($arguments[0]) || empty($arguments[0])) {
         throw new \TYPO3\Eel\FlowQuery\FlowQueryException('property() must be given an attribute name when used on objects, fetching all attributes is not supported.', 1332492263);
     } else {
         $context = $flowQuery->getContext();
         if (!isset($context[0])) {
             return null;
         }
         $element = $context[0];
         $propertyPath = $arguments[0];
         return \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($element, $propertyPath);
     }
 }

 /**
  * {@inheritdoc}
  *
  * @param FlowQuery $flowQuery the FlowQuery object
  * @param array $arguments the arguments for this operation
  * @return void
  */
 public function evaluate(FlowQuery $flowQuery, array $arguments)
 {
     $output = array();
     $outputNodePaths = array();
     /** @var NodeInterface $contextNode */
     foreach ($flowQuery->getContext() as $contextNode) {
         $outputNodePaths[$contextNode->getPath()] = true;
     }
     foreach ($flowQuery->getContext() as $contextNode) {
         $parentNode = $contextNode->getParent();
         if ($parentNode instanceof NodeInterface) {
             foreach ($parentNode->getChildNodes() as $childNode) {
                 if (!isset($outputNodePaths[$childNode->getPath()])) {
                     $output[] = $childNode;
                     $outputNodePaths[$childNode->getPath()] = true;
                 }
             }
         }
     }
     $flowQuery->setContext($output);
     if (isset($arguments[0]) && !empty($arguments[0])) {
         $flowQuery->pushOperation('filter', $arguments);
     }
 }