<?
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 reiner@team-entzminger.de
*=========================================================================================
* 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 .= ' Parent: ' . $this->parent . "<br>\n";
$result .= ' 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 .= ' ' . $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
?>
|
Stumble It!
Bookmark in del.icio.us
Download
