org.netfrag.elib/vops/objects.php.inc

<?

// ==============================================================
class DSAbstractObject {

  // the type of this object
  var $type;

  // the name of the object-key
  var $objectkey_name;

  // the (virtual) attributes
  var $attributes;
  
  // references to other/new objects
    // a reference to a "DSSession"-object which will be passed in "from outside" by the "DSEngine"
    var $ref_session;
    // a "DataQuery"-object instantiated in the constructor later
    var $ref_dataquery;
    // a reference to a "PDLModelObject"-object, which will be initialized in the constructor from "$ref_session"
    var $ref_pdlModelObject;
    // a reference to a list (array) of "PDLModelObject"-attributes ("PDLModelObjectAttribute"s)
    var $ref_pdlModelObjectAttributes;
  
  // miscellanious other variables

    // some state-information
    var $bool_unbound;        // no binding to database yet
    var $bool_created;         // created for being a new object
    
    var $pdlEventName;
    var $pdlEventName_CurrentObjectOperation;
    var $dsType;

    // metainfo about this object
    //var $metainfo;

  // ---------------------------------------------------------------------------------------
  function DSAbstractObject($type, $eventIdentifier, &$ref_session) {

    // initialize most important information for an object :-)
    $this->type = $type;
    $this->ref_session =& $ref_session;
    $this->ref_pdlModelObject =& $this->ref_session->pdlengine->getPDLObject($type);
    $this->ref_pdlModelObjectAttributes =& $this->ref_pdlModelObject->attributes;
    $this->objectkey_name = $this->ref_pdlModelObject->objectkey;
    
    $this->_initAttributes();
    
    // initialize object-state (-> "this is a new object")
    $this->bool_unbound = 1;
    $this->bool_created = 1;

    $this->pdlEventName = 'retrieve ' . $eventIdentifier;
    $this->pdlEventName_CurrentObjectOperation = '';
    if ($eventIdentifier == 'all') {
      $this->dsType = 'DSDataCollection';
    } else {
      $this->dsType = 'DSDataObject';
    }

    // create a new "DataQuery"-object and store reference
    $this->ref_dataquery =& new DataQuery();

  }


  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // PROTOTYPES?
  // TODO: silly idea with the prototypes in here, in fact most of these are 
  //            very specialized methods of "DSDataObject" which have nothing lost in "DSDataCollection"

    // attribute-operations
    //function get() { }
    //function set() { }
    
    // object-key-operations
    function getObjectKeyName() { return $this->_getObjectKeyName(); }
    function getObjectKey() { return $this->_getObjectKey(); }
    function setObjectKey($value) { return $this->_setObjectKey($value); }
    function hasObjectKey() { return $this->_hasObjectKey(); }
    
    // object-operations
    //function load() { }
    //function save() { }
    //function delete() { }
    function fill($attributes_new) { $this->_fill($attributes_new); }
    function reset() { $this->_reset(); }
    function unbind() { $this->_unbind(); }


  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // ATTRIBUTE-OPERATIONS (get/set)

    // ---------------------------------------------------------------------------------------
    function _getAttribute($attribute_name) {
      if (isset($this->attributes[$attribute_name])) {
        $value = $this->attributes[$attribute_name];

        if (isset($this->ref_pdlModelObjectAttributes)) {
          switch ($this->ref_pdlModelObjectAttributes[$attribute_name]->type) {
            case 'Date':
              // modify date from english/american format to german one
              //$value = join('-', array_reverse( split('.', $value) ));
              $value = convertDate($value, 'german');
              break;
          }
        }

        return $value;
      }
    }

    function _setAttribute($attribute_name, $value) {

      if (isset($this->ref_pdlModelObjectAttributes)) {
        switch ($this->ref_pdlModelObjectAttributes[$attribute_name]->type) {
          case 'Date':
            // modify date from english/american format to german one
            //$value = join('-', array_reverse( split('.', $value) ));
            $value = convertDate($value, 'english');
            break;
        }
      }
  
      $this->attributes[$attribute_name] = $value;
    }

    function _existsAttribute($attribute_name) {
      return isset($this->attributes[$attribute_name]);
    }

