storage enhancements

[m6w6/pq-gateway] / lib / pq / Mapper / Map.php

<?php

namespace pq\Mapper;

use pq\Gateway\Row;
use pq\Gateway\Rowset;
use pq\Gateway\Table;
use pq\Gateway\Table\Reference;
use pq\Query\Expr;

class Map implements MapInterface
{
        /**
         * @var string
         */
        private $class;

        /**
         * @var Table
         */
        private $gateway;

        /**
         * @var ObjectManager
         */
        private $objects;

        /**
         * @var PropertyInterface[]
         */
        private $properties = [];

        /**
         * Create a new object map definition
         * @param string $class
         * @param Table $gateway
         * @param ...PropertyInterface $properties
         */
        function __construct($class, Table $gateway, PropertyInterface ...$properties) {
                $this->class = $class;
                $this->gateway = $gateway;
                foreach ($properties as $property) {
                        $this->addProperty($property);
                }
                $this->objects = new ObjectManager($this);
        }

        /**
         * Get the name of the mapped class
         * @return string
         */
        function getClass() {
                return $this->class;
        }

        /**
         * Get the object manager
         * @return ObjectManager
         */
        function getObjects() {
                return $this->objects;
        }

        /**
         * Get the underlying table gateway
         * @return Table
         */
        function getGateway() {
                return $this->gateway;
        }

        /**
         * Get the defined properties to map
         * @return PropertyInterface[]
         */
        function getProperties() {
                return $this->properties;
        }

        /**
         * Add a property to map
         * @param PropertyInterface $property
         * @return Map
         */
        function addProperty(PropertyInterface $property) {
                $property->setContainer($this);
                $this->properties[] = $property;
                return $this;
        }

        /**
         * Get all child rows by foreign key
         * @param Row $row
         * @param string $refName
         * @param array $objects
         * @return Rowset
         */
        function allOf(Row $row, $refName, &$objects = null) {
                /* apply objectOf to populate the object cache */
                return $this->gateway->of($row, $refName)->apply(function($row) use(&$objects) {
                        $objects[] = $this->objects->asObject($row);
                });
        }

        /**
         * Get the parent row by foreign key
         * @param Row $row
         * @param string $refName
         * @param array $objects
         * @return Rowset
         */
        function refOf(Row $row, $refName, &$objects = null) {
                $rid = [];
                $rel = $row->getTable()->getRelation($this->gateway->getName(), $refName);
                // FIXME: check if foreign key points to primary key
                foreach ($rel as $fgn => $col) {
                        $rid[$col] = $row->$fgn->get();
                }
                $rid = $this->objects->serializeRowId($rid);
                if ($this->objects->hasObject($rid)) {
                        $object = $this->objects->getObjectById($rid);
                        $row = $this->objects->getRow($object);
                        $objects[] = $object;
                        $rowset = new Rowset($this->gateway);
                        return $rowset->append($row);
                }
                /* apply objectOf to populate the object cache */
                return $this->gateway->by($row, $refName)->apply(function($row) use(&$objects) {
                        $objects[] = $this->objects->asObject($row);
                });
        }

        /**
         * Get the table relation reference
         * @param MapInterface $map
         * @param string $refName
         * @return Reference
         */
        function relOf(MapInterface $map, $refName) {
                return $map->getGateway()->getRelation(
                        $this->gateway->getName(), $refName);
        }

        /**
         * Drain the deferred callback queue
         * @param callable[] $deferred
         * @param callable $exec
         */
        private function drain(array $deferred, callable $exec) {
                while ($deferred) {
                        $cb = array_shift($deferred);
                        if (($cb = $exec($cb))) {
                                $deferred[] = $cb;
                        }
                }
        }

        /**
         * Map a row to an object
         * @param Row $row
         * @return object
         */
        function map(Row $row) {
                $deferred = [];
                $object = $this->objects->asObject($row);
                foreach ($this->properties as $property) {
                        if (($cb = $property->read($row, $object))) {
                                $deferred[] = $cb;
                        }
                }
                $this->drain($deferred, function(callable $cb) use($row, $object) {
                        return $cb($row, $object);
                });
                return $object;
        }

        /**
         * Map a rowset to an array of objects
         * @param Rowset $rows
         * @return object[]
         */
        function mapAll(Rowset $rows) {
                $objects = [];
                foreach ($rows as $row) {
                        $objects[] = $this->map($row);
                }
                return $objects;
        }

        /**
         * Unmap on object
         * @param object $object
         */
        function unmap($object) {
                $deferred = [];
                /* @var $row Row */
                $row = $this->objects->asRow($object);
                $upd = $this->objects->rowId($row, true);
                foreach ($this->properties as $property) {
                        if (($cb = $property->write($object, $row))) {
                                $deferred[] = $cb;
                        }
                }
                foreach ($this->gateway->getIdentity() as $col) {
                        if (null === $row->$col->get()
                        || ($row->$col->isExpr() && $row->$col->get()->isNull()))
                        {
                                $row->$col = new Expr("DEFAULT");
                        }
                }
                if ($row->isDirty()) {
                        if ($upd) {
                                $row->update();
                        } else {
                                $row->create();
                        }
                }
                foreach ($this->properties as $property) {
                        if (($cb = $property->read($row, $object))) {
                                $deferred[] = $cb;
                        }
                }
                $this->drain($deferred, function($cb) use($object, $row) {
                        return $cb($object, $row);
                });
                if ($row->isDirty()) {
                        $row->update();
                }
        }
}