class MigrateSourceList in Migrate 7.2

Implementation of MigrateSource, providing the semantics of iterating over IDs provided by a MigrateList and retrieving data from a MigrateItem.

Hierarchy

• class \MigrateSource implements \Iterator
  • class \MigrateSourceList

File

plugins/sources/list.inc, line 81

Support for migration from sources with distinct means of listing items to import and obtaining the items themselves.

class MigrateSourceList extends MigrateSource {

  /**
   * MigrateList object used to obtain ID lists.
   *
   * @var MigrateList
   */
  protected $listClass;

  /**
   * MigrateItem object used to obtain the source object for a given ID.
   *
   * @var MigrateItem
   */
  protected $itemClass;

  /**
   * Iterator of IDs from the listing class.
   *
   * @var Iterator
   */
  protected $idIterator;

  /**
   * List of available source fields.
   *
   * @var array
   */
  protected $fields = array();

  /**
   * Simple initialization.
   */
  public function __construct(MigrateList $list_class, MigrateItem $item_class, $fields = array(), $options = array()) {
    parent::__construct($options);
    $this->listClass = $list_class;
    $this->itemClass = $item_class;
    $this->fields = $fields;
  }

  /**
   * Return a string representing the source.
   *
   * @return string
   */
  public function __toString() {
    return (string) $this->listClass;
  }

  /**
   * Return MigrateList object used to obtain ID lists.
   *
   * @return MigrateList
   */
  public function listClass() {
    return $this->listClass;
  }

  /**
   * Returns a list of fields available to be mapped from the source query.
   * Since we can't reliably figure out what "fields" are in the source,
   * it's up to the implementing Migration constructor to fill them in.
   *
   * @return array
   *  Keys: machine names of the fields (to be passed to addFieldMapping)
   *  Values: Human-friendly descriptions of the fields.
   */
  public function fields() {
    return $this->fields;
  }

  /**
   * It's the list class that knows how many records are available, so ask it.
   *
   * @return int
   */
  public function computeCount() {

    // @API: Support old count method for now.
    if (method_exists($this->listClass, 'computeCount')) {
      return $this->listClass
        ->computeCount();
    }
    else {
      return $this->listClass
        ->count();
    }
  }

  /**
   * Implementation of MigrateSource::performRewind().
   *
   * @return void
   */
  public function performRewind() {

    // If there isn't a specific ID list passed in, get it from the list class.
    if ($this->idList) {
      $this->idsToProcess = $this->idList;
    }
    else {
      $this->idsToProcess = $this->listClass
        ->getIdList();
    }
    $this->idIterator = $this->idsToProcess instanceof Iterator ? $this->idsToProcess : new ArrayIterator($this->idsToProcess);
    $this->idIterator
      ->rewind();
  }

  /**
   * Implementation of MigrateSource::getNextRow().
   *
   * @return null|stdClass
   */
  public function getNextRow() {
    $row = NULL;
    while ($this->idIterator
      ->valid()) {
      $ids = $this->idIterator
        ->current();
      $this->idIterator
        ->next();

      // Skip empty IDs
      if (empty($ids)) {
        continue;
      }

      // Got a good ID, get the data and get out.
      $row = $this->itemClass
        ->getItem($ids);
      if ($row) {

        // No matter what $ids is, be it a string, integer, object, or array, we
        // cast it to an array so that it can be properly mapped to the source
        // keys as specified by the map. This is done after getItem is called so
        // that the ItemClass doesn't have to care about this requirement.
        $ids = (array) $ids;
        foreach (array_keys($this->activeMap
          ->getSourceKey()) as $key_name) {

          // Grab the first id and advance the array cursor. Then save the ID
          // using the map source key - it will be used for mapping.
          $id = current($ids);
          next($ids);
          $row->{$key_name} = $id;
        }
        break;
      }
    }
    return $row;
  }

