new overloading feature?

Why not using Singleton for multiple objects with getInstance() ?

Andrey

Derrell.Lipman@UnwiredUniverse.com wrote:

I came across an interesting desire today. I'd like to create a new class
instance if an only if a "key" value does not already exist. This key value
could be looked up in a database, in an array, etc.

The following contrived example shows use of a proposed __new() overload
function which would be called BEFORE the constructor, and could chose to
return a newly constructed object (by calling __construct()) or to return an
already existing object.

One could certainly call a function which searched for the key value and only
instantiated a new object if the existing one was not found, but this seems
cleaner.

Thoughts?

<?php

class X
{
static $allX = array();
var $val;

function __construct($val)
{
    $this->val = $val;
    X::$allX[] =& $this;
}

function __new($val)
{
    foreach (X::$allX as $x)
    {
        if ($x->val == $val)
        {
            return $x;
        }
    }

    return __construct($val);
}

}

$try1 = new X(23); /* would return $allX[0] reference /
$try2 = new X(42); / woudl return $allX[1] reference /
$try3 = new X(23); / would return $allX[0] reference */
?

Derrell.Lipman@UnwiredUniverse.com writes:

Leonardo Pedretti lpedretti@suserver.com writes:

I would like (for code cleanliness purposes) to make 'new' return a
reference to an already created object under certain circumstances without
using a factory, is it possible?

A number of months ago, I proposed a similar feature, implemented as
overloading a __new() function. At the time, it seemed I was the only one who
wanted it, but your request is for a feature identical to my request. Here's
my previous message. (The whole thread can be found under the subject "new
overloading feature?" from 5 Nov 2004). I'd love for this to be revisited now
that there's someone else with a similar desire.

My previous proposal:

I came across an interesting desire today. I'd like to create a new class
instance if an only if a "key" value does not already exist. This key value
could be looked up in a database, in an array, etc.

The following contrived example shows use of a proposed __new() overload
function which would be called BEFORE the constructor, and could chose to
return a newly constructed object (by calling __construct()) or to return an
already existing object.

One could certainly call a function which searched for the key value and only
instantiated a new object if the existing one was not found, but this seems
cleaner.

Thoughts?

<?php

class X
{
static $allX = array();
var $val;

function __construct($val)
{
    $this->val = $val;
    X::$allX[] =& $this;
}

function __new($val)
{
    foreach (X::$allX as $x)
    {
        if ($x->val == $val)
        {
            return $x;
        }
    }

    return __construct($val);
}

}

$try1 = new X(23); /* would return $allX[0] reference /
$try2 = new X(42); / woudl return $allX[1] reference /
$try3 = new X(23); / would return $allX[0] reference */
?

My thoughts are:

1. Adding to many __methods is ugly.

2. Interesting subject though. Not to add to the flame but I've seen the
   need for more advanced overloading features in allot of the code I've
   been writing with PHP5. Consider the following example (C++ almost like,
   may slow down the engine but seems like a cleaner idea):

class StringObject
{
public $val = '';

public function __construct($str = '')
{
$this->val = $str;
}

public function __operator($operator, &$lOperand, &$rOperand,
&$returnValue)
{
switch ($operator) {
case T_CONCAT_EQUALS:
if ($rOperand instanceof StringObject &&
$lOperand instanceof StringObject) {
$returnValue = $lOperand->val . $rOperand->val;
// or something?
return true; // use operator handler;
}

   // ...other operators that are supported by this object
   // can be defined here...

 }
 return false; // normal operation takes place;

}
}

$str1 = new StringObject("hello ");
$str2 = new StringObject("world!");

str1 .= $str2;

This would be very useful and very clean but seems like if defined would
really slow down the engine. But, i think this could work well in many,
many different situations. Maybe only a subset of operators are
overloadable with this method.

-Justin

Derrell Lipman wrote:

I came across an interesting desire today. I'd like to create a new class
instance if an only if a "key" value does not already exist. This key value
could be looked up in a database, in an array, etc.

The following contrived example shows use of a proposed __new() overload
function which would be called BEFORE the constructor, and could chose to
return a newly constructed object (by calling __construct()) or to return an
already existing object.

One could certainly call a function which searched for the key value and only
instantiated a new object if the existing one was not found, but this seems
cleaner.

Thoughts?

<?php

class X
{
static $allX = array();
var $val;

function __construct($val)
{
    $this->val = $val;
    X::$allX[] =& $this;
}

function __new($val)
{
    foreach (X::$allX as $x)
    {
        if ($x->val == $val)
        {
            return $x;
        }
    }

    return __construct($val);
}

}

$try1 = new X(23); /* would return $allX[0] reference /
$try2 = new X(42); / woudl return $allX[1] reference /
$try3 = new X(23); / would return $allX[0] reference */
?

My thoughts are:

1. Adding to many __methods is ugly.

2. Interesting subject though. Not to add to the flame but I've seen the
   need for more advanced overloading features in allot of the code I've
   been writing with PHP5. Consider the following example (C++ almost like,
   may slow down the engine but seems like a cleaner idea):

class StringObject
{
public $val = '';

public function __construct($str = '')
{
$this->val = $str;
}

public function __operator($operator, &$lOperand, &$rOperand,
&$returnValue)
{
switch ($operator) {
case T_CONCAT_EQUALS:
if ($rOperand instanceof StringObject &&
$lOperand instanceof StringObject) {
$returnValue = $lOperand->val . $rOperand->val;
// or something?
return true; // use operator handler;
}

   // ...other operators that are supported by this object
   // can be defined here...

 }
 return false; // normal operation takes place;

}
}

$str1 = new StringObject("hello ");
$str2 = new StringObject("world!");

str1 .= $str2;

This would be very useful and very clean but seems like if defined would
really slow down the engine. But, i think this could work well in many,
many different situations. Maybe only a subset of operators are
overloadable with this method.

-Justin

Derrell Lipman wrote:

I came across an interesting desire today. I'd like to create a new class
instance if an only if a "key" value does not already exist. This key value
could be looked up in a database, in an array, etc.

The following contrived example shows use of a proposed __new() overload
function which would be called BEFORE the constructor, and could chose to
return a newly constructed object (by calling __construct()) or to return an
already existing object.

One could certainly call a function which searched for the key value and only
instantiated a new object if the existing one was not found, but this seems
cleaner.

Thoughts?

<?php

class X
{
static $allX = array();
var $val;

function __construct($val)
{
    $this->val = $val;
    X::$allX[] =& $this;
}

function __new($val)
{
    foreach (X::$allX as $x)
    {
        if ($x->val == $val)
        {
            return $x;
        }
    }

    return __construct($val);
}

}

$try1 = new X(23); /* would return $allX[0] reference /
$try2 = new X(42); / woudl return $allX[1] reference /
$try3 = new X(23); / would return $allX[0] reference */
?