CODEWITHSUNDEEP
phpdesign-patternsproxy
DatsunBing
DatsunBing

Reputation: 9076

In php, how can I determine equality when an object proxy is involved?

In my php application I have been comparing objects with the usual equality comparison operator, e.g.:

if ($objectA == $objectB) { ... }

Recently I implemented proxies (for objects which are expensive to load) however this means the equality operator no longer works. Is there a simple way around this? One that doesn't rely on reflection?

For the moment, I have resorted to testing the unique identifier of each object, e.g.

if ($objectA->getId() == $objectB->getId) { ... }

But this has two problems: 1) I need to refactor all existing code, and 2) in the future I may need to compare objects which are value objects (not entities).

I'm not hopeful of an easy solution since I think it would require a new magic method...

Here's my AbstractProxy class. Any help appreciated...

abstract class KOOP_Base_AbstractProxy
    implements KOOP_Base_iDomain
{
    use KOOP_Trait_Helper_Helper;

    /**
     * @var integer Object identifier
     */
    protected $_id = null;

    /**
     * @var KOOP_Base_AbstractMapper
     */
    protected $_mapper = null;

    /**
     * @var KOOP_Base_AbstractDomain Actual object
     */
    protected $_subject = null;

    /**
     * Store object id for lazy loading
     *
     * @param integer   $id Object identifier
     * @param string    $mapper Mapper by which to retrieve object
     */
    public function __construct($id, $mapper)
    {
        $this->_id = $id;
        $this->_mapper = $mapper;
    }

    /**
     * Get subject
     *
     * @return KOOP_Base_AbstractDomain
     */
    protected function getSubject()
    {
        if (!$this->_subject) {
            $this->_subject = $this->getMapper($this->_mapper)->find($this->_id);
        }
        return $this->_subject;
    }

    /**
     * Get property
     *
     * @param string $property
     * @return mixed
     */
    public function __get($property)
    {
        return $this->getSubject()->$property;
    }

    /**
     * Set property
     *
     * @param string $property
     * @param mixed $value
     * @return void
     */
    public function __set($property, $value)
    {
        $this->getSubject()->$property = $value;
    }

    /**
     * Is property set?
     *
     * @param $property
     * @return boolean
     */
    public function __isset($property)
    {
        return isset($this->getSubject()->$property);
    }

    /**
     * Unset property
     *
     * @param string $property
     * @return mixed
     */
    public function __unset($property)
    {
        unset($this->getSubject()->$property);
    }

    /**
     * Call method
     *
     * @param   string $method Method to call
     * @param   array  $params Parameters to pass
     * @return  mixed
     */
    public function __call($method, array $params)
    {
        return call_user_func_array(array($this->getSubject(), $method), $params);
    }

    /**
     * Get id
     *
     * Saves having to retrieve the entire object when only the ID is required.
     */
    public function getId()
    {
        return $this->_id;
    }
}

Upvotes: 1

Views: 138

Answers (1)

BrianH
BrianH

Reputation: 2133

Proxies do break object equality, and there's no utterly clean way to fix this. In a fully object oriented language you would handle this by operator overloading (which I don't recommend) or implementing a custom .equals() function (as in Java). Sadly, PHP simply does not support object orientation at this level, so you will have some decisions to make.

1) I would prefer to have your proxy class provide an equals() function which takes as input a reference to the object you want to test against and compares it to the proxied object - which shouldn't be much more 'expensive' than it was to not use a proxy at all. Example in pseudo-PHP code (my apologies if my reference syntax is off, it's been a while):

public function equals (&$toCompare)
{

 if ($_subject == $toCompare)
 {
    return true;
 }
 else
 {
    return false;
 }

}

The downside is simple: you have to refactor your code that involves this proxied object, and you have to remember that "==" does not work on this proxied object type while you are working. If you don't deal with these objects much, or if you deal with them all the time, this is fine. If you deal with them regularly but intermittently, or if others must work with them on occasion, then this will cause bugs when you/they forget about this equality problem.

2) Use an Operator Overloading extension to the language. I haven't done this, I don't know if it works, and it might be a nightmare. I include it for theoretical completeness.

Personally, I think I'd just hack it with the pseudo-Java approach call it a day, as I think it would actually work and require nothing more than using the function correctly (and remembering to use it in the first place).

Upvotes: 1

Related Questions