    // ---------------------------------------------------------------------------------------
    function _initAttributes() {
      $attribute_names = array_keys($this->ref_pdlModelObjectAttributes);
      $this->attributes = createHash($attribute_names);
    }

    // ---------------------------------------------------------------------------------------
    function _checkAttributeAccess($attribute_name, $access_mode) {
  
      /*
      remarks for attribute-access-checking: is the following mechanism okay?
      - always (maybe first): check for attribute-existance
      - read-mode:
          - if the object is new (objectkey == '<new>'), return no value
      - write-mode:
          - if the object has no object-key: continue work
          - if the object has got one or more object-key(s):
            - if the object is bound: continue work
            - if the object is not bound: check if all object-keys are set first before accessing other attributes
      */    
  
      if (!$this->_existsAttribute($attribute_name)) {
        print "<font color=\"red\">Could not access attribute \"$attribute_name\" (operation: \"$access_mode\") in object \"{$this->type}\". Attribute does not exist.</font><br>";
        return 0;
      }
      
  
      switch ($access_mode) {
  
        // - - - - - - - - - - - - 
        case 'read':
          // is this a new object?
          if ( $this->getObjectKey() == '<new>' ) {
            //return $this->_getAttribute($attribute_name);
            return 0;
          }
          break;
  
        // - - - - - - - - - - - - 
        case 'write':
          // if this object is unbound, just allow access to the object-key(s)
          // this is needed to load a single object in order to set the object-id for loading
  
          // check for object-key
          if ($this->objectkey_name) {
            if ($this->bool_unbound) {
              if ($attribute_name != $this->objectkey_name) {
                print "<font color=\"red\">Could not access attribute \"$attribute_name\" for setting in object-type \"{$this->type}\", because the object is unbound, not new, ";
                print "and \"$attribute_name\" is not the object-key.</font><br>";
                return 0;
              }
            }
          } else {
            // object has got no object-key: continue work
          }
      
          break;
      }
      
      return 1;
    }


  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // OBJECT-KEY-OPERATIONS

    // ---------------------------------------------------------------------------------------
    // returns the attribute-name of the object-key
    function _getObjectKeyName() {
      // get name of key
      return $this->objectkey_name;
    }  
  
    // ---------------------------------------------------------------------------------------
    // returns the attribute-value of the object-key
    function _getObjectKey() {
  
      // get value of key
      $objectkey = $this->_getAttribute($this->objectkey_name);
  
      if ($objectkey) {
        return $objectkey;
      } else {
        // HACK: !?
        //return "<new>";
        return "<undefined>";
      }
    }  
  
    // ---------------------------------------------------------------------------------------
    // sets the attribute-value of the object-key
    function _setObjectKey($value) {
      // set value of key
      $this->_setAttribute($this->objectkey_name, $value);
    }  
  
    // ---------------------------------------------------------------------------------------
    // has this object an object-key?
    function _hasObjectKey() {
      if ($this->objectkey_name) { return 1; }
    }  
  

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // OBJECT-OPERATIONS (load/save/delete/reset/fill)

    // ---------------------------------------------------------------------------------------
    function _setupDataQuery($eventname) {
      
      if (!$eventname) {
        print "<font color=\"red\">Could not initiate any action on object \"{$this->type}\", because the eventname specified was empty. This is needed for getting the proper metadata to execute the object-operation.</font><br>";
        return;
      }

      // set class-variables
      $this->pdlEventName_CurrentObjectOperation = $eventname;
      
      // get pdl for current event from "PDLModelObject"
      if (!isset($this->ref_pdlModelObject->events[$eventname])) {
        trigger_error("DSDataObject->_validateOperation_Object(): Could not find PDLModelEvent \"$eventname\" for object-type \"$this->type\"", E_USER_ERROR);
      }
      $unreadySql = $this->ref_pdlModelObject->events[$eventname]->get_unreadySql();
    
      // initialize "DataQuery"s map-part with mapping-informations
      $this->ref_dataquery->setMap($this->ref_pdlModelObjectAttributes);
        
      // initialize "DataQuery"s sql-part with the "unready" sql-statement
      $this->ref_dataquery->setQuery($unreadySql);
      
      return 1;

    }

