PHP SMWExporter::getDataItemExpElement方法代码示例

 /**
  * @since 2.5
  *
  * {@inheritDoc}
  */
 public function addResourceValue(ExpData $expData, DIProperty $property, DataItem $dataItem)
 {
     $expElement = $this->exporter->getDataItemExpElement($dataItem);
     if ($expElement !== null) {
         $expData->addPropertyObjectValue($this->getResourceElementForProperty($property), $expElement);
     }
     $this->addResourceHelperValue($expData, $property, $dataItem);
 }

 /**
  * @dataProvider dataItemExpElementProvider
  */
 public function testGetDataItemExpElement(DataItem $dataItem, $instance)
 {
     if ($instance === null) {
         return $this->assertNull(Exporter::getDataItemExpElement($dataItem));
     }
     $this->assertInstanceOf($instance, Exporter::getDataItemExpElement($dataItem));
 }

 private function doMapValueDescription(ValueDescription $description, &$exact)
 {
     if ($description->getComparator() === SMW_CMP_EQ) {
         $result = $this->exporter->getDataItemExpElement($description->getDataItem());
     } else {
         // OWL cannot represent <= and >= ...
         $exact = false;
         $result = false;
     }
     return $result;
 }

 public function testDeleteSubjectOnMockBaseStore()
 {
     $title = Title::newFromText('DeleteSubjectOnMockBaseStore');
     $expResource = Exporter::getDataItemExpElement(DIWikiPage::newFromTitle($title));
     $resourceUri = TurtleSerializer::getTurtleNameForExpElement($expResource);
     $extraNamespaces = array($expResource->getNamespaceId() => $expResource->getNamespace());
     $baseStore = $this->getMockBuilder('\\SMWStore')->disableOriginalConstructor()->getMockForAbstractClass();
     $baseStore->expects($this->once())->method('deleteSubject')->with($this->equalTo($title))->will($this->returnValue(true));
     $sparqlDatabase = $this->getMockBuilder('\\SMWSparqlDatabase')->disableOriginalConstructor()->getMock();
     $sparqlDatabase->expects($this->once())->method('deleteContentByValue')->will($this->returnValue(true));
     $sparqlDatabase->expects($this->once())->method('delete')->with($this->equalTo("{$resourceUri} ?p ?o"), $this->equalTo("{$resourceUri} ?p ?o"), $this->equalTo($extraNamespaces))->will($this->returnValue(true));
     $connectionManager = $this->getMockBuilder('\\SMW\\ConnectionManager')->disableOriginalConstructor()->getMock();
     $connectionManager->expects($this->any())->method('getConnection')->will($this->returnValue($sparqlDatabase));
     $instance = new SPARQLStore($baseStore);
     $instance->setConnectionManager($connectionManager);
     $instance->deleteSubject($title);
 }

 public function doDataUpdate(SMWSemanticData $data)
 {
     parent::doDataUpdate($data);
     $expDataArray = $this->prepareUpdateExpData($data);
     if (count($expDataArray) > 0) {
         $subjectResource = SMWExporter::getDataItemExpElement($data->getSubject());
         $this->deleteSparqlData($subjectResource);
         $turtleSerializer = new SMWTurtleSerializer(true);
         $turtleSerializer->startSerialization();
         foreach ($expDataArray as $expData) {
             $turtleSerializer->serializeExpData($expData);
         }
         $turtleSerializer->finishSerialization();
         $triples = $turtleSerializer->flushContent();
         $prefixes = $turtleSerializer->flushSparqlPrefixes();
         smwfGetSparqlDatabase()->insertData($triples, $prefixes);
     }
 }

 private function createFilterConditionToMatchRegexPattern($dataItem, &$joinVariable, $comparator, $pattern)
 {
     if ($dataItem instanceof DIBlob) {
         return new FilterCondition("{$comparator}( ?{$joinVariable}, \"{$pattern}\", \"s\")", array());
     }
     if ($dataItem instanceof DIUri) {
         return new FilterCondition("{$comparator}( str( ?{$joinVariable} ), \"{$pattern}\", \"i\")", array());
     }
     // Pattern search for a wikipage object can only be done on the sortkey
     // literal and not on it's resource
     $skeyExpElement = Exporter::getInstance()->getSpecialPropertyResource('_SKEY');
     $expElement = $this->exporter->getDataItemExpElement($dataItem->getSortKeyDataItem());
     $condition = new SingletonCondition($expElement);
     $filterVariable = $this->compoundConditionBuilder->getNextVariable();
     $condition->condition = "?{$joinVariable} " . $skeyExpElement->getQName() . " ?{$filterVariable} .\n";
     $condition->matchElement = "?{$joinVariable}";
     $filterCondition = new FilterCondition("{$comparator}( ?{$filterVariable}, \"{$pattern}\", \"s\")", array());
     $condition->weakConditions = array($filterVariable => $filterCondition->getCondition());
     return $condition;
 }

 public function descriptionToExpData($desc, &$exact)
 {
     if ($desc instanceof SMWConjunction || $desc instanceof SMWDisjunction) {
         $result = new SMWExpData(new SMWExpResource(''));
         $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('rdf', 'type'), new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Class')));
         $elements = array();
         foreach ($desc->getDescriptions() as $subdesc) {
             $element = $this->descriptionToExpData($subdesc, $exact);
             if ($element === false) {
                 $element = new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Thing'));
             }
             $elements[] = $element;
         }
         $prop = $desc instanceof SMWConjunction ? 'intersectionOf' : 'unionOf';
         $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('owl', $prop), SMWExpData::makeCollection($elements));
     } elseif ($desc instanceof SMWClassDescription) {
         if (count($desc->getCategories()) == 1) {
             // single category
             $result = new SMWExpData(SMWExporter::getResourceElement(end($desc->getCategories())));
         } else {
             // disjunction of categories
             $result = new SMWExpData(new SMWExpResource(''));
             $elements = array();
             foreach ($desc->getCategories() as $cat) {
                 $elements[] = new SMWExpData(SMWExporter::getResourceElement($cat));
             }
             $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('owl', 'unionOf'), SMWExpData::makeCollection($elements));
         }
         $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('rdf', 'type'), new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Class')));
     } elseif ($desc instanceof SMWConceptDescription) {
         $result = new SMWExpData(SMWExporter::getResourceElement($desc->getConcept()));
     } elseif ($desc instanceof SMWSomeProperty) {
         $result = new SMWExpData(new SMWExpResource(''));
         $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('rdf', 'type'), new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Restriction')));
         $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('owl', 'onProperty'), new SMWExpData(SMWExporter::getResourceElement($desc->getProperty())));
         $subdata = $this->descriptionToExpData($desc->getDescription(), $exact);
         if ($desc->getDescription() instanceof SMWValueDescription && $desc->getDescription()->getComparator() == SMW_CMP_EQ) {
             $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('owl', 'hasValue'), $subdata);
         } else {
             if ($subdata === false) {
                 $owltype = SMWExporter::getOWLPropertyType($desc->getProperty()->getPropertyTypeID());
                 if ($owltype == 'ObjectProperty') {
                     $subdata = new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Thing'));
                 } elseif ($owltype == 'DatatypeProperty') {
                     $subdata = new SMWExpData(SMWExporter::getSpecialNsResource('rdfs', 'Literal'));
                 } else {
                     // no restrictions at all with annotation properties ...
                     return new SMWExpData(SMWExporter::getSpecialNsResource('owl', 'Thing'));
                 }
             }
             $result->addPropertyObjectValue(SMWExporter::getSpecialNsResource('owl', 'someValuesFrom'), $subdata);
         }
     } elseif ($desc instanceof SMWValueDescription) {
         if ($desc->getComparator() == SMW_CMP_EQ) {
             $result = SMWExporter::getDataItemExpElement($desc->getDataItem());
         } else {
             // alas, OWL cannot represent <= and >= ...
             $exact = false;
             $result = false;
         }
     } elseif ($desc instanceof SMWThingDescription) {
         $result = false;
     } else {
         $result = false;
         $exact = false;
     }
     return $result;
 }

 /**
  * Create an SMWSparqlCondition from an SMWValueDescription.
  *
  * @param $description SMWValueDescription
  * @param $joinVariable string name, see buildSparqlCondition()
  * @param $orderByProperty mixed SMWDIProperty or null, see buildSparqlCondition()
  * @return SMWSparqlCondition
  */
 protected function buildValueCondition(SMWValueDescription $description, $joinVariable, $orderByProperty)
 {
     $dataItem = $description->getDataItem();
     switch ($description->getComparator()) {
         case SMW_CMP_EQ:
             $comparator = '=';
             break;
         case SMW_CMP_LESS:
             $comparator = '<';
             break;
         case SMW_CMP_GRTR:
             $comparator = '>';
             break;
         case SMW_CMP_LEQ:
             $comparator = '<=';
             break;
         case SMW_CMP_GEQ:
             $comparator = '>=';
             break;
         case SMW_CMP_NEQ:
             $comparator = '!=';
             break;
         case SMW_CMP_LIKE:
             $comparator = 'regex';
             break;
         case SMW_CMP_NLKE:
             $comparator = '!regex';
             break;
         default:
             $comparator = '';
             // unkown, unsupported
     }
     if ($comparator === '') {
         $result = $this->buildTrueCondition($joinVariable, $orderByProperty);
     } elseif ($comparator == '=') {
         $expElement = SMWExporter::getDataItemHelperExpElement($dataItem);
         if (is_null($expElement)) {
             $expElement = SMWExporter::getDataItemExpElement($dataItem);
         }
         $result = new SMWSparqlSingletonCondition($expElement);
         $this->addOrderByDataForProperty($result, $joinVariable, $orderByProperty, $dataItem->getDIType());
     } elseif ($comparator == 'regex' || $comparator == '!regex') {
         if ($dataItem instanceof SMWDIBlob) {
             $pattern = '^' . str_replace(array('^', '.', '\\', '+', '{', '}', '(', ')', '|', '^', '$', '[', ']', '*', '?'), array('\\^', '\\.', '\\\\', '\\+', '\\{', '\\}', '\\(', '\\)', '\\|', '\\^', '\\$', '\\[', '\\]', '.*', '.'), $dataItem->getString()) . '$';
             $result = new SMWSparqlFilterCondition("{$comparator}( ?{$joinVariable}, \"{$pattern}\", \"s\")", array());
             $this->addOrderByDataForProperty($result, $joinVariable, $orderByProperty, $dataItem->getDIType());
         } else {
             $result = $this->buildTrueCondition($joinVariable, $orderByProperty);
         }
     } else {
         $result = new SMWSparqlFilterCondition('', array());
         $this->addOrderByData($result, $joinVariable, $dataItem->getDIType());
         $orderByVariable = $result->orderByVariable;
         if ($dataItem instanceof SMWDIWikiPage) {
             $expElement = SMWExporter::getDataItemExpElement($dataItem->getSortKeyDataItem());
         } else {
             $expElement = SMWExporter::getDataItemHelperExpElement($dataItem);
             if (is_null($expElement)) {
                 $expElement = SMWExporter::getDataItemExpElement($dataItem);
             }
         }
         $valueName = SMWTurtleSerializer::getTurtleNameForExpElement($expElement);
         if ($expElement instanceof SMWExpNsResource) {
             $result->namespaces[$expElement->getNamespaceId()] = $expElement->getNamespace();
         }
         $result->filter = "?{$orderByVariable} {$comparator} {$valueName}";
     }
     return $result;
 }