[classi e oggetti] Xesperti patterns...Oggetto.Attributes("nome")[.getValue()]

[max161]

Ciao a tutti, il titolo non è certamente esplicativo per cui cercherò di spiegarmi nel modo + chiaro possibile...
vorrei che richiamando il METODO Attributes*("nome") di DEFAULT chiamasse il metodo getValue() dell'istanza di Item da esso ritornato

[uso il punto per chiarezza]

quindi invece di scrivere Oggetto.Attributes("nome").getValue()

1) vorrei poter scrivere Oggetto.Attributes("nome")

e per richiamare setValue e getKey devo specificarli...

2) quindi invece di scrivere Oggetto.Attributes("nome").setValue()
3) quindi invece di scrivere Oggetto.Attributes("nome").getKey()

function Attributes($n){
 // ret obj Item (ha metodi .getValue(), .setValue() e getKey())
 return $this->Attributes->getItem($n); // ->getValue();
} 

Avevo pensato ad un metodo apposito per richiamare il valore ad esempio:

// al singolare
function Attribute($n){
 // ret obj Item (ha metodi .getValue(), .setValue() e getKey())
 return $this->Attributes->getItem($n)->getValue();
} 

e richiamare il valore con Oggetto.Attribute("nome")

*: è una classe che posside il metodo getValue() il quale restituisce un oggetto di tipo Item (prop. key, value) che possiede anche i metodi setValue e getKey.


GRAZIE A CHI AVRA' PAZIENZA DI CAPIRE IL SOTTILE PROBLEMA E SOPRATTUTTO A CHI SAPRA AIUTARMI!

[Al_katraz984]

vorrei che richiamando il METODO Attributes*("nome") di DEFAULT chiamasse il metodo getValue() dell'istanza di Item da esso ritornato

:master: sei molto criptico..

function Attributes(&$item, $n){
      $this->item =& $item;
      $valore = $this->item->getValue($n);
      return $valore;
} 

nel metodo Attributes passi come primo valore un'istanza della classe item e come 2° valore il tuo $n...

Xo non sò se è quello ke ti serve... si capisce poco..

[max161]

Grazie per la risposta...
la tua soluzione non è applicabile perchè non posso passare al metodo attribute l'istanza di una classe che in esso è contenuta, da dove lo piglio $item???. Infatti Attributes non fa altro che ritornarmi un elemento della proprietà array (in realtà Collection) Attributes, che è un Item.
comunque la soluzione (che mi è venuta in mente proprio iniziando questo 3d...) testata e funzionante è creare un metodo Attribute in modo da poter richiamare l'istanza Item in questo modo:

// return Item instance !
Oggetto.Attributes("nome");

e il suo valore in questo:

// return Item value Property !
Oggetto.Attribute("nome")

e naturalmente....

Oggetto.Attributes("nome")-getValue(); // che non uso +

questo approccio mi ha permesso di non essere invasivo nel codice, aggiungendo un metodo Attribute alla classe Oggetto e sostituendo tutte le occorrenze dove necessario. Il codice è notevolmente migliorato in leggibilità...e logica
è un po' ilo concetto che si ritrova in ADO:


rs.Fields.Item(1).Value

Fields ritorna la collection Fields

// è come scrivere

rs.Fields.Item(1)

Fields ritorna la collection Fields e Item ritorna di default il valore

//e scrivere...

rs.Fields(1).Value

Fields ritorna l'istanza item alla quale viene applicato il metodo value (o proprietà pubblica?)

// e scrivere ....

rs.Fields(1)

Fields ritorna l'istanza item attraverso il metodo Item (implementazione) che di DEFAULT ritorna il proprio valore

probabilemente si può ottenere un effetto così anche con php creando ad esempio un metodo Fields che può o meno ricevere 1 parametro.
nel primo caso richiamerebbe il metodo Item che ritorna il valore , nel secondo l'intera collection di Items (Attributes).

QUINDI:

Class Oggetto{

   private Attributes; // Collection 

   function Attributes($n = null){ 
      if($n){ 
         return $this->Attributes->Item($n);

      }else{
         return $this->Attributes;  
      }
   }
}

Class Attributes extends Collection{
   //[ parent!
   function Item($n){ 
      return $this->getItem($n)->getValue(); 
   }

   function getItem($n){ 
      return $this->getItem($n); 
   }
   // parent
} 

