Location: PHPKode > scripts > PDOM > pdom/Element.php
<?
define( "ELEMENT", "element" );

/*========================================================================================
*  Autor: Reiner Entzminger            Telefon  (0 63 41) 8 43 69
*         Südring 10                   Telefax  (0 63 41) 8 43 69
*         D-76829 Landau               Mobil +49(0)170 7 34 62 72
*
*  http://www.team-entzminger.de       Mail hide@address.com
*=========================================================================================
*  Element  Version 1.00.0006          Datum: 27.02.2002
*=========================================================================================
*  Enthält Informationen zu einem Element sowie dessen Kind-Elemente
*=======================================================================================*/

   class Element {
      var $element      = array();              // die Kind-Elemente des Elements

      var $parent       = '';                   // Name des Vater-Elements
      var $name         = '';                   // Name des Elements
      var $value        = '';                   // Wert des Elements

      var $attributes;                          // (objekt) die Attribute des Elements
      var $comment;                             // (objekt) Kommentar zum Element

      var $hasChild     = false;                // zeigt an, ob das Element Kind-Elemente hat
      var $child        = array();              // Tabelle mit den Namen der Kind-Elemente

      /**-----------------------------------------------------------------------
      * Element nimmt ein Element mit seinen Attributen und Kindern auf
      * @param  element    - (obtional) der Name des Elements
      * @param  perent     - (obtional) der Name des Vater-Elements. Dieser
      * Parameter schließt den ersten Parameter ein.
      * @param  attributt  - (obtional) das Objekt Attribut mit den Attributen
      * des Elements. Dieser Parameter schließt die ersten beiden Parameter ein.
      *-----------------------------------------------------------------------*/
      function Element() {
      // $this->pro->Method( "class Element()" );

         $GLOBALS['error']    = 0;

         $arga                = func_num_args();
         $args                = func_get_args();

      // über die for-Schleife prüfen, ob ein oder mehrere Parameter an den Konstruktor
      // übergeben wurden.
      //
         for( $i=0; $i<$arga; $i++ ) {
            if ( $i < 2 ) {
            // die ersten möglichen Parameter sind der Elementname und der Name des Vater-
            // Elements. Diese sind vom Datentyp string.
            //
               if ( is_String( $args[$i] ) ) {
                  if ( $i == 0 ) {
                  // Name des neuen Elements
                  //
                     $this->name          = $args[$i];
                  } else {
                  // Name des neuen Vaters
                  //
                     $this->parent        = $args[$i];
                  }  // if ( $i == 0 )
               } else {
                  $GLOBALS['error']    = 1;                 // falscher Datentyp
                  break;
               }  // if ( is_String( $arg[$i] ) )
            } else {
            // der dritte mögliche Parameter sind die die Attribute des Elements. Dieser
            // Parameter muss vom Type Objekt, der Instanz "ATTRIBUT" sein.
            //
               if ( is_object( $args[$i] ) ) {
                  if ( get_class( $args[$i] ) == ATTRIBUT ) {
                     $this->attributes = $args[$i];
                     break;
                  } else {
                     $GLOBALS['error']    = 1;                 // falscher Datentyp
                     break;
                  }  // if ( get_class( $attributes ) == ATTRIBUT )
               } else {
                  $GLOBALS['error']    = 1;                 // falscher Datentyp
                  break;
               }  // if ( is_object( $args[$i] ) )
            }  // if ( $i < 2 )
         }  // for( $i=0; $i<$arga; $i++ )

      // $this->pro->Returns( "class Element()" );
      }  // function Methode()


      /**-----------------------------------------------------------------------
      * addElement setzt ein (weiteres) Kind-Element
      * @param  $element - das Objekt Element
      *-----------------------------------------------------------------------*/
      function addElement( $element ) {
      // $this->pro->Method( "Element: addElement()" );

         $GLOBALS['error']    = 0;
         $result              = false;

      // prüfen, ob der angegebene Parameter ein gültiges Objekt der Instanz
      // Element ist.
      //
         if ( is_object( $element ) ) {
            if ( get_class( $element ) == ELEMENT ) {
               array_push( $this->element, $element );
               array_push( $this->child, $element->name );

               $this->hasChild      = true;
               $result              = true;
            } else {
               $GLOBALS['error']    = 1;                    // ungültiger Datentyp
            }  // if ( get_class( $element ) == ELEMENT )
         } else {
            $GLOBALS['error']    = 1;                       // ungültiger Datentyp
         }  // if ( is_object( $element ) )

      // $this->pro->Returns( "Element: addElement()" );

         return $result;
      }  // function addElement()


      /**-----------------------------------------------------------------------
      * setParent setzt den Namen des Vater-Elements
      * @param  name    - der Name des Vater-Elements
      * @return Wurde ein gültiger Parameter angegeben und die Eigenschaft konnte
      * gesetzt werden, dann gibt die Funktion true zurück. Sonst false.
      *-----------------------------------------------------------------------*/
      function setParent( $parent ) {
      // $this->pro->Method( "Element: setParent()" );

         $GLOBALS['error']    = 0;
         $result              = false;

      // prüfen, ob der angegebene Parameter ein String ist und keine leere
      // Zeichenfolge enthält
      //
         if ( !empty( $parent ) ) {
            if ( is_string( $parent ) ) {
               $this->parent        = $parent;
               $result              = true;
            } else {
               $GLOBALS['error']    = 1;                    // falscher Datentyp
            }  // if ( is_string( $parent ) )
         } else {
            $GLOBALS['error']    = 5;                       // leerer Parameter
         }  // if ( !empty( $parent ) )

      // $this->pro->Returns( "Element: setParent()" );

         return $result;
      }  // function setParent()


      /**-----------------------------------------------------------------------
      * setName setzt den Namen des Elements
      * @param  name    - der Name des Elements
      * @return Wurde ein gültiger Parameter angegeben und die Eigenschaft konnte
      * gesetzt werden, dann gibt die Funktion true zurück. Sonst false.
      *-----------------------------------------------------------------------*/
      function setName( $name ) {
      // $this->pro->Method( "Element: setName()" );

         $GLOBALS['error']    = 0;
         $result              = false;

      // prüfen, ob der angegebene Parameter ein String ist und keine leere
      // Zeichenfolge enthält
      //
         if ( !empty( $name ) ) {
            if ( is_string( $name ) ) {
               $this->name          = $name;
               $result              = true;
            } else {
               $GLOBALS['error']    = 1;                    // falscher Datentyp
            }  // if ( is_string( $name ) )
         } else {
            $GLOBALS['error']    = 5;                       // leerer Parameter
         }  // if ( !empty( $name ) )

      // $this->pro->Returns( "Element: setName()" );

         return $result;
      }  // function setName()


      /**-----------------------------------------------------------------------
      * setValue setzt den Wert, des Elements
      * @param  value   - Wert des Elements
      *-----------------------------------------------------------------------*/
      function setValue( $value ) {
      // $this->pro->Method( "Element: setValue()" );

         $this->value         = $value;

      // $this->pro->Returns( "Element: setValue()" );
      }  // function setValue()


      /**-----------------------------------------------------------------------
      * setAttributes setzt die Attribute des Elements
      * @param  attributes - Objekt der Instanz ATTRIBUT mit den Attributen des
      * Elements
      * @return Wurde ein gültiger Parameter angegeben und die Eigenschaft konnte
      * gesetzt werden, dann gibt die Funktion true zurück. Sonst false.
      *-----------------------------------------------------------------------*/
      function setAttributes( $attributes ) {
      // $this->pro->Method( "Element: setAttributes()" );

         $GLOBALS['error']    = 0;
         $result              = false;

      // prüfen, ob der angegebene Parameter ein gültiges Objekt der Instanz
      // Element ist.
      //
         if ( is_object( $attributes ) ) {
            if ( get_class( $attributes ) == ATTRIBUT ) {
               $this->attributes    = $attributes;
               $result              = true;
            } else {
               $GLOBALS['error']    = 1;                    // falscher Datentyp
            }  // if ( get_class( $attributes ) == ATTRIBUT )
         } else {
            $GLOBALS['error']    = 1;                       // falscher Datentyp
         }  // if ( is_object( $attributes ) )

      // $this->pro->Returns( "Element: setAttributes()" );

         return result;
      }  // function setAttributes()


      /**-----------------------------------------------------------------------
      * addComment setzt Commentare für dieses Element
      * @param  comment - der Kommentar zum Element
      *-----------------------------------------------------------------------*/
      function addComment( $comment ) {
      // $this->pro->Method( "Element: addComment()" );

         if ( empty( $this->comment ) ) {
            $this->comment       = new Comment();           // Kommentar instanziieren
         }  // if ( empty( $this->comment ) )

         $this->comment->addComment( $comment );

      // $this->pro->Returns( "Element: addComment()" );
      }  // function addComment()


      /**-----------------------------------------------------------------------
      * getElement gibt das benannte Element (Index oder Name) zurück
      * @param  index   - Index innerhalb der Sammlung der Elemente. Dieser
      * Parameter schließt den zweiten Parameter aus.
      * @param  name    - Name innerhalb der Sammlung der Elemente. Dieser
      * Parameter schließt den ersten Parameter aus. Werden mehrere Elemente mit
      * dem gleichen Parameter gefunden, wird immer das zuletzt gefundene
      * Element zurückgegeben.
      * @return das abgefragte Element, oder false wenn das angeforderte Element
      * nicht gefunden werden konnte.
      *-----------------------------------------------------------------------*/
      function getElement( $element ) {
      // $this->pro->Method( "Element: getElement()" );

         $GLOBALS['error']    = 0;

      // prüfen, von welchem Datentyp der Parameter ist
      // Long, Attribut über den Index ermitteln
      // String, Attribut nach dem Namen abfragen
      //
         if ( is_long( $element ) ) {
            if ( $element < count( $this->element ) ) {
               if ( $element > -1 ) {
                  $result              = $this->element[$element];
               } else {
                  $GLOBALS['error']    = 4;                 // Index out of bounds
                  $result              = false;
               }  // if ( $element > -1 )
            } else {
               $GLOBALS['error']    = 4;                    // Index out of bounds
               $result              = false;
            }  // if ( $element < count( $this->element ) )
         }  // if ( is_long( $element ) )

         else if ( is_string( $element ) ) {
            $speicher            = array_flip( $this->child );

            if ( isset( $speicher[$element] ) ) {
               $result              = $this->element[$speicher[$element]];
            } else {
               $GLOBALS['error']    = 4;                    // Index out of bounds
               $result              = false;
            }  // if ( isset( $speicher[$element] ) )
         } else {
            $GLOBALS['error']    = 1;                    // falscher Datentyp
            $result              = false;
         }  // if ( is_string( $element ) )

      // $this->pro->Returns( "Element: getElement()" );

         return $result;
      }  // function getElement()


      /**-----------------------------------------------------------------------
      * getElements gibt einen indizierten Array aller Elemente zurück
      * @return einen indizierten Array aller Elemente
      *-----------------------------------------------------------------------*/
      function getElements() {
      // $this->pro->Method( "Element: getElements()" );
      // $this->pro->Returns( "Element: getElements()" );

         return $this->element;
      }  // function getElements()


      /**-----------------------------------------------------------------------
      * getParent gibt den Namen des Vater-Elements zurück
      * @return der Name des Vater-Elements
      *-----------------------------------------------------------------------*/
      function getParent() {
      // $this->pro->Method( "Element: getParent()" );
      // $this->pro->Returns( "Element: getParent()" );

         return $this->parent;
      }  // function getParent()


      /**-----------------------------------------------------------------------
      * getName gibt den Namen des Elements zurück
      * @return der Name des Elements
      *-----------------------------------------------------------------------*/
      function getName() {
      // $this->pro->Method( "Element: getName()" );
      // $this->pro->Returns( "Element: getName()" );

         return $this->name;
      }  // function getName()


      /**-----------------------------------------------------------------------
      * getValue gibt den Wert des Elements zurück
      * @return der Wert des Elements
      *-----------------------------------------------------------------------*/
      function getValue() {
      // $this->pro->Method( "Element: getValue()" );
      // $this->pro->Returns( "Element: getValue()" );

         return $this->value;
      }  // function getValue()


      /**-----------------------------------------------------------------------
      * getAttributes gibt eine Instanze des Objects ATTRIBUT des Elements
      * zurück
      * @return eine Instanze des Objects ATTRIBUT des Elements
      *-----------------------------------------------------------------------*/
      function getAttributes() {
      // $this->pro->Method( "Element: getAttributes()" );
      // $this->pro->Returns( "Element: getAttributes()" );

         return $this->attributes;
      }  // function getAttributes()


      /**-----------------------------------------------------------------------
      * getComment gibt eine Instanze des Objects COMMENT des Elements zurück
      * @return eine Instanze des Objects COMMENT des Elements
      *-----------------------------------------------------------------------*/
      function getComment() {
      // $this->pro->Method( "Element: getComment()" );
      // $this->pro->Returns( "Element: getComment()" );

         return $this->comment;
      }  // function getComment()


      /**-----------------------------------------------------------------------
      * hasElement prüft, ob weitere Elemente in der Sammlung vorhanden sind und
      * gibt true zurück, wenn weitere Elemente vorhanden sind, sonst false
      * @return true wenn weitere Elemente vorhanden sind, sonst false
      *-----------------------------------------------------------------------*/
      function hasElement() {
      // $this->pro->Method( "Element: hasElement()" );

         $result              = true;

         if ( $this->hasChild ) {
            if ( isset( $this->index ) ) {
               if ( !( $this->index < count( $this->element ) ) ) {
                  $result              = false;
               }  // if ( !( $this->index < count( $this->element ) ) )
            } else {
               $this->index         = 0;
            }  // if ( isset( $this->index ) )
         } else {
            $result              = false;
         }  // if ( $this->hasChild )

      // $this->pro->Returns( "Element: hasElement()" );

         return $result;
      }  // function hasElement()


      /**-----------------------------------------------------------------------
      * getNext() gibt das nächste Objekt der Instanze ELEMENT zurück. Bei dem
      * ersten Aufruf wird das erste Element zurückgegeben, danach jeweils das
      * nächste, solange weitere Elemente (prüfen über die Funktion hasElement)
      * vorhanden sind.
      * @return ein Objekt der Instanze ELEMENT. Ist kein weiteres Element
      * vorhanden, wird false zurückgegeben.
      *-----------------------------------------------------------------------*/
      function getNext() {
      // $this->pro->Method( "Element: getNext()" );

         if ( $this->hasElement() ) {
            $result              = $this->element[$this->index++];
         } else {
            $GLOBALS['error']    = 4;                       // Index out of bounds
            $result              = false;
         }  // if ( $this->hasElement() )

      // $this->pro->Returns( "Element: getNext()" );

         return $result;
      }  // function getNext()


      /**-----------------------------------------------------------------------
      * getChildByName gibt einen Array mit den Namen der Kindelemente zurück
      * @return einen Array mit den Namen der Kindelemente
      *-----------------------------------------------------------------------*/
      function getChildByName() {
      // $this->pro->Method( "Element: getChildByName()" );
      // $this->pro->Returns( "Element: getChildByName()" );

         return $this->child;
      }  // function getChildByName()


      /**-----------------------------------------------------------------------
      * toString gibt Informationen zum Element in einem String zurück
      * @return Informationen zum Element
      *-----------------------------------------------------------------------*/
      function toString() {
      // $this->pro->Method( "Element: toString()" );

         $result        = '';

         $result       .= 'Element: ' . $this->name . "<br>\n";
         $result       .= '&nbsp;&nbsp;&nbsp;Parent: ' . $this->parent . "<br>\n";
         $result       .= '&nbsp;&nbsp;&nbsp;Value: ' . $this->value . "<br>\n<br>\n";

         if ( ! empty( $this->attributes ) ) {
            $result       .= $this->attributes->toString() . "<br>\n";
         }  // if ( ! empty( $this->attributes ) )

         if ( ! empty( $this->comment ) ) {
            $result       .= $this->comment->toString() . "<br>\n<br>\n";
         }  // if ( ! empty( $this->comment ) )

         $result       .= 'Kinder : ' . "<br>\n";

         for( $i=0; $i< count( $this->child ); $i++ ) {
            $result       .= '&nbsp;&nbsp;&nbsp;' . $this->child[$i] . "<br>\n<br>\n";
         }  // for( $i=0; $i< count( $this->child ); $i++ )

      // $this->pro->Returns( "Element: toString()" );

         return $result;
      }  // function toString()

   }  // class Element
?>
Return current item: PDOM