OpenStructs

structWSF
Code Documentation

• Login
• Blog

• Home
• structWSF
• Resources
• Downloads

ClassHierarchy.php

Go to the documentation of this file.

<?php


class ClassHierarchy
{
  public $classes = array();

  function __construct($rootClass)
  {
    $this->classes[$rootClass] = new ClassNode($rootClass, "");
  }

  function __destruct() { }


  public function addClassRelationship($class, $subClassOf)
  {
    // Make sure the relationship doesn't already exists
    if(isset($this->classes[$class]->subClassOf))
    {
      foreach($this->classes[$class]->subClassOf as $sc)
      {
        if($sc->name == $subClassOf)
        {
          return;
        }
      }
    }

    // First, check if the superClass exists. If it doesn't, we link it to owl:Thing
    if(!isset($this->classes[$subClassOf]))
    {
      $this->addClassRelationship($subClassOf, "http://www.w3.org/2002/07/owl#Thing");
    }

    // Then check if the class already belong to the structure. If it does, we only have to re-link the structure
    if(isset($this->classes[$class]))
    {
      $target = $this->classes[$class];

      $superClass = $this->classes[$subClassOf];

      array_push($superClass->superClassOf, $target);

      array_push($target->subClassOf, $superClass);


      // Lets remove the owl:Thing link if it was existing (introduced at step 1).
      $newSubclassArray = array();

      foreach($target->subClassOf as $sc)
      {
        if($sc->name != "http://www.w3.org/2002/07/owl#Thing")
        {
          array_push($newSubclassArray, $sc);
        }
        else
        {
          // Remove the link from the subClassOf owl:Thing too!
          $newSuperClassArray = array();

          $owlThing = $this->classes["http://www.w3.org/2002/07/owl#Thing"];

          foreach($owlThing->superClassOf as $sc)
          {
            if($sc->name != $target->name)
            {
              array_push($newSuperClassArray, $sc);
            }
          }

          $owlThing->superClassOf = $newSuperClassArray;
        }
      }

      $target->subClassOf = $newSubclassArray;
    }
    else
    {
      // Otherwise we have a new node to add to the structure.
      $newClass = new ClassNode($class, $superClass);
      $this->classes[$class] = $newClass;

      $superClass = $this->classes[$subClassOf];

      array_push($superClass->superClassOf, &$newClass);

      array_push($newClass->subClassOf, $superClass);
    }
  }

  public function getSuperClasses($class)
  {
    $superClasses = array();
    $stack = array();

    if(isset($this->classes[$class]))
    {
      // Initialize the stack
      foreach($this->classes[$class]->subClassOf as $sc)
      {
        if(array_search($sc, $stack) === FALSE)
        {
          array_push($stack, $sc);
        }
      }

      while(count($stack) > 0)
      {
        $target = array_pop($stack);

        array_push($superClasses, $target);

        if(isset($target->subClassOf))
        {
          foreach($target->subClassOf as $sc)
          {
            if(array_search($sc, $stack) === FALSE)
            {
              array_push($stack, $sc);
            }
          }
        }
      }
    }

    return $superClasses;
  }

  public function getSubClasses($class)
  {
    $subClasses = array();
    $stack = array();

    if(isset($this->classes[$class]))
    {
      // Initialize the stack
      foreach($this->classes[$class]->superClassOf as $sc)
      {
        if(array_search($sc, $stack) === FALSE)
        {
          array_push($stack, $sc);
        }
      }

      while(count($stack) > 0)
      {
        $target = array_pop($stack);

        array_push($subClasses, $target);

        if(isset($target->superClassOf))
        {
          foreach($target->superClassOf as $sc)
          {
            if(array_search($sc, $stack) === FALSE)
            {
              array_push($stack, $sc);
            }
          }
        }
      }
    }

    return $subClasses;
  }

  public function isSubClassOf($subClass, $superClass)
  {
    $superClasses = $this->getSuperClasses($subClass);

    foreach($superClasses as $sc)
    {
      if($sc->name == $superClass)
      {
        return (TRUE);
      }
    }

    return (FALSE);
  }
}

class ClassNode
{
  public $name = "";

  public $label = "";

  public $description = "";

  public $subClassOf = array(); // array of pointers

  public $superClassOf = array(); // array of pointers

  function __construct($name, $subClassOf)
  {
    $this->name = $name;

    if(isset($subClassOf->name) && $subClassOf->name != "")
    {
      $this->subClassOf[$subClassOf->name] = $subClassOf;
    }
  }

  function __destruct() { }
}


?>

Copyright © 2009. Structured Dynamics LLC. All rights reserved.