Get called function name in destructor - php

Question

is it possible to get the called function name in destructor ?
class My_class {
function my_func() {
echo 'Hii';
}
function your_func() {
echo 'Hii';
}
function __destruct() {
echo $the_called_func_name;
}
}
$bar = new my_class();
$bar->my_func();
is it possible to get the name 'my_func' in the destructor ?
if we used
echo __FUNCTION__;
it will give
__destruct
i want
my_func

Answer 1

Yes it is possible. Since my_func is dynamical, you can use function overload (a.k.a magic method) __call()
class My_Class
{
private $methods = array();
public function __call($method, array $args)
{
array_push($this->methods, $method);
}
public function getMethods()
{
return $this->methods;
}
public function __destruct()
{
// Off course, you should improve this
print_r($this->getMethods());
}
}
// Usage:
$foo = new My_Class();
$foo->my_func(); // Output Array(0 => 'my_func')

Answer 2

its just for logging that which function has been accesed. Instead of calling log function in each function.
It's not easily possible without adding code to the methods or using a separate tool for debugging and profiling.
Note that the proposed solutions with __call don't work with existing public methods, in the end it would get more complicated than just adding log(__METHOD__) to each method.
What you are looking for is basically Aspect Oriented Programming (AOP) which is not terribly supported in PHP. The framework Flow3 uses annotations and reflection to add aspects dynamically. Their Logging Example is a perfect illustration of your use case:
namespace Example\MyPackage;
/**
* A logging aspect
*
* #Flow\Aspect
*/
class LoggingAspect {
/**
* #var \TYPO3\Flow\Log\LoggerInterface A logger implementation
*/
protected $logger;
/**
* For logging we need a logger, which we will get injected automatically by
* the Object Manager
*
* #param \TYPO3\Flow\Log\SystemLoggerInterface $logger The System Logger
* #return void
*/
public function injectSystemLogger(\TYPO3\Flow\Log\SystemLoggerInterface ⏎
$systemLogger) {
$this->logger = $systemLogger;
}
/**
* Before advice, logs all access to public methods of our package
*
* #param \TYPO3\Flow\AOP\JoinPointInterface $joinPoint: The current join point
* #return void
* #Flow\Before("method(public Example\MyPackage\.*->.*())")
*/
public function logMethodExecution(\TYPO3\Flow\AOP\JoinPointInterface $joinPoint) {
$logMessage = 'The method ' . $joinPoint->getMethodName() . ' in class ' .
$joinPoint->getClassName() . ' has been called.';
$this->logger->log($logMessage);
}
}
The important line is this:
#Flow\Before("method(public Example\MyPackage\.*->.*())")
it tells the framework to call logMethodExecution before any method call in any class of the Example\MyPackage namespace.
So, with Flow3 you can do it. But implementing a similar behaviour by yourself without an AOP framework is bound to fail.

Answer 3

Yes,
class My_class {
function my_func() {
echo 'Hii';
}
function your_func() {
echo 'Hii';
}
function __destruct() {
self::my_func();
// my_func called
}
}
$bar = new my_class();
$bar->my_func();
If you mean function name, use __call for object function and __callStatic for static function.