analogueorm / analogue

src/Drivers/DBAdapter.php

Indentation +30 added lines, -30 removed lines

@@ -4,38 +4,38 @@
 
 interface DBAdapter
 {
-    /**
-     * Return's Driver specific Query Implementation.
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
-     */
-    public function getQuery();
+	/**
+	 * Return's Driver specific Query Implementation.
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
+	 */
+	public function getQuery();
 
-    /**
-     * Return the Date format used on this adapter.
-     *
-     * @return string
-     */
-    public function getDateFormat();
+	/**
+	 * Return the Date format used on this adapter.
+	 *
+	 * @return string
+	 */
+	public function getDateFormat();
 
-    /**
-     * Start a DB transaction on driver that supports it.
-     *
-     * @return void
-     */
-    public function beginTransaction();
+	/**
+	 * Start a DB transaction on driver that supports it.
+	 *
+	 * @return void
+	 */
+	public function beginTransaction();
 
-    /**
-     * Commit a DB transaction on driver that supports it.
-     *
-     * @return void
-     */
-    public function commit();
+	/**
+	 * Commit a DB transaction on driver that supports it.
+	 *
+	 * @return void
+	 */
+	public function commit();
 
-    /**
-     * Rollback a DB transaction on driver that supports it.
-     *
-     * @return void
-     */
-    public function rollback();
+	/**
+	 * Rollback a DB transaction on driver that supports it.
+	 *
+	 * @return void
+	 */
+	public function rollback();
 }

src/Drivers/IlluminateDriver.php

Indentation +36 added lines, -36 removed lines

@@ -4,44 +4,44 @@
 
 class IlluminateDriver implements DriverInterface
 {
-    /**
-     * The Illuminate Connection Provider.
-     *
-     * @var CapsuleConnectionProvider|IlluminateConnectionProvider
-     */
-    protected $connectionProvider;
+	/**
+	 * The Illuminate Connection Provider.
+	 *
+	 * @var CapsuleConnectionProvider|IlluminateConnectionProvider
+	 */
+	protected $connectionProvider;
 
-    /**
-     * IlluminateDriver constructor.
-     *
-     * @param $connectionProvider
-     */
-    public function __construct($connectionProvider)
-    {
-        $this->connectionProvider = $connectionProvider;
-    }
+	/**
+	 * IlluminateDriver constructor.
+	 *
+	 * @param $connectionProvider
+	 */
+	public function __construct($connectionProvider)
+	{
+		$this->connectionProvider = $connectionProvider;
+	}
 
-    /**
-     * Return the name of the driver.
-     *
-     * @return string
-     */
-    public function getName()
-    {
-        return 'illuminate';
-    }
+	/**
+	 * Return the name of the driver.
+	 *
+	 * @return string
+	 */
+	public function getName()
+	{
+		return 'illuminate';
+	}
 
-    /**
-     * Get Analogue DBAdapter.
-     *
-     * @param string|null $connection
-     *
-     * @return IlluminateDBAdapter
-     */
-    public function getAdapter($connection = null)
-    {
-        $connection = $this->connectionProvider->connection($connection);
+	/**
+	 * Get Analogue DBAdapter.
+	 *
+	 * @param string|null $connection
+	 *
+	 * @return IlluminateDBAdapter
+	 */
+	public function getAdapter($connection = null)
+	{
+		$connection = $this->connectionProvider->connection($connection);
 
-        return new IlluminateDBAdapter($connection);
-    }
+		return new IlluminateDBAdapter($connection);
+	}
 }

src/Drivers/CapsuleConnectionProvider.php

Indentation +24 added lines, -24 removed lines

@@ -6,30 +6,30 @@
 
 class CapsuleConnectionProvider
 {
-    /**
-     * @var Capsule
-     */
-    protected $capsule;
+	/**
+	 * @var Capsule
+	 */
+	protected $capsule;
 
-    /**
-     * CapsuleConnectionProvider constructor.
-     *
-     * @param Capsule $capsule
-     */
-    public function __construct(Capsule $capsule)
-    {
-        $this->capsule = $capsule;
-    }
+	/**
+	 * CapsuleConnectionProvider constructor.
+	 *
+	 * @param Capsule $capsule
+	 */
+	public function __construct(Capsule $capsule)
+	{
+		$this->capsule = $capsule;
+	}
 
-    /**
-     * Get a Database connection object.
-     *
-     * @param  $name
-     *
-     * @return \Illuminate\Database\Connection
-     */
-    public function connection($name = null)
-    {
-        return $this->capsule->getConnection($name);
-    }
+	/**
+	 * Get a Database connection object.
+	 *
+	 * @param  $name
+	 *
+	 * @return \Illuminate\Database\Connection
+	 */
+	public function connection($name = null)
+	{
+		return $this->capsule->getConnection($name);
+	}
 }

src/Drivers/Manager.php

Indentation +27 added lines, -27 removed lines

