Example #1
0
 /**
  * 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, '');
 }
Example #2
0
 /**
  * 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;
 }
Example #8
0
 /**
  * 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();
 }