<?php
/* ADAPTER
 *
 * O adapter funciona como um adaptador real, usando por exemplo em
 * tomadas. A função do adaptador é fazer com que uma classe (cliente)
 * feita pra falar com uma outra classe (compativel), possa tambem falar
 * com uma terceira classe com interface incompatível, sem a necessidade
 * de alterações nem na classe original e nem na incompatível.
 * Isso é feito através de um adaptador: uma classe que possui a mesma
 * interface da classe compatível, mas que internamente faz chamadas à
 * classe incompatível para prover os mesmos recursos.
 */


/**
 * Classe Cliente. Esta classe sabe falar com a interface Compativel.
 */
class Cliente {

	/**
	 * Construtor bem simples, recebe um array como parâmetro, chama
	 * o método externo ordena() e imprime o array com print_r()
	 *
	 * @access	public
	 * @param	array	$array	Array a ser ordenado
	 */
	public function __construct( $array ) {

		$ord = Ordena::ordena( $array );
		print "Array ordenado:\n";
		print_r( $ord );

	} // end :: __construct


} // end :: Cliente


/**
 * Definição da interface com que a classe Cliente sabe falar
 */
interface Compativel {

	/**
	 * Este método estático deve ordenar o array passado e retorná-lo.
	 *
	 * @access	public
	 * @param	array	$array	Array com elementos a serem ordenados
	 * @return	array	Array ordenado
	 * @static
	 */
	public static function ordena( $array );

} // end :: Compativel


/**
 * Adaptador: Faz a classe Cliente falar com a Incompativel.
 */
class Ordena implements Compativel {

	/**
	 * Construtor, declarado apenas para que o PHP não reclame que o
	 * construtor da classe não pode ser estático.
	 */
	private function __construct() {}


	/**
	 * Implementação da função ordena() usando a classe incompatível.
	 * O segredo do adaptador é fornecer à classe Cliente a mesma interface
	 * que ela sabe trabalhar, e fazendo o "trabalho sujo" de modo
	 * transparente.
	 * Dessa forma, a classe Cliente não faz a menor idéia de que não está
	 * falando com a classe com que foi originalmente projetado para falar.
	 *
	 * @access	public
	 * @param	array	$array	Array a ser ordenado
	 * @return	array	O array ordenado
	 * @static
	 */
	public static function ordena( $array ) {

		$inc = new Incompativel( $array );
		$ord = $inc->sortArray();
		return $ord;

	} // end :: ordena

} // end :: Ordena


/**
 * Esta é a nossa classe que faz a ordenação. Note que a interface dela
 * é completamente diferente da que a classe Cliente sabe falar.
 */
class Incompativel {

	/**
	 * Variável para guardar o array a ser ordenado
	 * @access	private
	 */
	private $arr;


	/**
	 * Construtor da classe. Recebe o array como parâmetro e o coloca
	 * na variável arr.
	 *
	 * @access	public
	 * @param	array	$array	Array a ser ordenado
	 */
	public function __construct( $array ) {

		$this->arr = $array;

	} // end :: __construct;

	
	/**
	 * Ordena e retorna o array guardado em arr.
	 *
	 * @access	public
	 * @return	array	O array ordenado
	 */
	public function sortArray() {

		$tmp = $this->arr;
		sort( $tmp );
		return $tmp;

	} // end :: sortArray

} // end :: Incompativel


//////////////////////////////
// Exemplo de uso

$array = Array( 3,2,5,4,1 );

print "Ordenação usando a classe incompatível diretamente\n";
$inc = new Incompativel( $array );
$ord = $inc->sortArray();
print_r( $ord );


// Agora, usando a classe cliente através de um adaptador
print "Fazendo a ordenação direto da classe Cliente através de um adaptador\n";
$cliente = new Cliente( $array );
?>