@@ -4,33 +4,33 @@
 
 class Manager
 {
-    /**
-     * @var DriverInterface[]
-     */
-    protected $drivers = [];
+	/**
+	 * @var DriverInterface[]
+	 */
+	protected $drivers = [];
 
-    /**
-     * Add a Mapping Driver.
-     *
-     * @param DriverInterface $driver
-     */
-    public function addDriver(DriverInterface $driver)
-    {
-        $this->drivers[$driver->getName()] = $driver;
-    }
+	/**
+	 * Add a Mapping Driver.
+	 *
+	 * @param DriverInterface $driver
+	 */
+	public function addDriver(DriverInterface $driver)
+	{
+		$this->drivers[$driver->getName()] = $driver;
+	}
 
-    /**
-     * Get the DBAdapter.
-     *
-     * @param string $driver
-     * @param string $connection connection name for drivers supporting multiple connection.
-     *
-     * @return DriverInterface|void
-     */
-    public function getAdapter($driver, $connection = null)
-    {
-        if (array_key_exists($driver, $this->drivers)) {
-            return $this->drivers[$driver]->getAdapter($connection);
-        }
-    }
+	/**
+	 * Get the DBAdapter.
+	 *
+	 * @param string $driver
+	 * @param string $connection connection name for drivers supporting multiple connection.
+	 *
+	 * @return DriverInterface|void
+	 */
+	public function getAdapter($driver, $connection = null)
+	{
+		if (array_key_exists($driver, $this->drivers)) {
+			return $this->drivers[$driver]->getAdapter($connection);
+		}
+	}
 }

src/MagicCasting.php

Indentation +102 added lines, -102 removed lines

@@ -8,117 +8,117 @@
 
 trait MagicCasting
 {
-    /**
-     * Determine if the given attribute exists.
-     *
-     * @param mixed $offset
-     *
-     * @return bool
-     */
-    public function offsetExists($offset)
-    {
-        return isset($this->$offset);
-    }
+	/**
+	 * Determine if the given attribute exists.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return bool
+	 */
+	public function offsetExists($offset)
+	{
+		return isset($this->$offset);
+	}
 
-    /**
-     * Get the value for a given offset.
-     *
-     * @param mixed $offset
-     *
-     * @return mixed
-     */
-    public function offsetGet($offset)
-    {
-        return $this->$offset;
-    }
+	/**
+	 * Get the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return mixed
+	 */
+	public function offsetGet($offset)
+	{
+		return $this->$offset;
+	}
 
-    /**
-     * Set the value for a given offset.
-     *
-     * @param mixed $offset
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function offsetSet($offset, $value)
-    {
-        $this->$offset = $value;
-    }
+	/**
+	 * Set the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function offsetSet($offset, $value)
+	{
+		$this->$offset = $value;
+	}
 
-    /**
-     * Unset the value for a given offset.
-     *
-     * @param mixed $offset
-     *
-     * @return void
-     */
-    public function offsetUnset($offset)
-    {
-        unset($this->$offset);
-    }
+	/**
+	 * Unset the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return void
+	 */
+	public function offsetUnset($offset)
+	{
+		unset($this->$offset);
+	}
 
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return $this->toArray();
-    }
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return $this->toArray();
+	}
 
-    /**
-     * Convert the entity instance to JSON.
-     *
-     * @param int $options
-     *
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        return json_encode($this->toArray(), $options);
-    }
+	/**
+	 * Convert the entity instance to JSON.
+	 *
+	 * @param int $options
+	 *
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		return json_encode($this->toArray(), $options);
+	}
 
-    /**
-     * Convert Mappable object to array;.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        return $this->attributesToArray($this->attributes);
-    }
+	/**
+	 * Convert Mappable object to array;.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return $this->attributesToArray($this->attributes);
+	}
 
-    /**
-     * Transform the Object to array/json,.
-     *
-     * @param array $sourceAttributes
-     *
-     * @return array
-     */
-    protected function attributesToArray(array $sourceAttributes)
-    {
-        $attributes = [];
+	/**
+	 * Transform the Object to array/json,.
+	 *
+	 * @param array $sourceAttributes
+	 *
+	 * @return array
+	 */
+	protected function attributesToArray(array $sourceAttributes)
+	{
+		$attributes = [];
 
-        foreach ($sourceAttributes as $key => $attribute) {
-            // If the attribute is a proxy, and hasn't be loaded, we discard
-            // it from the returned set.
-            if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
-                continue;
-            }
+		foreach ($sourceAttributes as $key => $attribute) {
+			// If the attribute is a proxy, and hasn't be loaded, we discard
+			// it from the returned set.
+			if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
+				continue;
+			}
 
-            if ($attribute instanceof Carbon) {
-                $attributes[$key] = $attribute->__toString();
-                continue;
-            }
+			if ($attribute instanceof Carbon) {
+				$attributes[$key] = $attribute->__toString();
+				continue;
+			}
 
-            if ($attribute instanceof Arrayable) {
-                $attributes[$key] = $attribute->toArray();
-            } else {
-                $attributes[$key] = $attribute;
-            }
-        }
+			if ($attribute instanceof Arrayable) {
+				$attributes[$key] = $attribute->toArray();
+			} else {
+				$attributes[$key] = $attribute;
+			}
+		}
 
-        return $attributes;
-    }
+		return $attributes;
+	}
 }

src/System/CachedRelationship.php

Indentation +59 added lines, -59 removed lines

