/** * Instantiate an RDFs Class * * @access public * @author Jerome Bogaerts, <*****@*****.**> * @param Class clazz * @param string label * @return core_kernel_classes_Resource */ public function createInstance(core_kernel_classes_Class $clazz, $label = '') { if (empty($label)) { $label = $this->createUniqueLabel($clazz); } return core_kernel_classes_ResourceFactory::create($clazz, $label, ''); }
/** * Short description of method createSPX * * @access public * @author firstname and lastname of author, <*****@*****.**> * @param Resource $subject * @param Property $predicate * @return core_kernel_rules_Term */ public static function createSPX(core_kernel_classes_Resource $subject, core_kernel_classes_Property $predicate) { $returnValue = null; $termSPXClass = new core_kernel_classes_Class(CLASS_TERM_SUJET_PREDICATE_X, __METHOD__); $label = 'Def Term SPX Label : ' . $subject->getLabel() . ' - ' . $predicate->getLabel(); $comment = 'Def Term SPX Label : ' . $subject->getUri() . ' ' . $predicate->getUri(); $SPXResource = core_kernel_classes_ResourceFactory::create($termSPXClass, $label, $comment); $returnValue = new core_kernel_rules_Term($SPXResource->getUri()); $subjectProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_SUBJET, __METHOD__); $predicateProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_PREDICATE, __METHOD__); $returnValue->setPropertyValue($subjectProperty, $subject->getUri()); $returnValue->setPropertyValue($predicateProperty, $predicate->getUri()); return $returnValue; }
/** * Short description of method createOperation * * @access public * @author firstname and lastname of author, <*****@*****.**> * @param Term term1 * @param Term term2 * @param Resource operator * @return core_kernel_rules_Operation */ public static function createOperation(core_kernel_rules_Term $term1, core_kernel_rules_Term $term2, core_kernel_classes_Resource $operator) { $returnValue = null; $operationClass = new core_kernel_classes_Class(CLASS_OPERATION, __METHOD__); $label = 'Def Operation Label ' . $term1->getLabel() . ' ' . $operator->getLabel() . ' ' . $term2->getLabel(); $comment = 'Def Operation Comment ' . $term1->getUri() . ' ' . $operator->getUri() . ' ' . $term2->getUri(); $operatorProperty = new core_kernel_classes_Property(PROPERTY_OPERATION_OPERATOR, __METHOD__); $firstOperand = new core_kernel_classes_Property(PROPERTY_OPERATION_FIRST_OP, __METHOD__); $secondOperand = new core_kernel_classes_Property(PROPERTY_OPERATION_SECND_OP, __METHOD__); $termOperationInstance = core_kernel_classes_ResourceFactory::create($operationClass, $label, $comment); $returnValue = new core_kernel_rules_Operation($termOperationInstance->getUri()); $returnValue->debug = __METHOD__; $returnValue->setPropertyValue($operatorProperty, $operator->getUri()); $returnValue->setPropertyValue($firstOperand, $term1->getUri()); $returnValue->setPropertyValue($secondOperand, $term2->getUri()); return $returnValue; }
public function testCreateSPX() { $booleanClass = new core_kernel_classes_Class(GENERIS_BOOLEAN); $maybe = core_kernel_classes_ResourceFactory::create($booleanClass, 'testCase testCreateSPX', __METHOD__); $SPXResource = core_kernel_rules_TermFactory::createSPX($maybe, new core_kernel_classes_Property(RDFS_COMMENT)); $this->assertIsA($SPXResource, 'core_kernel_rules_Term'); $subjectProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_SUBJET); $predicateProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_PREDICATE); $subject = $SPXResource->getUniquePropertyValue($subjectProperty); $this->assertIsA($subject, 'core_kernel_classes_Resource'); $this->assertEquals($subject->getUri(), $maybe->getUri()); $predicate = $SPXResource->getUniquePropertyValue($predicateProperty); $this->assertIsA($predicate, 'core_kernel_classes_Resource'); $this->assertEquals($predicate->getUri(), RDFS_COMMENT); $SPXResource->delete(); $maybe->delete(); }
public function testEvaluate() { //bad term $badTermResource = core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(CLASS_TERM), 'bad term', __METHOD__); $badTerm = new core_kernel_rules_Term($badTermResource->getUri()); try { $badTerm->evaluate(); $this->fail('should raise exception : Forbidden type'); } catch (common_Exception $e) { $this->assertEquals($e->getMessage(), 'Forbidden Type of Term'); } // eval const $constantResource = core_kernel_rules_TermFactory::createConst('test1'); $term = $constantResource->evaluate(); $this->assertIsA($term, 'core_kernel_classes_Literal'); $this->assertEquals($term, 'test1'); $constantResource->delete(); //eval SPX $booleanClass = new core_kernel_classes_Class(GENERIS_BOOLEAN); $maybe = core_kernel_classes_ResourceFactory::create($booleanClass, 'testCase testCreateSPX', __METHOD__); $SPXResource = core_kernel_rules_TermFactory::createSPX($maybe, new core_kernel_classes_Property(RDFS_COMMENT)); $spxResult = $SPXResource->evaluate(); $this->assertIsA($spxResult, 'core_kernel_classes_Literal'); $this->assertEquals($spxResult, __METHOD__); // eval operation $constant5 = core_kernel_rules_TermFactory::createConst('5'); $constant12 = core_kernel_rules_TermFactory::createConst('12'); $operation = core_kernel_rules_OperationFactory::createOperation($constant5, $constant12, new core_kernel_classes_Resource(INSTANCE_OPERATOR_ADD)); $operationTerm = new core_kernel_rules_Term($operation->getUri()); $result = $operationTerm->evaluate(); $this->assertEquals($result->literal, '17'); $fakeTerm = new core_kernel_rules_Term($maybe->getUri()); try { $fakeTerm->evaluate(); $this->fail('should raise exception : Forbidden type'); } catch (common_Exception $e) { $this->assertEquals($e->getMessage(), 'problem evaluating Term'); } $badTermResource->delete(); $constant5->delete(); $constant12->delete(); $SPXResource->delete(); $operation->delete(); $maybe->delete(); }
public function testCreateInstanceHardified() { $rr = ResourceReferencer::singleton(); $this->assertFalse($rr->isClassReferenced($this->class)); $softinstance = core_kernel_classes_ResourceFactory::create($this->class); $this->assertFalse($rr->isResourceReferenced($softinstance)); $switcher = new Switcher(); $switcher->hardify($this->class, array('topclass' => $this->class)); unset($switcher); $this->assertTrue($rr->isClassReferenced($this->class)); common_Logger::i('creating hardified'); $hardinstance = core_kernel_classes_ResourceFactory::create($this->class); $this->assertTrue($rr->isResourceReferenced($hardinstance), 'Instance created from harmode class was added in softmode'); $softinstance->delete(); $hardinstance->delete(); $switcher = new Switcher(); $switcher->unhardify($this->class); unset($switcher); }
/** * Short description of method createRecursiveExpression * * @access public * @author firstname and lastname of author, <*****@*****.**> * @param Expression exp1 * @param Expression exp2 * @param Resource operator * @return core_kernel_rules_Expression */ public static function createRecursiveExpression(core_kernel_rules_Expression $exp1, core_kernel_rules_Expression $exp2, core_kernel_classes_Resource $operator) { $returnValue = null; if ($exp1 == null || $exp2 == null || $operator == null) { var_dump($exp1, $exp2, $operator); throw new common_Exception('paramaters could not be null'); } $expressionClass = new core_kernel_classes_Class(CLASS_EXPRESSION, __METHOD__); $label = 'Expression : ' . $exp1->getLabel() . ' ' . $operator->getLabel() . ' ' . $exp2->getLabel(); $comment = 'Expression : ' . $exp1->getUri() . ' ' . $operator->getUri() . ' ' . $exp2->getUri(); $expressionInst = core_kernel_classes_ResourceFactory::create($expressionClass, $label, $comment); $terminalExpressionProperty = new core_kernel_classes_Property(PROPERTY_TERMINAL_EXPRESSION, __METHOD__); $logicalOperatorProperty = new core_kernel_classes_Property(PROPERTY_HASLOGICALOPERATOR, __METHOD__); $firstExpressionProperty = new core_kernel_classes_Property(PROPERTY_FIRST_EXPRESSION, __METHOD__); $secondExpressionProperty = new core_kernel_classes_Property(PROPERTY_SECOND_EXPRESSION, __METHOD__); $returnValue = new core_kernel_rules_Expression($expressionInst->getUri()); $returnValue->debug = __METHOD__; $returnValue->setPropertyValue($terminalExpressionProperty, INSTANCE_EMPTY_TERM_URI); $returnValue->setPropertyValue($firstExpressionProperty, $exp1->getUri()); $returnValue->setPropertyValue($secondExpressionProperty, $exp2->getUri()); $returnValue->setPropertyValue($logicalOperatorProperty, $operator->getUri()); return $returnValue; }
/** * Creates a new file with a specific name and path * * @param string $filename * @param string $relativeFilePath * @return core_kernel_versioning_File */ public function createFile($filename, $relativeFilePath = '') { $resource = core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(CLASS_GENERIS_FILE)); $returnValue = new core_kernel_versioning_File($resource); $returnValue->setPropertiesValues(array(PROPERTY_FILE_FILENAME => $filename, PROPERTY_FILE_FILEPATH => trim($relativeFilePath, DIRECTORY_SEPARATOR), PROPERTY_FILE_FILESYSTEM => $this)); return $returnValue; }
public function testCreateInstanceWithProperties() { // simple case, without params $class = $this->class; $litproperty = new core_kernel_classes_Property(core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(RDF_PROPERTY))->getUri()); $property = new core_kernel_classes_Property(core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(RDF_PROPERTY))->getUri()); $instance = $class->createInstanceWithProperties(array()); $this->assertTrue($instance->hasType($class)); // simple literal properties $instance1 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel', RDFS_COMMENT => 'testcomment')); $this->assertTrue($instance1->hasType($class)); $this->assertEquals($instance1->getLabel(), 'testlabel'); $this->assertEquals($instance1->getComment(), 'testcomment'); // multiple literal properties $instance2 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel', $litproperty->getUri() => array('testlit1', 'testlit2'))); $this->assertTrue($instance2->hasType($class)); $this->assertEquals($instance2->getLabel(), 'testlabel'); $comments = $instance2->getPropertyValues($litproperty); sort($comments); $this->assertEquals($comments, array('testlit1', 'testlit2')); // single ressource properties $propInst = core_kernel_classes_ResourceFactory::create($class); $instance3 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel', RDFS_COMMENT => 'testcomment', $property->getUri() => $propInst)); $this->assertTrue($instance3->hasType($class)); $this->assertEquals($instance3->getLabel(), 'testlabel'); $propActual = $instance3->getUniquePropertyValue($property); // returns a ressource $this->assertEquals($propInst->getUri(), $propActual->getUri()); // multiple ressource properties $propInst2 = core_kernel_classes_ResourceFactory::create($class); $instance4 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel', RDFS_COMMENT => 'testcomment', $property->getUri() => array($propInst, $propInst2))); $this->assertTrue($instance4->hasType($class)); $this->assertEquals($instance4->getLabel(), 'testlabel'); $propActual = array_values($instance4->getPropertyValues($property)); // returns uris $propNormative = array($propInst->getUri(), $propInst2->getUri()); sort($propActual); sort($propNormative); $this->assertEquals($propActual, $propNormative); // multiple classes $classres = core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(RDFS_CLASS), 'TestClass2'); $class2 = new core_kernel_classes_Class($classres); $classres = core_kernel_classes_ResourceFactory::create(new core_kernel_classes_Class(RDFS_CLASS), 'TestClass3'); $class3 = new core_kernel_classes_Class($classres); // 2 classes (by ressource) $instance5 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel5', RDF_TYPE => $classres)); $this->assertTrue($instance5->hasType($class)); $this->assertTrue($instance5->hasType($class3)); $this->assertEquals($instance5->getLabel(), 'testlabel5'); // 3 classes (by uri + class) $instance6 = $class->createInstanceWithProperties(array(RDFS_LABEL => 'testlabel6', RDF_TYPE => array($class2, $class3->getUri()))); $this->assertTrue($instance6->hasType($class)); $this->assertTrue($instance6->hasType($class2)); $this->assertTrue($instance6->hasType($class3)); $this->assertEquals($instance6->getLabel(), 'testlabel6'); $instance->delete(); $instance1->delete(); $instance2->delete(); $propInst->delete(); $propInst2->delete(); $property->delete(); $litproperty->delete(); $instance5->delete(); $instance6->delete(); $class2->delete(); $class3->delete(); }