    // ---------------------------------------------------------------------------------------
    function _validateOperation_Object($operation_mode) {
      
      // first, distinguish between "DSDataObject" and "DSDataCollection"
      switch($this->dsType) {
        case 'DSDataObject':
          if (!$this->hasObjectKey()) {
            // TODO: CHECK THIS!!!
            //print "<font color=\"red\">Could not initiate object-operation \"$operation_mode\" on object \"{$this->type}\", because \"{$this->type}\" seems to have no object-key.</font><br>";
            //return;
          }
          break;
        case 'DSDataCollection':
          break;
      }
      
      return 1;
  
    }

    // ---------------------------------------------------------------------------------------
    function _validateOperation_Attributes($operation_mode) {
      
      /*
      object-key-juggling, we must handle a few things:
        - does this object has got object-keys or not?
        - and if it has - are they valid and stuff?
      */
      
      switch($operation_mode) {
      
        // - - - - - - - - - - - - 
        case 'load':
          if ($this->hasObjectKey()) {
            $objectkey = $this->getObjectKey();
            // define here what shall happen if an object with key "<undefined>" gets a load-request
            if ($objectkey == '<undefined>') {
              print "<font color=\"red\">Could not load object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"undefined\".</font><br>";
              return;
            }
            // define here what shall happen if an object with key "<new>" gets a load-request
            if ($objectkey == '<new>') {
              print "<font color=\"red\">Could not load object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"new\".</font><br>";
              return;
            }
          }
          break;
        
        // - - - - - - - - - - - - 
        case 'save':
          
          if ($this->hasObjectKey()) {
            $objectkey = $this->getObjectKey();
            // define here what shall happen if an object with key "<undefined>" gets a save-request
            if ($objectkey == '<undefined>') {
              print "<font color=\"red\">Could not save object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"undefined\".</font><br>";
              return;
            }
            // define here what shall happen if an object with key "<new>" gets a save-request
            if ($objectkey == '<new>') {
              //print "<font color=\"red\">Could not save object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"new\".</font><br>";
              //return;
              // overwrite the value of the objectkey-attribute
              $this->setObjectKey('null');
            }
          }
  
          break;
        
      }
      
      return 1;
  
    }
  
  
  // ---------------------------------------------------------------------------------------
  function _load_startup() {
    
    // if this object is already bound, we will skip loading it again
    // TODO: if not "bool_dirty"
    if (!$this->bool_unbound) { return; }

    // set object-state
    $this->bool_unbound = 0;
    $this->bool_created = 0;

    $bool_operation_ok = ( ($this->_validateOperation_Object('load')) && ($this->_setupDataQuery($this->pdlEventName)) );
    return $bool_operation_ok;

  }

  // ---------------------------------------------------------------------------------------
  function _save_startup() {
    
    //print "save: " . "bu: " . $this->bool_unbound . "; " . "bc: " . $this->bool_created . "\n";
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // determine pdl-event
      $eventname = '';
      // actual insert
      if ($this->bool_unbound && $this->bool_created) {
        $eventname = 'add';
      }
      // actual update
      if (!$this->bool_unbound && !$this->bool_created) {
        $eventname = 'update';
      }

    // if this object is already bound, we will skip loading it again
    // TODO: if not "bool_dirty"
    //if (!$this->bool_unbound) { return; }

    // set object-state
    //$this->bool_unbound = 0;
    //$this->bool_created = 0;
    
    $bool_operation_ok = ( ($this->_validateOperation_Object('save')) && ($this->_setupDataQuery($eventname)) );
    return $bool_operation_ok;

  }

  // ---------------------------------------------------------------------------------------
  function _delete_startup() {
    $eventname = 'remove';
    $bool_operation_ok = ( ($this->_validateOperation_Object('delete')) && ($this->_setupDataQuery($eventname)) );
    return $bool_operation_ok;
  }