Così per teenere Item->getValue() posso scrivere:

Oggetto.Attributes().Item(1)

Oggetto.Attributes().Item(1).getValue()  // ?????

oppure

Oggetto.Attributes(1)

Oggetto.Attributes(1)->getValue() // ????? 

Dove ho scritto // ????? non so come fare....
La discussione è aperta...

PS: spero di essere stato + chiaro... :master:

[whisher]

Ciao.
Toglimi una curiosità ma sei su PHP5 o PHP4
perchè se sei su PHP5 quello che stai facendo ha poco senso
(almeno ad una prima occhiata) .

Facci un favore posta il codice
perchè cosi non si capisce cosa vai cercando.








Ad esempio :

Class Oggetto{

   private Attributes; // Collection

   function Attributes($n = null){
      if($n){
         return $this->Attributes->Item($n);

      }else{
         return $this->Attributes;  
      }
   }
} 

cosa caspita gli passi

[max161]

Sono su PHP 5.
gli passo un NUMERO O INDICE...attributes è una COLLECTION.
praticamente sto cercando il modo o il pattern che mi permetta di DEFINIRE un metodo di DEFAULT. esempio:

$Oggetto->Attributes->Item(1)->getValue()

vorrei poterlo scrivere come:

$Oggetto->Attributes->Item(1)

e come

$Oggetto->Attributes(1)

mmm...invece di postare il codice faccio un esempio. mettiamo di avere una classe Principale ed una incapsulata in una proprietà che chiameremo Figlia:

class Principale{
   private $Figlia;
   function __construct(){
      $this->Figlia = new Figlia("chiave1", "valore1");
   }

   function Figlia(){
      $this->Figlia->getValue();
   }

}

class Figlia{
   private $value; // string
   private $key;

   function __construct($k, $v){
      $this->setKey($k);      
      $this->setValue($v);      
   }

   public function getValue(){
      return $this->value;
   }
   public function getKey(){
      return $this->key;
   }
   public function setValue($s){
      $this->value = $s;
   }
   public function setKey($s){
      $this->key = $s;
   }

} 

sostanzialmente vorrei che scrivendo:

$objPrincipale = new Principale;
$str = $objPrincipale->Figlia; // [->getValue()] 

... mi tornasse di default il valore, per questo ho implementato il metodo Figlia nella classe Principale ma non è la strada giusta perchè se volessi lanciare il metodo setValue lasciando inalterata la sinossi cioè così....

$objPrincipale = new Principale;
$str = $objPrincipale->Figlia->setValue("valore2"); 

...non funzionerebbe. Secondo me il trucchetto, se esiste, è legato alla visibilità da parte della classe Figlia della classe principale tramite un riferimento ...
es.

class Principale{
   private $Figlia;
   function __construct(){
      $this->Figlia = new Figlia("chiave1", "valore1", $this);
   }
.....................


class Figlia{
   private $value; // string
   private $key;
   private $Container;

   function __construct($k, $v, $objContainer){
      $this->setKey($k);      
      $this->setValue($v);      
      $this->Container = $objContainer;
   }
.... ...... ...... 

oppure potrei rendere pubblica la visibilità della proprietà Figlia ma vorrei evitarlo a meno che non esista un modo per rendere le proprietà di una classe pubbliche ma in sola lettura (creazione metodi a parte naturalmente).
mah!

[max161]

ho implementato nell classe Item il metodo __toString():

class Item{
  private $key;
  private $value;
  public function getValue(){
   return this->value;
  }
  // default method when non method is called !
  public function __toString(){
   return this->value;
  }
}

// es:
$objItem = new Item
echo $objItem;

// è la stessa cosa di 

echo $objItem->getValue(); 

[andr3a]

Originariamente inviato da max161

class Principale{
   private $Figlia;
   function __construct(){
      $this->Figlia = new Figlia("chiave1", "valore1");
   }

   function Figlia(){
      return $this->Figlia->getValue();
   }

}

...

$objPrincipale = new Principale;
$str = $objPrincipale->Figlia(); // [->getValue()]

.... il toString non può far tornare un valore diverso da una stringa (come ben saprai) ... ma a te non serviva il toString, casomai il __get o il __set


[edit]
un esempio base di getter e setter:
http://forum.html.it/forum/showthrea...readid=1097205