@@ -8,69 +8,69 @@
  */
 class CachedRelationship
 {
-    /**
-     * The Hash of the related entity.
-     *
-     * @var string
-     */
-    protected $hash;
+	/**
+	 * The Hash of the related entity.
+	 *
+	 * @var string
+	 */
+	protected $hash;
 
-    /**
-     * Pivot attributes, if any.
-     *
-     * @var array
-     */
-    protected $pivotAttributes;
+	/**
+	 * Pivot attributes, if any.
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes;
 
-    /**
-     * CachedRelationship constructor.
-     *
-     * @param $hash
-     * @param array $pivotAttributes
-     */
-    public function __construct($hash, $pivotAttributes = [])
-    {
-        $this->hash = $hash;
-        $this->pivotAttributes = $pivotAttributes;
-    }
+	/**
+	 * CachedRelationship constructor.
+	 *
+	 * @param $hash
+	 * @param array $pivotAttributes
+	 */
+	public function __construct($hash, $pivotAttributes = [])
+	{
+		$this->hash = $hash;
+		$this->pivotAttributes = $pivotAttributes;
+	}
 
-    /**
-     * Return true if any pivot attributes are present.
-     *
-     * @return bool
-     */
-    public function hasPivotAttributes()
-    {
-        return count($this->pivotAttributes) > 0;
-    }
+	/**
+	 * Return true if any pivot attributes are present.
+	 *
+	 * @return bool
+	 */
+	public function hasPivotAttributes()
+	{
+		return count($this->pivotAttributes) > 0;
+	}
 
-    /**
-     * Returns the hash of the related entity.
-     *
-     * @return string
-     */
-    public function getHash()
-    {
-        return $this->hash;
-    }
+	/**
+	 * Returns the hash of the related entity.
+	 *
+	 * @return string
+	 */
+	public function getHash()
+	{
+		return $this->hash;
+	}
 
-    /**
-     * Get the cached values for the pivot attributes.
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotAttributes;
-    }
+	/**
+	 * Get the cached values for the pivot attributes.
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotAttributes;
+	}
 
-    /**
-     * Access to the hash for fast cache comparison.
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->hash;
-    }
+	/**
+	 * Access to the hash for fast cache comparison.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->hash;
+	}
 }

src/System/EntityCache.php

Indentation +337 added lines, -337 removed lines

@@ -15,341 +15,341 @@
  */
 class EntityCache
 {
-    /**
-     * Entity's raw attributes/relationships.
-     *
-     * @var array
-     */
-    protected $cache = [];
-
-    /**
-     * Entity Map for the current Entity Type.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * Wrapper factory.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Associative array containing list of pivot attributes per relationship
-     * so we don't have to call relationship method on refresh.
-     *
-     * @var array
-     */
-    protected $pivotAttributes = [];
-
-    /**
-     * EntityCache constructor.
-     *
-     * @param EntityMap $entityMap
-     */
-    public function __construct(EntityMap $entityMap)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->factory = new Factory();
-    }
-
-    /**
-     * Add an array of key=>attributes representing
-     * the initial state of loaded entities.
-     *
-     * @param array $results
-     */
-    public function add(array $results)
-    {
-        $cachedResults = [];
-
-        $keyColumn = $this->entityMap->getKeyName();
-
-        foreach ($results as $result) {
-            $id = $result[$keyColumn];
-
-            // Forget the ID field from the cache attributes
-            // to prevent any side effect.
-            unset($result[$keyColumn]);
-            $cachedResults[$id] = $result;
-        }
-
-        if (count($this->cache) == 0) {
-            $this->cache = $cachedResults;
-        } else {
-            $this->mergeCacheResults($cachedResults);
-        }
-    }
-
-    /**
-     * Retrieve initial attributes for a single entity.
-     *
-     * @param string $id
-     *
-     * @return array
-     */
-    public function get($id)
-    {
-        if ($this->has($id)) {
-            return $this->cache[$id];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Check if a record for this id exists.
-     *
-     * @param string $id
-     *
-     * @return bool
-     */
-    public function has($id)
-    {
-        return array_key_exists($id, $this->cache);
-    }
-
-    /**
-     * Combine new result set with existing attributes in
-     * cache.
-     *
-     * @param array $entities
-     *
-     * @return void
-     */
-    protected function mergeCacheResults($entities)
-    {
-        foreach ($entities as $key => $entity) {
-            $this->cache[$key] = $entity;
-        }
-    }
-
-    /**
-     * Cache Relation's query result for an entity.
-     *
-     * @param string       $key          primary key of the cached entity
-     * @param string       $relation     name of the relation
-     * @param mixed        $results      results of the relationship's query
-     * @param Relationship $relationship
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    public function cacheLoadedRelationResult($key, $relation, $results, Relationship $relationship)
-    {
-        if ($results instanceof EntityCollection) {
-            $this->cacheManyRelationResults($key, $relation, $results, $relationship);
-        }
-
-        // TODO : As we support popo Entities, Maybe this check isn't needed anymore,
-        // or we have to check that $result is an object instead
-        if ($results instanceof Mappable) {
-            $this->cacheSingleRelationResult($key, $relation, $results, $relationship);
-        }
-    }
-
-    /**
-     * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
-     *
-     * @param string       $parentKey
-     * @param string       $relation
-     * @param array        $result
-     * @param Relationship $relationship
-     *
-     * @throws MappingException
-     *
-     * @return CachedRelationship
-     */
-    protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $pivotColumns = $relationship->getPivotAttributes();
-
-        if (!array_key_exists($relation, $this->pivotAttributes)) {
-            $this->pivotAttributes[$relation] = $pivotColumns;
-        }
-
-        $wrapper = $this->factory->make($result);
-
-        $hash = $wrapper->getEntityHash();
-
-        if (count($pivotColumns) > 0) {
-            $pivotAttributes = [];
-            foreach ($pivotColumns as $column) {
-                $pivot = $wrapper->getEntityAttribute('pivot');
-
-                $pivotWrapper = $this->factory->make($pivot);
-
-                $pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
-            }
-
-            $cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
-        } else {
-            $cachedRelationship = new CachedRelationship($hash);
-        }
-
-        return $cachedRelationship;
-    }
-
-    /**
-     * Cache a many relationship.
-     *
-     * @param                  $parentKey
-     * @param string           $relation
-     * @param EntityCollection $results
-     * @param Relationship     $relationship
-     *
-     * @throws MappingException
-     */
-    protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = [];
-
-        foreach ($results as $result) {
-            $cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-
-            $relatedHash = $cachedRelationship->getHash();
-
-            $this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
-        }
-    }
-
-    /**
-     * Cache a single relationship.
-     *
-     * @param              $parentKey
-     * @param string       $relation
-     * @param Mappable     $result
-     * @param Relationship $relationship
-     *
-     * @throws MappingException
-     */
-    protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-    }
-
-    /**
-     * Get Entity's Hash.
-     *
-     * @param  $entity
-     *
-     * @throws MappingException
-     *
-     * @return string
-     */
-    protected function getEntityHash(InternallyMappable $entity)
-    {
-        $class = $entity->getEntityClass();
-
-        $mapper = Manager::getMapper($class);
-
-        $keyName = $mapper->getEntityMap()->getKeyName();
-
-        return $class.'.'.$entity->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Refresh the cache record for an aggregated entity after a write operation.
-     *
-     * @param Aggregate $entity
-     */
-    public function refresh(Aggregate $entity)
-    {
-        $this->cache[$entity->getEntityId()] = $this->transform($entity);
-    }
-
-    /**
-     * Transform an Aggregated Entity into a cache record.
-     *
-     * @param Aggregate $aggregatedEntity
-     *
-     * @throws MappingException
-     *
-     * @return array
-     */
-    protected function transform(Aggregate $aggregatedEntity)
-    {
-        $baseAttributes = $aggregatedEntity->getRawAttributes();
-
-        $relationAttributes = [];
-
-        // First we'll handle each relationships that are a one to one
-        // relation, and which will be saved as a CachedRelationship
-        // object inside the cache.
-
-        // NOTE : storing localRelationships maybe useless has we store
-        // the foreign key in the attributes already.
-
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
-
-            if (count($aggregates) == 1) {
-                $related = $aggregates[0];
-                $relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
-            }
-            if (count($aggregates) > 1) {
-                throw new MappingException("Single Relationship '$relation' contains several related entities");
-            }
-        }
-
-        // Then we'll handle the 'many' relationships and store them as
-        // an array of CachedRelationship objects.
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
-
-            $relationAttributes[$relation] = [];
-
-            foreach ($aggregates as $aggregate) {
-                $relationAttributes[$relation][] = new CachedRelationship(
-                    $aggregate->getEntityHash(),
-                    $aggregate->getPivotAttributes()
-                );
-            }
-        }
-
-        return $baseAttributes + $relationAttributes;
-    }
-
-    /**
-     * Get pivot attributes for a relation.
-     *
-     * @param string             $relation
-     * @param InternallyMappable $entity
-     *
-     * @return array
-     */
-    protected function getPivotValues($relation, InternallyMappable $entity)
-    {
-        $values = [];
-
-        $entityAttributes = $entity->getEntityAttributes();
-
-        if (array_key_exists($relation, $this->pivotAttributes)) {
-            foreach ($this->pivotAttributes[$relation] as $attribute) {
-                if (array_key_exists($attribute, $entityAttributes)) {
-                    $values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
-                }
-            }
-        }
-
-        return $values;
-    }
-
-    /**
-     * Clear the entity Cache. Use with caution as it could result
-     * in impredictable behaviour if the cached entities are stored
-     * after the cache clear operation.
-     *
-     * @return void
-     */
-    public function clear()
-    {
-        $this->cache = [];
-        $this->pivotAttributes = [];
-    }
+	/**
+	 * Entity's raw attributes/relationships.
+	 *
+	 * @var array
+	 */
+	protected $cache = [];
+
+	/**
+	 * Entity Map for the current Entity Type.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * Wrapper factory.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Associative array containing list of pivot attributes per relationship
+	 * so we don't have to call relationship method on refresh.
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes = [];
+
+	/**
+	 * EntityCache constructor.
+	 *
+	 * @param EntityMap $entityMap
+	 */
+	public function __construct(EntityMap $entityMap)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->factory = new Factory();
+	}
+
+	/**
+	 * Add an array of key=>attributes representing
+	 * the initial state of loaded entities.
+	 *
+	 * @param array $results
+	 */
+	public function add(array $results)
+	{
+		$cachedResults = [];
+
+		$keyColumn = $this->entityMap->getKeyName();
+
+		foreach ($results as $result) {
+			$id = $result[$keyColumn];
+
+			// Forget the ID field from the cache attributes
+			// to prevent any side effect.
+			unset($result[$keyColumn]);
+			$cachedResults[$id] = $result;
+		}
+
+		if (count($this->cache) == 0) {
+			$this->cache = $cachedResults;
+		} else {
+			$this->mergeCacheResults($cachedResults);
+		}
+	}
+
+	/**
+	 * Retrieve initial attributes for a single entity.
+	 *
+	 * @param string $id
+	 *
+	 * @return array
+	 */
+	public function get($id)
+	{
+		if ($this->has($id)) {
+			return $this->cache[$id];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Check if a record for this id exists.
+	 *
+	 * @param string $id
+	 *
+	 * @return bool
+	 */
+	public function has($id)
+	{
+		return array_key_exists($id, $this->cache);
+	}
+
+	/**
+	 * Combine new result set with existing attributes in
+	 * cache.
+	 *
+	 * @param array $entities
+	 *
+	 * @return void
+	 */
+	protected function mergeCacheResults($entities)
+	{
+		foreach ($entities as $key => $entity) {
+			$this->cache[$key] = $entity;
+		}
+	}
+
+	/**
+	 * Cache Relation's query result for an entity.
+	 *
+	 * @param string       $key          primary key of the cached entity
+	 * @param string       $relation     name of the relation
+	 * @param mixed        $results      results of the relationship's query
+	 * @param Relationship $relationship
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	public function cacheLoadedRelationResult($key, $relation, $results, Relationship $relationship)
+	{
+		if ($results instanceof EntityCollection) {
+			$this->cacheManyRelationResults($key, $relation, $results, $relationship);
+		}
+
+		// TODO : As we support popo Entities, Maybe this check isn't needed anymore,
+		// or we have to check that $result is an object instead
+		if ($results instanceof Mappable) {
+			$this->cacheSingleRelationResult($key, $relation, $results, $relationship);
+		}
+	}
+
+	/**
+	 * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
+	 *
+	 * @param string       $parentKey
+	 * @param string       $relation
+	 * @param array        $result
+	 * @param Relationship $relationship
+	 *
+	 * @throws MappingException
+	 *
+	 * @return CachedRelationship
+	 */
+	protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$pivotColumns = $relationship->getPivotAttributes();
+
+		if (!array_key_exists($relation, $this->pivotAttributes)) {
+			$this->pivotAttributes[$relation] = $pivotColumns;
+		}
+
+		$wrapper = $this->factory->make($result);
+
+		$hash = $wrapper->getEntityHash();
+
+		if (count($pivotColumns) > 0) {
+			$pivotAttributes = [];
+			foreach ($pivotColumns as $column) {
+				$pivot = $wrapper->getEntityAttribute('pivot');
+
+				$pivotWrapper = $this->factory->make($pivot);
+
+				$pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
+			}
+
+			$cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
+		} else {
+			$cachedRelationship = new CachedRelationship($hash);
+		}
+
+		return $cachedRelationship;
+	}
+
+	/**
+	 * Cache a many relationship.
+	 *
+	 * @param                  $parentKey
+	 * @param string           $relation
+	 * @param EntityCollection $results
+	 * @param Relationship     $relationship
+	 *
+	 * @throws MappingException
+	 */
+	protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = [];
+
+		foreach ($results as $result) {
+			$cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+
+			$relatedHash = $cachedRelationship->getHash();
+
+			$this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
+		}
+	}
+
+	/**
+	 * Cache a single relationship.
+	 *
+	 * @param              $parentKey
+	 * @param string       $relation
+	 * @param Mappable     $result
+	 * @param Relationship $relationship
+	 *
+	 * @throws MappingException
+	 */
+	protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+	}
+
+	/**
+	 * Get Entity's Hash.
+	 *
+	 * @param  $entity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return string
+	 */
+	protected function getEntityHash(InternallyMappable $entity)
+	{
+		$class = $entity->getEntityClass();
+
+		$mapper = Manager::getMapper($class);
+
+		$keyName = $mapper->getEntityMap()->getKeyName();
+
+		return $class.'.'.$entity->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Refresh the cache record for an aggregated entity after a write operation.
+	 *
+	 * @param Aggregate $entity
+	 */
+	public function refresh(Aggregate $entity)
+	{
+		$this->cache[$entity->getEntityId()] = $this->transform($entity);
+	}
+
+	/**
+	 * Transform an Aggregated Entity into a cache record.
+	 *
+	 * @param Aggregate $aggregatedEntity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return array
+	 */
+	protected function transform(Aggregate $aggregatedEntity)
+	{
+		$baseAttributes = $aggregatedEntity->getRawAttributes();
+
+		$relationAttributes = [];
+
+		// First we'll handle each relationships that are a one to one
+		// relation, and which will be saved as a CachedRelationship
+		// object inside the cache.
+
+		// NOTE : storing localRelationships maybe useless has we store
+		// the foreign key in the attributes already.
+
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
+
+			if (count($aggregates) == 1) {
+				$related = $aggregates[0];
+				$relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
+			}
+			if (count($aggregates) > 1) {
+				throw new MappingException("Single Relationship '$relation' contains several related entities");
+			}
+		}
+
+		// Then we'll handle the 'many' relationships and store them as
+		// an array of CachedRelationship objects.
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
+
+			$relationAttributes[$relation] = [];
+
+			foreach ($aggregates as $aggregate) {
+				$relationAttributes[$relation][] = new CachedRelationship(
+					$aggregate->getEntityHash(),
+					$aggregate->getPivotAttributes()
+				);
+			}
+		}
+
+		return $baseAttributes + $relationAttributes;
+	}
+
+	/**
+	 * Get pivot attributes for a relation.
+	 *
+	 * @param string             $relation
+	 * @param InternallyMappable $entity
+	 *
+	 * @return array
+	 */
+	protected function getPivotValues($relation, InternallyMappable $entity)
+	{
+		$values = [];
+
+		$entityAttributes = $entity->getEntityAttributes();
+
+		if (array_key_exists($relation, $this->pivotAttributes)) {
+			foreach ($this->pivotAttributes[$relation] as $attribute) {
+				if (array_key_exists($attribute, $entityAttributes)) {
+					$values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
+				}
+			}
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Clear the entity Cache. Use with caution as it could result
+	 * in impredictable behaviour if the cached entities are stored
+	 * after the cache clear operation.
+	 *
+	 * @return void
+	 */
+	public function clear()
+	{
+		$this->cache = [];
+		$this->pivotAttributes = [];
+	}
 }

src/System/EntityBuilder.php

Indentation +161 added lines, -161 removed lines

@@ -9,165 +9,165 @@
  */
 class EntityBuilder
 {
-    /**
-     * The mapper for the entity to build.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * Relations that are eager loaded on this query.
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * Relations that will be lazy loaded on this query.
-     *
-     * @var array
-     */
-    protected $lazyLoads;
-
-    /**
-     * @var array
-     */
-    protected $casts;
-
-    /**
-     * Entity Wrapper Factory.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * EntityBuilder constructor.
-     *
-     * @param Mapper $mapper
-     * @param array  $eagerLoads
-     */
-    public function __construct(Mapper $mapper, array $eagerLoads)
-    {
-        $this->mapper = $mapper;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->eagerLoads = $eagerLoads;
-
-        $this->lazyLoads = $this->getRelationshipsToProxy();
-
-        $this->factory = new Factory();
-    }
-
-    /**
-     * Convert an array of values into an entity.
-     *
-     * @param array $result
-     *
-     * @return array
-     */
-    public function build(array $result)
-    {
-        $instance = $this->getWrapperInstance();
-
-        // Hydrate any embedded Value Object
-        //
-        // TODO Move this to the result builder instead,
-        // as we'll handle this the same way as they were
-        // eager loaded relationships.
-        $this->hydrateValueObjects($result);
-
-        $instance->setEntityAttributes($result);
-
-        // Hydrate relationship attributes with lazyloading proxies
-        if (count($this->lazyLoads) > 0) {
-            $instance->setProxies($this->lazyLoads);
-        }
-
-        // Hydrate and return the instance
-        $instance->hydrate();
-        $entity = $instance->getObject();
-
-        return $entity;
-    }
-
-    /**
-     * Get the correct wrapper prototype corresponding to the object type.
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return InternallyMappable
-     */
-    protected function getWrapperInstance()
-    {
-        return $this->factory->make($this->mapper->newInstance());
-    }
-
-    /**
-     * Hydrate value object embedded in this entity.
-     *
-     * @param array $attributes
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return void
-     */
-    protected function hydrateValueObjects(&$attributes)
-    {
-        foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
-            $this->hydrateValueObject($attributes, $localKey, $valueClass);
-        }
-    }
-
-    /**
-     * Hydrate a single value object.
-     *
-     * @param array  $attributes
-     * @param string $localKey
-     * @param string $valueClass
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return void
-     */
-    protected function hydrateValueObject(&$attributes, $localKey, $valueClass)
-    {
-        $map = $this->mapper->getManager()->getValueMap($valueClass);
-
-        $embeddedAttributes = $map->getAttributes();
-
-        $valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
-        $voWrapper = $this->factory->make($valueObject);
-
-        foreach ($embeddedAttributes as $key) {
-            $prefix = snake_case(class_basename($valueClass)).'_';
-
-            $voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
-
-            unset($attributes[$prefix.$key]);
-        }
-
-        $attributes[$localKey] = $voWrapper->getObject();
-    }
-
-    /**
-     * Deduce the relationships for which we will build lazy loading proxies.
-     *
-     * @return array
-     */
-    protected function getRelationshipsToProxy()
-    {
-        $relations = $this->entityMap->getRelationships();
-
-        return array_diff($relations, $this->eagerLoads);
-    }
+	/**
+	 * The mapper for the entity to build.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * Relations that are eager loaded on this query.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * Relations that will be lazy loaded on this query.
+	 *
+	 * @var array
+	 */
+	protected $lazyLoads;
+
+	/**
+	 * @var array
+	 */
+	protected $casts;
+
+	/**
+	 * Entity Wrapper Factory.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * EntityBuilder constructor.
+	 *
+	 * @param Mapper $mapper
+	 * @param array  $eagerLoads
+	 */
+	public function __construct(Mapper $mapper, array $eagerLoads)
+	{
+		$this->mapper = $mapper;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->eagerLoads = $eagerLoads;
+
+		$this->lazyLoads = $this->getRelationshipsToProxy();
+
+		$this->factory = new Factory();
+	}
+
+	/**
+	 * Convert an array of values into an entity.
+	 *
+	 * @param array $result
+	 *
+	 * @return array
+	 */
+	public function build(array $result)
+	{
+		$instance = $this->getWrapperInstance();
+
+		// Hydrate any embedded Value Object
+		//
+		// TODO Move this to the result builder instead,
+		// as we'll handle this the same way as they were
+		// eager loaded relationships.
+		$this->hydrateValueObjects($result);
+
+		$instance->setEntityAttributes($result);
+
+		// Hydrate relationship attributes with lazyloading proxies
+		if (count($this->lazyLoads) > 0) {
+			$instance->setProxies($this->lazyLoads);
+		}
+
+		// Hydrate and return the instance
+		$instance->hydrate();
+		$entity = $instance->getObject();
+
+		return $entity;
+	}
+
+	/**
+	 * Get the correct wrapper prototype corresponding to the object type.
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return InternallyMappable
+	 */
+	protected function getWrapperInstance()
+	{
+		return $this->factory->make($this->mapper->newInstance());
+	}
+
+	/**
+	 * Hydrate value object embedded in this entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return void
+	 */
+	protected function hydrateValueObjects(&$attributes)
+	{
+		foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
+			$this->hydrateValueObject($attributes, $localKey, $valueClass);
+		}
+	}
+
+	/**
+	 * Hydrate a single value object.
+	 *
+	 * @param array  $attributes
+	 * @param string $localKey
+	 * @param string $valueClass
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return void
+	 */
+	protected function hydrateValueObject(&$attributes, $localKey, $valueClass)
+	{
+		$map = $this->mapper->getManager()->getValueMap($valueClass);
+
+		$embeddedAttributes = $map->getAttributes();
+
+		$valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
+		$voWrapper = $this->factory->make($valueObject);
+
+		foreach ($embeddedAttributes as $key) {
+			$prefix = snake_case(class_basename($valueClass)).'_';
+
+			$voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
+
+			unset($attributes[$prefix.$key]);
+		}
+
+		$attributes[$localKey] = $voWrapper->getObject();
+	}
+
+	/**
+	 * Deduce the relationships for which we will build lazy loading proxies.
+	 *
+	 * @return array
+	 */
+	protected function getRelationshipsToProxy()
+	{
+		$relations = $this->entityMap->getRelationships();
+
+		return array_diff($relations, $this->eagerLoads);
+	}
 }

