[ Mini Kiebo ]

Server: Windows NT DESKTOP-5B8S0D4 6.2 build 9200 (Windows 8 Professional Edition) i586 Path: D:/Backup/05122024/htdocs/jurnal-kesmas/v1/lib/pkp/classes/db/ [ Home ]
File: DAOResultFactory.php
<?php

/**
 * @file classes/db/DAOResultFactory.php
 *
 * Copyright (c) 2014-2021 Simon Fraser University
 * Copyright (c) 2000-2021 John Willinsky
 * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
 *
 * @class DAOResultFactory
 *
 * @ingroup db
 *
 * @brief Wrapper around Enumerable providing "factory" features for generating
 * objects from DAOs.
 */

namespace PKP\db;

use APP\submission\DAO;
use Illuminate\Support\Collection;
use Illuminate\Support\Enumerable;
use PKP\core\ItemIterator;
use ReflectionClass;

/**
 * @template T of \PKP\core\DataObject
 * @extends ItemIterator<mixed,T>
 */
class DAOResultFactory extends ItemIterator
{
    /** @var DAO The DAO used to create objects */
    public $dao;

    /** @var string The name of the DAO's factory function (to be called with an associative array of values) */
    public $functionName;

    /**
     * @var array an array of primary key field names that uniquely
     *   identify a result row in the record set.
     */
    public $idFields;

    /** @var \Generator<int,object>|Enumerable<int,object> The results to be wrapped around */
    public $records;

    /**
     * @var string|null Fetch SQL
     */
    public $sql;

    /**
     * @var array|null Fetch parameters
     */
    public $params;

    /**
     * @var DBResultRange|null $rangeInfo Range information, if specified.
     */
    public $rangeInfo;

    /**
     * @var bool Does $functionName expect each record to be converted to an array
     */
    public $expectsArray = true;

    /** @var ?int Cached row count */
    private $rowCount = null;

    /**
     * Constructor.
     * Initialize the DAOResultFactory
     *
     * @param object $records ADO record set, Generator, or Enumerable
     * @param object $dao DAO class for factory
     * @param string $functionName The function to call on $dao to create an object
     * @param array $idFields an array of primary key field names that uniquely identify a result row in the record set. Should be data object _data array key, not database column name
     * @param string $sql Optional SQL query used to generate paged result set. Necessary when total row counts will be needed (e.g. when paging). WARNING: New code should not use this.
     * @param array $params Optional parameters for SQL query used to generate paged result set. Necessary when total row counts will be needed (e.g. when paging). WARNING: New code should not use this.
     * @param ?DBResultRange $rangeInfo Optional pagination information. WARNING: New code should not use this.
     */
    public function __construct($records, $dao, $functionName, $idFields = [], $sql = null, $params = [], $rangeInfo = null)
    {
        parent::__construct();
        $this->functionName = $functionName;
        $this->dao = $dao;
        $this->idFields = $idFields;
        $this->records = $records;
        $this->sql = $sql;
        $this->params = $params;
        $this->rangeInfo = $rangeInfo;

        // Determine if the "fromRow" method expects to receive an array or a stdClass.
        // EntityDAOs expect an object. DAOs that extend PKP\db\DAO expect an array.
        $reflector = new ReflectionClass(get_class($this->dao));
        if ($reflector->hasMethod($this->functionName)) {
            $params = $reflector->getMethod($this->functionName)->getParameters();
            if (!empty($params) && $params[0]->hasType() && $params[0]->getType()->getName() === 'object') {
                $this->expectsArray = false;
            }
        }
    }

    /**
     * Return the object representing the next row.
     *
     * @return ?T
     */
    public function next()
    {
        if ($this->records == null) {
            return $this->records;
        }

        $row = null;
        $functionName = $this->functionName;
        $dao = $this->dao;

        if ($this->records instanceof \Generator) {
            $row = $this->records->current();
            $this->records->next();
        } elseif ($this->records instanceof Collection) {
            $row = $this->records->shift();
        } else {
            throw new \Exception('Unsupported record set type (' . join(', ', class_implements($this->records)) . ')');
        }
        if (!$row) {
            return null;
        }
        if ($this->expectsArray) {
            $row = (array) $row;
        }
        return $dao->$functionName($row);
    }

    /**
     * @copydoc ItemIterator::count()
     */
    public function getCount()
    {
        if ($this->sql === null) {
            throw new \Exception('DAOResultFactory instances cannot be counted unless supplied in constructor (DAO ' . $this->dao::class . ')!');
        }
        // EntityDAOs do not support the countRecords method, but it can
        // be accessed through an instance of PKP\db\DAO attached to them
        $dao = property_exists($this->dao, 'deprecatedDao') ? $this->dao->deprecatedDao : $this->dao;
        return $this->rowCount ??= $dao->countRecords($this->sql, $this->params);
    }

    /**
     * Return the next row, with key.
     *
     * @param null|mixed $idField
     *
     * @return ?array{mixed,T} ($key, $value)
     */
    public function nextWithKey($idField = null)
    {
        $result = $this->next();
        if ($idField) {
            assert($result instanceof \PKP\core\DataObject);
            $key = $result->getData($idField);
        } elseif (empty($this->idFields)) {
            $key = null;
        } else {
            assert($result instanceof \PKP\core\DataObject && is_array($this->idFields));
            $key = '';
            foreach ($this->idFields as $idField) {
                assert(!is_null($result->getData($idField)));
                if (!empty($key)) {
                    $key .= '-';
                }
                $key .= (string)$result->getData($idField);
            }
        }
        return [$key, $result];
    }

    /**
     * Get the page number of a set that this iterator represents.
     *
     * @return int
     */
    public function getPage()
    {
        return $this->rangeInfo->getPage();
    }

    /**
     * Get the total number of pages in this set.
     *
     * @return int
     */
    public function getPageCount()
    {
        return ceil($this->getCount() / $this->rangeInfo->getCount());
    }

    /**
     * Return a boolean indicating whether or not we've reached the end of results
     *
     * @return bool
     */
    public function eof()
    {
        if ($this->records == null) {
            return true;
        }
        /** @var DAOResultIterator */
        $records = $this->records;
        return !$records->valid();
    }

    /**
     * Return true iff the result list was empty.
     *
     * @return bool
     */
    public function wasEmpty()
    {
        return $this->getCount() === 0;
    }

    /**
     * Convert this iterator to an array.
     *
     * @return T[]
     */
    public function toArray()
    {
        $returner = [];
        while ($row = $this->next()) {
            $returner[] = $row;
        }
        return $returner;
    }

    /**
     * Return an Iterator for this DAOResultFactory.
     *
     * @return DAOResultIterator<T>
     */
    public function toIterator()
    {
        return new DAOResultIterator($this);
    }

    /**
     * Convert this iterator to an associative array by database ID.
     *
     * @return array<array-key,T>
     */
    public function toAssociativeArray($idField = 'id')
    {
        $returner = [];
        while ($row = $this->next()) {
            $returner[$row->getData($idField)] = $row;
        }
        return $returner;
    }
}

if (!PKP_STRICT_MODE) {
    class_alias('\PKP\db\DAOResultFactory', '\DAOResultFactory');
}