  // ---------------------------------------------------------------------------------------
  function _fill($attributes_new) {
    
    // save all attribute-names in case the new ones are incomplete
    $attribute_names = array_keys($this->attributes);
    
    // overwrite original attributes with new ones
    $this->attributes = array_merge(createHash($attribute_names), $attributes_new);

    // set object-state
    if ($this->hasObjectKey()) {
      switch($this->getObjectKey()) {
        case '<undefined>':
          break;
        case '<new>':
          break;
        case '':
          break;
        // yeah, the object-key is set to a valid value, so we declare this object as "bound"
        default:
          $this->bool_unbound = 0;
          //print "-------------fill<br>";
          //$this->_load_startup();
          //$this->_setupDataQuery($this->pdlEventName);
          //print ".-...............pdl: " . $this->pdlEventName;
          //$this->filters = array();
          //$this->ref_dataquery->clearCriterias();
          //$this->reset();
          break;
      }
    }
    
  }

  // ---------------------------------------------------------------------------------------
  // declares this object as "unbound" (not loaded)
  function _unbind() {
    $this->bool_unbound = 1;
  }

  // ---------------------------------------------------------------------------------------
  // declares this object as "unbound" (not loaded)
  function _reset() {
    $this->_unbind();
  }

}


// ==============================================================
class DSDataObject extends DSAbstractObject {


  // ---------------------------------------------------------------------------------------
  function DSDataObject($type, &$ref_session) {
    // debugging
    slog("DSDataObject: new DSDataObject($type)");
    parent::DSAbstractObject($type, 'single', &$ref_session);
  }


  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // ATTRIBUTE-OPERATIONS (get/set)


    // ---------------------------------------------------------------------------------------
    function get($attribute_name) {
  
      // debugging
      slog("DSDataObject: get($attribute_name)");
  
      // attribute-access!?
      if (!$this->_checkAttributeAccess($attribute_name, 'read')) { return; }
  
      // is this object unbound? if yes, try an implicit load!
      if ( ($this->bool_unbound) && ($this->hasObjectKey()) ) {
        // we have to pre-check here if the object we want to load implicitely has got an object key - else this wouldn't make sense ...
        // ... the reason for this case is maybe because "DSDataCollection" did a "fill" on a "DSDataObject" so this object is "unbound", too
        // the normal case is that a "DSDataObject" is "unbound", so it will get an implicit "load"-request when it recieved an attribute-"get"-request here
        // the "forbidden" load of an object without object-key is also checked later in "->_validateOperation_Object()", 
        // but there the operation is cancelled with an error, here we can prevent this :-)
        $this->load();
      }
  
      // TODO: other DataCollections ( for "Associations"-functionality :-) )
  
      // TODO/HACK: this comparison doesn't ensure completely if an attribute-value is set or not ( imagine "0" (zero)!!! )
      if ( $retval = $this->_getAttribute($attribute_name) ) {
        return $retval;
      }
  
    }
    

    // ---------------------------------------------------------------------------------------
    function set($attribute_name, $value) {
      
      // attribute-access!?
      if (!$this->_checkAttributeAccess($attribute_name, 'write')) { return; }
  
      slog("DSDataObject: set($attribute_name, $value)");
      // TODO (MUST): other DataCollections
  
      $this->_setAttribute($attribute_name, $value);
    }
  
    // ---------------------------------------------------------------------------------------
    function getAll_old() {
      slog("DSDataObject: getAll()");
      return $this->attributes;
    }
    
    function setAll_old($attributes) {
      slog("DSDataObject: setAll($attributes)");
      $this->attributes = $attributes;
    }


  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // OBJECT-OPERATIONS (load/save/delete/reset/fill)


    // ---------------------------------------------------------------------------------------
    function load() {
  
      if (!$this->_load_startup()) { return; }
  
      // validate attributes to assure a good object-operation
      if (!$this->_validateOperation_Attributes('load')) {
        print "<font color=\"red\">DSDataObject->_validateOperation_Attributes('load') for \"{$this->type}\" failed.</font><br>";
      }
  
      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
      // add criteria-information to the "DataQuery" to limit the result to this single object/entry
      // HACK!!! move this functionality (':') to "...->addCriteria?)
        $this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $this->getObjectKey());
      
      
      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
      // retrieve data
        
        // execute the "DataQuery"
        $this->ref_dataquery->query();
        