  /**
   * Overrides MigrateSource::hash().
   */
  protected function hash($row) {

    // Let the item class override the default hash function.
    if (method_exists($this->itemClass, 'hash')) {
      $hash = $this->itemClass
        ->hash($row);
    }
    else {
      $hash = parent::hash($row);
    }
    return $hash;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
MigrateSource::$activeMap	protected	property	The MigrateMap class for the current migration.
MigrateSource::$activeMigration	protected	property	The Migration class currently invoking us, during rewind() and next().
MigrateSource::$cacheCounts	protected	property	Whether this instance should cache the source count.
MigrateSource::$cacheKey	protected	property	Key to use for caching counts.
MigrateSource::$currentKey	protected	property	The primary key of the current row
MigrateSource::$currentRow	protected	property	The current row from the quey
MigrateSource::$highwaterField	protected	property	Information on the highwater mark for the current migration, if any.
MigrateSource::$idList	protected	property	List of source IDs to process.
MigrateSource::$mapRowAdded	protected	property	By default, next() will directly read the map row and add it to the data row. A source plugin implementation may do this itself (in particular, the SQL source can incorporate the map table into the query) - if so, it should set this TRUE so we…
MigrateSource::$multikeySeparator	protected	property	Used in the case of multiple key sources that need to use idlist.
MigrateSource::$numIgnored	protected	property	Number of rows intentionally ignored (prepareRow() returned FALSE)
MigrateSource::$numProcessed	protected	property	Number of rows we've at least looked at.	1
MigrateSource::$originalHighwater	protected	property	The highwater mark at the beginning of the import operation.
MigrateSource::$skipCount	protected	property	Whether this instance should not attempt to count the source.
MigrateSource::$trackChanges	protected	property	If TRUE, we will maintain hashed source rows to determine whether incoming data has changed.
MigrateSource::count	public	function	Return a count of available source records, from the cache if appropriate. Returns -1 if the source is not countable.
MigrateSource::current	public	function	Implementation of Iterator::current() - called when entering a loop iteration, returning the current row
MigrateSource::dataChanged	protected	function	Determine whether this row has changed, and therefore whether it should be processed.
MigrateSource::getCurrentKey	public	function
MigrateSource::getIgnored	public	function
MigrateSource::getProcessed	public	function
MigrateSource::key	public	function	Implementation of Iterator::key - called when entering a loop iteration, returning the key of the current row. It must be a scalar - we will serialize to fulfill the requirement, but using getCurrentKey() is preferable.
MigrateSource::next	public	function	Implementation of Iterator::next() - subclasses of MigrateSource should implement getNextRow() to retrieve the next valid source rocord to process.
MigrateSource::prepareRow	protected	function	Give the calling migration a shot at manipulating, and possibly rejecting, the source row.
MigrateSource::resetStats	public	function	Reset numIgnored back to 0.
MigrateSource::rewind	public	function	Implementation of Iterator::rewind() - subclasses of MigrateSource should implement performRewind() to do any class-specific setup for iterating source records.
MigrateSource::valid	public	function	Implementation of Iterator::valid() - called at the top of the loop, returning TRUE to process the loop and FALSE to terminate it
MigrateSourceList::$fields	protected	property	List of available source fields.
MigrateSourceList::$idIterator	protected	property	Iterator of IDs from the listing class.
MigrateSourceList::$itemClass	protected	property	MigrateItem object used to obtain the source object for a given ID.
MigrateSourceList::$listClass	protected	property	MigrateList object used to obtain ID lists.
MigrateSourceList::computeCount	public	function	It's the list class that knows how many records are available, so ask it.
MigrateSourceList::fields	public	function	Returns a list of fields available to be mapped from the source query. Since we can't reliably figure out what "fields" are in the source, it's up to the implementing Migration constructor to fill them in. Overrides MigrateSource::fields
MigrateSourceList::getNextRow	public	function	Implementation of MigrateSource::getNextRow().
MigrateSourceList::hash	protected	function	Overrides MigrateSource::hash(). Overrides MigrateSource::hash
MigrateSourceList::listClass	public	function	Return MigrateList object used to obtain ID lists.
MigrateSourceList::performRewind	public	function	Implementation of MigrateSource::performRewind().
MigrateSourceList::__construct	public	function	Simple initialization. Overrides MigrateSource::__construct
MigrateSourceList::__toString	public	function	Return a string representing the source.