Question

Hola, lo que quiero hacer es algo asi:

First_class class extends Second_class
{
   function first_class_function ()
   {
   $ this-> second_class_function ();
   }
}

class Second_class
{
   function second_class_function ()
   {
   return "el nombre de la funcion que llamo a esta funcion" // en este caso deberia devolver first_class_function
   }
}

Porque lo quiero? para automatizar algo(no puedo decir mucho el aviso de confidencialidad me lo impide), desde luego puedo escribir el nombre de la funcion como un argumento, pero este no es el caso.

Answer 1

Una posible solución podria ser usar la clase Exception y el metodo getTrace() para obtener el seguimiento como un array.

ejemplo:

<?php

class First_class extends Second_class
{
    function first_class_function ()
    {
        return $this->second_class_function();
    }
}

class Second_class
{
    function second_class_function ()
    {
        $exception = new Exception;

        return $exception->getTrace()[1]['function'];
    }
}

$foo = new First_class();
var_dump($foo->first_class_function());

---

http://php.net/manual/es/class.exception.php
http://php.net/manual/es/exception.gettrace.php

Answer 2

Investiga la programación orientada a objetos y como trabajar con los métodos de los padres pero no se si un padre puede trabajar con el método de un hijo realmente eso no suena lógico para la programación orientada a objetos.
No obstante te recomiendo estos links:
Herencia en PHP
Herencia y el uso del parent
Otro ejemplo de Herencia en PHP
Herencia en PHP con ejemplo
espero que te sea de ayuda o te de una idea.
Saludos Dairon

Answer 3

Hola @vendetta,

los frameworks generalmente rutean las llamadas a las funciones o métodos correctos analizando la petición, y no en nombre de la clase llamadora, tal como sugiere @white en su comentario.

Para implementar un ruteo con la forma que proponés, la idea es que la clase que recibe el mensaje genérico no sea una subclase de la que implementa el método. De esta forma es posible analizar la clase invocada y actuar en consecuencia (además de que esta separación de clases es natural, porque tendrán distintas responsabilidades, y por tanto deben ser clases distintas).

Para saber de qué clase es un llamador se puede hacer:

<?php
class First_class extends base_class {
   function first_class_method () {
    return $this->base_class_method ();
   }
}
class base_class {
   function base_class_method () {
    //return "el nombre de la funcion que llamo a esta funcion"; // en este caso deberia devolver first_class_function
    return get_called_class();
   }
}

$o = new First_class();
var_dump( ($o->first_class_method()) );

y ahora, dependiendo de la clase (no del método) que hace la llamada, podés invocar a quien quieras.

Esto es lo que indicaría un buen diseño OO.

También se puede conocer el método llamador, pero al costo de enviarlo como parámetro. Esto no es lo que estás buscando exactamente, pero dado que cada subclase será escrita para procesar una entrada, tampoco es muy aplicable generalizarlo, porque una subclase no podrá serlo de más de una superclase.

El código quedaría así:

<?php
class First_class extends base_class {
   function first_class_method () {
    return $this->base_class_method (__METHOD__);
   }
}
class base_class {
   function base_class_method ($c) {
    //return "el nombre de la funcion que llamo a esta funcion"; // en este caso deberia devolver first_class_function
    return $c;
   }
}

$o = new First_class();
var_dump( ($o->first_class_method()) );

Si te hace falta una implemetación más genérica, la solución de diseño a este problema (el hacking con back_trace() es genial, pero no es una solución de diseño en OO) es usar Double Dispatch http://en.wikipedia.org/wiki/Double_dispatch que es el mecanismo de la POO para crear una jerarquía de clases que se encargue de resolver a quién debe llamar un método de otra clase en tiempo de ejecución.

Saludos cordiales!