        // get next (first) item of result(s)
        if ($this->ref_dataquery->next()) {
          
          // initialize attributes with loaded values
          $attributes_loaded =& $this->ref_dataquery->getResult();
  
          // fill ourself with attributes
          $this->fill($attributes_loaded);
          
          return 1;
        }
  
    }
    
  
    // ---------------------------------------------------------------------------------------
    function save() {
  
      if (!$this->_save_startup()) { return; }
  
      // catch all vars to save this object
      $this->save_catchAllVars();
  
      // validate attributes to assure a good object-operation
      if (!$this->_validateOperation_Attributes('save')) {
        print "<font color=\"red\">DSDataObject->_validateOperation_Attributes('save') for \"{$this->type}\" failed.</font><br>";
      }
  
      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
      // add criteria-information to the "DataQuery" to limit the result to this single object/entry
      // HACK!!! move this functionality (':') to "...->addCriteria?)
        //$this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $objectkey);
      
      //print $this->ref_dataquery->getSql() . "<br>";
      //print "save<br>";
      //exit;
      
      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
      // save data
        
        // execute the "DataQuery"
        $this->ref_dataquery->setData($this->attributes);
        $this->ref_dataquery->query();
        
        // TODO: review this mechanism!
        // patch object-key if this was a create-operation, because new object-keys are provided by the underlying rdbms here
        if ($this->pdlEventName_CurrentObjectOperation == 'add') {
          $this->setObjectKey($this->ref_dataquery->lastInsertId);
        }
  
    }
    
  
    // ---------------------------------------------------------------------------------------
    function delete() {
  
      if (!$this->_delete_startup()) { return; }
      $this->ref_dataquery->query();
  
  /*
      $eventname = 'remove';
  
      if (!isset($this->pdlModelObject->events[$eventname])) {
        trigger_error("could not find PDLModelObjectEvent \"$eventname\"", E_USER_ERROR);
      }
      $almost_sql = $this->pdlModelObject->events[$eventname]->getEventPdl();
      $almost_sql .= ';';
  
      $almost_sql = str_replace(':' . $this->getID_name(), "'" . $this->getID() . "'", $almost_sql);
  
      $sql = $almost_sql;
  
      if ($sql) {
        $this->dataquery->setSQL($sql);
        $this->dataquery->query();
      }
  */
  
    }

    /*
    function setMetaInfo($metainfo) {
      $this->metainfo = $metainfo;
    }
    */

  function reset() {
    parent::_reset();
  }  


  // ---------------------------------------------------------------------------------------
  function save_catchAllVars() {
    global $HTTP_GET_VARS;
    while(list($key, $value) = each($this->attributes)) {
      if (isset($HTTP_GET_VARS[$key])) {
        //$this->attributes[$key] = $HTTP_GET_VARS[$key];
        $this->_setAttribute($key, $HTTP_GET_VARS[$key]);
      }
    }
  }


}


// ==============================================================
// implements a collection of "DSDataObject"s interacting with a DataQuery
class DSDataCollection extends DSAbstractObject {

  // - - - - - - - - - - - - - - - - - - - - - -
  // data which influences the result of this "DSDataCollection"

    // filters we applied to this DataCollection (a hash of "DSFilter"-objects)
    var $filters;
    // the default concatenator for appending the "filters" to a query with already existing criteria-information
    var $filterConcatenator;
  
    // sortorders we applied to this DataCollection (a hash of "DSSortOrder"-objects)
    var $sortorders;
  
  // - - - - - - - - - - - - - - - - - - - - - -
  // miscellanious data

    // paging?
    var $page;

    // the number of results
    var $resultcount;
    
    // var $data;
    //var $metainfo;

  
  // ---------------------------------------------------------------------------------------
  function DSDataCollection($type, &$ref_session) {
    
    // call parent-constructor
    parent::DSAbstractObject($type, 'all', &$ref_session);
    
    // initialize class-variables
    $this->filters = array();
    $this->filterConcatenator = 'AND';
    $this->sortorders = array();
  }

    
  // ---------------------------------------------------------------------------------------
  // creates a new "DSFilter"-object and adds reference to local "filters"-hash
  function &addFilter($filterstring, $logicalOperator = 'AND') {
    slog("DSDataCollection: &addFilter($filterstring)");
    $r_filter = &new DSFilter($filterstring, $logicalOperator);
    $this->filters[] =& $r_filter;
    return $r_filter;
  }
  