src/System/Wrappers/Wrapper.php

Indentation +204 added lines, -204 removed lines

@@ -10,208 +10,208 @@
  */
 abstract class Wrapper implements InternallyMappable
 {
-    /**
-     * Original Entity Object.
-     *
-     * @var mixed
-     */
-    protected $entity;
-
-    /**
-     * Corresponding EntityMap.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * @var \Analogue\ORM\System\Proxirs\ProxyFactory
-     */
-    protected $proxyFactory;
-
-    /**
-     * Wrapper constructor.
-     *
-     * @param $entity
-     * @param $entityMap
-     */
-    public function __construct($entity, $entityMap)
-    {
-        $this->entity = $entity;
-        $this->entityMap = $entityMap;
-        $this->proxyFactory = new ProxyFactory();
-    }
-
-    /**
-     * Return the wrapped entity class.
-     *
-     * @return mixed
-     */
-    public function getEntityClass()
-    {
-        return get_class($this->entity);
-    }
-
-    /**
-     * Return the entity's primary key valuye.
-     *
-     * @return string
-     */
-    public function getEntityKey()
-    {
-        return $this->getEntityAttribute($this->entityMap->getKeyName());
-    }
-
-    /**
-     * Return the Entity class/primary key couple,
-     * which is used for internall operations.
-     *
-     * @return string
-     */
-    public function getEntityHash()
-    {
-        return $this->getEntityClass().'.'.$this->getEntityKey();
-    }
-
-    /**
-     * Returns the wrapped entity.
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        return $this->entity;
-    }
-
-    /**
-     * Returns the wrapped entity's map.
-     *
-     * @return mixed
-     */
-    public function getMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity objet.
-     *
-     * @param array $relations list of relations to be lazy loaded
-     *
-     * @return void
-     */
-    public function setProxies(array $relations = null)
-    {
-        $attributes = $this->getEntityAttributes();
-        $proxies = [];
-
-        if (is_null($relations)) {
-            $relations = $this->getRelationsToProxy();
-        }
-
-        foreach ($relations as $relation) {
-            // We first look if we need to build the proxy on the relationship.
-            // If the key is handled locally and we know it not to be set,
-            // we'll set the relationship to null
-            if (!$this->relationNeedsProxy($relation, $attributes)) {
-                $proxies[$relation] = null;
-            } else {
-                $targetClass = $this->entityMap->getTargettedClass($relation);
-                $proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
-            }
-        }
-
-        foreach ($proxies as $key => $value) {
-            $this->setEntityAttribute($key, $value);
-        }
-    }
-
-    /**
-     * Determine which relations we have to build proxy for, by parsing
-     * attributes and finding methods that aren't set.
-     *
-     * @return array
-     */
-    protected function getRelationsToProxy()
-    {
-        $proxies = [];
-        $attributes = $this->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                $proxies[] = $relation;
-            }
-        }
-
-        return $proxies;
-    }
-
-    /**
-     * Determine if the relation needs a proxy or not.
-     *
-     * @param string $relation
-     * @param array  $attributes
-     *
-     * @return bool
-     */
-    protected function relationNeedsProxy($relation, $attributes)
-    {
-        if (in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
-            return false;
-        }
-
-        $localKey = $this->entityMap->getLocalKeys($relation);
-
-        if (is_null($localKey)) {
-            return true;
-        }
-
-        if (is_array($localKey)) {
-            $localKey = $localKey['id'];
-        }
-
-        if (!isset($attributes[$localKey])) {
-            return false;
-        }
-
-        if (is_null($attributes[$localKey])) {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @param string $key
-     * @param string $value
-     *
-     * @return mixed
-     */
-    abstract public function setEntityAttribute($key, $value);
-
-    /**
-     * @param string $key
-     *
-     * @return mixed
-     */
-    abstract public function getEntityAttribute($key);
-
-    /**
-     * @param array $attributes
-     *
-     * @return mixed
-     */
-    abstract public function setEntityAttributes(array $attributes);
-
-    /**
-     * @return mixed
-     */
-    abstract public function getEntityAttributes();
-
-    /**
-     * @param string $key
-     *
-     * @return mixed
-     */
-    abstract public function hasAttribute($key);
+	/**
+	 * Original Entity Object.
+	 *
+	 * @var mixed
+	 */
+	protected $entity;
+
+	/**
+	 * Corresponding EntityMap.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * @var \Analogue\ORM\System\Proxirs\ProxyFactory
+	 */
+	protected $proxyFactory;
+
+	/**
+	 * Wrapper constructor.
+	 *
+	 * @param $entity
+	 * @param $entityMap
+	 */
+	public function __construct($entity, $entityMap)
+	{
+		$this->entity = $entity;
+		$this->entityMap = $entityMap;
+		$this->proxyFactory = new ProxyFactory();
+	}
+
+	/**
+	 * Return the wrapped entity class.
+	 *
+	 * @return mixed
+	 */
+	public function getEntityClass()
+	{
+		return get_class($this->entity);
+	}
+
+	/**
+	 * Return the entity's primary key valuye.
+	 *
+	 * @return string
+	 */
+	public function getEntityKey()
+	{
+		return $this->getEntityAttribute($this->entityMap->getKeyName());
+	}
+
+	/**
+	 * Return the Entity class/primary key couple,
+	 * which is used for internall operations.
+	 *
+	 * @return string
+	 */
+	public function getEntityHash()
+	{
+		return $this->getEntityClass().'.'.$this->getEntityKey();
+	}
+
+	/**
+	 * Returns the wrapped entity.
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		return $this->entity;
+	}
+
+	/**
+	 * Returns the wrapped entity's map.
+	 *
+	 * @return mixed
+	 */
+	public function getMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity objet.
+	 *
+	 * @param array $relations list of relations to be lazy loaded
+	 *
+	 * @return void
+	 */
+	public function setProxies(array $relations = null)
+	{
+		$attributes = $this->getEntityAttributes();
+		$proxies = [];
+
+		if (is_null($relations)) {
+			$relations = $this->getRelationsToProxy();
+		}
+
+		foreach ($relations as $relation) {
+			// We first look if we need to build the proxy on the relationship.
+			// If the key is handled locally and we know it not to be set,
+			// we'll set the relationship to null
+			if (!$this->relationNeedsProxy($relation, $attributes)) {
+				$proxies[$relation] = null;
+			} else {
+				$targetClass = $this->entityMap->getTargettedClass($relation);
+				$proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
+			}
+		}
+
+		foreach ($proxies as $key => $value) {
+			$this->setEntityAttribute($key, $value);
+		}
+	}
+
+	/**
+	 * Determine which relations we have to build proxy for, by parsing
+	 * attributes and finding methods that aren't set.
+	 *
+	 * @return array
+	 */
+	protected function getRelationsToProxy()
+	{
+		$proxies = [];
+		$attributes = $this->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				$proxies[] = $relation;
+			}
+		}
+
+		return $proxies;
+	}
+
+	/**
+	 * Determine if the relation needs a proxy or not.
+	 *
+	 * @param string $relation
+	 * @param array  $attributes
+	 *
+	 * @return bool
+	 */
+	protected function relationNeedsProxy($relation, $attributes)
+	{
+		if (in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
+			return false;
+		}
+
+		$localKey = $this->entityMap->getLocalKeys($relation);
+
+		if (is_null($localKey)) {
+			return true;
+		}
+
+		if (is_array($localKey)) {
+			$localKey = $localKey['id'];
+		}
+
+		if (!isset($attributes[$localKey])) {
+			return false;
+		}
+
+		if (is_null($attributes[$localKey])) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return mixed
+	 */
+	abstract public function setEntityAttribute($key, $value);
+
+	/**
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	abstract public function getEntityAttribute($key);
+
+	/**
+	 * @param array $attributes
+	 *
+	 * @return mixed
+	 */
+	abstract public function setEntityAttributes(array $attributes);
+
+	/**
+	 * @return mixed
+	 */
+	abstract public function getEntityAttributes();
+
+	/**
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	abstract public function hasAttribute($key);
 }