  // ---------------------------------------------------------------------------------------
  // clears all filters from local "filters"-hash
  function clearFilters() {
    slog("DSDataCollection: clearFilters()");
    $this->filters = array();
  }


  // ---------------------------------------------------------------------------------------
  // creates a new "DSSortOrder"-object and adds reference to local "sortorders"-hash
  function &addSortOrder($column, $mode) {
    slog("DSDataCollection: &addSortOrder($column, $mode)");
    $r_order =& new DSSortOrder($column, $mode);
    array_push($this->sortorders, &$r_order);
    return $r_order;
  }


  // ---------------------------------------------------------------------------------------
  // limits DataCollection to a certain "page" (for paging of results)
  function &setPage($pagenumber, $pagesize) {
    // debugging
    slog("DSDataCollection: &setPage($pagenumber, $pagesize)");
    $this->page['number'] = $pagenumber;
    $this->page['size'] = $pagesize;
  }
  

  // ---------------------------------------------------------------------------------------
  // loads data into this "DSDataCollection"
  function load() {

    //$this->_load_startup();
    if (!$this->_load_startup()) { return; }


      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 1. process filters
        // $this->filterConcatenator
        if (isset($this->filters) && count($this->filters)) {
          reset($this->filters);
          while($r_filter =& current($this->filters)) {
            if ($strFilter = $r_filter->getParsed()) {
              //$almost_sql_FilterPart .= $strParsed . $sql_concat;
              //$this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $this->getObjectKey());
              $this->ref_dataquery->addCriteria($strFilter, $r_filter->logicalOperator);
            }
            next($this->filters);
          }
          // clear all filters
          $this->filters = array();
        }


      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 2. process orders
        if (isset($this->sortorders) && count($this->sortorders)) {
          reset($this->sortorders);
          while($r_order =& current($this->sortorders)) {
            $this->ref_dataquery->addOrder($r_order->getAttribute(), $r_order->getOrderAscDesc());
            next($this->sortorders);
          }
        }
      

      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 3. limit?
        if ( isset($this->page['number']) && isset($this->page['size']) ) {
          $nr = $this->page['number'];
          $size = $this->page['size'];
          $offset = $nr * $size;
          //$almost_sql .= " LIMIT $offset, $size";
          $strLimit = "$offset, $size";
          $this->ref_dataquery->addLimit($strLimit);
        }
      

     // fetch data
    $this->ref_dataquery->query();
    $this->resultcount = $this->ref_dataquery->getRowCount();
    $this->ref_dataquery->retrieveMetaInfo();
    //$this->metainfo = $this->dataquery->metainfo;

  }
  
  
  // ---------------------------------------------------------------------------------------
  // iterates to the next "DSDataObject" in the "DSDataCollection"-result and returns it
  function &next() {

    // debugging
    slog("DSDataCollection: &next()");

    // do an implicit load if we are "unbound"
    if ($this->bool_unbound) {
      $this->load();
    }

    // get next item from a "DataQuery"-result
    if ($this->ref_dataquery->next()) {
      $result = $this->ref_dataquery->getResult();
      //$obj =& $this->session->Map2Obj($row, $this->pdlModelObject->getObjectType() );
      //$obj =& $this->session->Map2Obj($row, $this->objecttype_full, $this->pdlEventName, $this->metainfo );
      //$obj->setMetaInfo($this->metainfo);
      $obj =& $this->ref_session->getDataObject($this->type);
      $obj->fill($result);
      //$obj->attributes =& $result;
      //$obj->bool_unbound = 0;
      return $obj;
    }
  }
  

  // ---------------------------------------------------------------------------------------
  // returns the number of results
  function getResultCount() {
    return $this->resultcount;
  }

  function reset() {
    parent::_reset();
    $this->filters = array();
    $this->sortorders = array();
    //$this->ref_dataquery->clearCriterias();
  }  
  
}

?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26