chain methods, is it possible to break a chain?

[ManWithNoName]

Dear sir,

say, do you know if it is possible to "break" a method chain in php?

e.g.

 
class a{
 
function x(){
  return $this;
}
 
function y(){
  if(condition===true){
    return $this;
  }
  else{
    return false;
  }
}
 
function z(){
  ...
}
 
$a=new a;
 
$this->x()->y()->z();
 
}
 
 

In the current example if the "condition" in method "y" is false an error will be thrown after y is evaluated, because z() can not be accessed from a non-object (that is "false" which is returned instead of "$this").

What I am trying to do dear sir, is to break the chain at juncture "y", that is,

when y returns false, then z should not be evaluated,

do you my good man know how I can achieve this?

Grateful for answer,

yours sincerely

[Markus]

You could throw an exception instead of returning false, and then run your obj calls in a try/catch block.

[ManWithNoName]

Hi again!

Thanks for your reply, and your tips for an approach to this problem,

I'll look into this :D

[Markus]

@ManWithNoName
No problamo! Let us know how you get on.

Mark.

[ManWithNoName]

I never used exceptions, but I can’t see how the basic set up could be used for my problem.

e.g. (in class a)

public function y(){
  if(condition===true){
    return $this;
  }
  else{
    throw new Exception("false");
  }
}
 

But this still means z() needs to be evaluated… (i.e. the chain won’t “break” at x() and return and thus never invoking z())

I have thought about this, and I don’t think this is possible to do what I want to do… PHP will evaluate the entire chain and expects that the methods are being called from a proper class object where the current called method exists…

[Markus]

Uh, confused. The code below produces the expected result, that is, the chaining breaks when an exception is thrown:

<?php
 
    class TestChain { 
 
        public function x() {
            printf("Method %s called\n", __METHOD__);
 
            return $this;
        }
 
        public function y($throw = TRUE) {
            printf("Method %s called\n", __METHOD__);
 
            if($throw) throw new Exception('Breaking');
            else return $this;
        }
 
        public function z() {
            printf("Method %s called\n", __METHOD__);
 
            return $this;
        }
 
    }
 
    $tc = new TestChain;
 
    try {
        // Should eventually evaluate z()
        $tc->x()->y(FALSE)->z();
        print "Method chaing ran well.\n";
    } catch (Exception $e) {
        printf("Method chaining failed: %s\n", $e->getMessage());
    }
 
    try {
        // Should not evaluate z()
        $tc->x()->y(TRUE)->z();
        print "Method chaing ran well.\n";
    } catch (Exception $e) {
        printf("Method chaining failed: %s\n", $e->getMessage());
    }
 

Although, I'm unable to make heads or tails on whether this is what you want or not.

Mark.

[ManWithNoName]

Thanks Markus but the problem lies in the “wrapping”, I don’t want to wrap the “chain” with try/catch,

I would like to have all necessary functionality embedded in the methods, in order to have a more “clean” and convenient code ;)

e.g.

$return=$this->database()->connect()->select_row();
$this->another_method_not_related_to_the_previous_method()->does_something_else(); 
 

The objective is: If connect() fails, return false, then $return will contain “false” and select_row() should never be evaluated,

the problem is that if connect() returns false, then select_row() will throw an error about not being able to init from a non object,

and if connect() returns $this, I have to evaluate a method that does not need to be initiated, and if connect() was false, how would select_row() know this? I would need to pass a variable between them, and that is not pretty :(

EDIT
I just found an example of passing a variable between methods in order to track "false", http://www.hawkhost.com/blog/2009/06...thod-chaining/, I do not like this implementation, but I can't see any other way of doing this...

[Markus]

@ManWithNoName
Somethings just aren't built into a language, and this isn't into PHP.

@hack: ick! I prefer my elegant try/catch. ;)

[ManWithNoName]

Thanks for trying to help me though.

[shulace717]

This is an older post, but I'm new to PHP (about a month into it) and found this interresting. After some research I think I've found a more direct solution.

Although, this can be applied with one line of code and absolutely no alterations to the class or methods, there is a catch. This evaluates the method chain twice.

The first time it is evaluated a boolean datatype, as the Logicial Operators work down the chain searching for a not TRUE value.

Basically, here is my 1 line solution:
($class->Ax() && $class ->Ay() && $class->Az()) ? ($result = $class->Ax()->Ay()->Az()) : ($result = FALSE);


Logical Operators

($class->Ax() && $class ->Ay() && $class->Az())

Ternary Operator - if

?

returned value of Method Chain (if TRUE)

($result = $class->Ax()->Ay()->Az()) 

Ternary Operator - then

:

validate FALSE boolean for a break in the chain.

($result = FALSE);

It's not perfect. You can follow the $trace global below to see how it travels the chain twice. However, I think it's effective and a step in the right direction.

Here's a bunch of code, consisting of a basic class and multiple test outputs at the bottom.

Please let me know what you think and how this could be further improved!

<?PHP
$trace ='';
$result = '';
 
class Main
{ 
 
    public $condition_A = TRUE;
    public $condition_B = TRUE;
 
    function Ax(){ 
        $GLOBALS['trace'] .= " --> ". __METHOD__;
        return $this; 
    } 
    function Ay(){ 
        if($this->condition_A===TRUE){ 
        $GLOBALS['trace'] .= " --> ". __METHOD__;
            return $this; 
        } 
        else{return FALSE;} 
    } 
    function Az(){ 
        $GLOBALS['trace'] .= " --> ". __METHOD__;
        return "Your requested row data"; 
    } 
      function Bx(){ 
        $GLOBALS['trace'] .= " --> ". __METHOD__;
        return $this; 
    }
    function By(){ 
        if($this->condition_B===TRUE){ 
            $GLOBALS['trace'] .= " --> ". __METHOD__;
            return $this; 
        } 
        else{
            $GLOBALS['trace'] .= " --> ". __METHOD__;
            return FALSE;
        } 
    } 
    function Bz(){ 
        $GLOBALS['trace'] .= " --> ". __METHOD__;
        return "Your requested row data"; 
    } 
    public function Control(){
        $return = $this->Ax()->Ay()->Az();
        return $return;
    }
 
}
 
$class = new Main;
 
$result = $class->Control();
echo $trace;                    //Output: --> Main::Ax --> Main::Ay --> Main::Az
echo '<br />';
printf (var_dump($result));        //Output: string(23) "Your requested row data" 
echo '<br />';
$trace = $result = NULL;
 
$result = $class->Bx()->By()->Bz();
echo $trace;                    //Output: --> Main::Bx --> Main::By --> Main::Bz
echo '<br />';
printf (var_dump($result));        //Output: string(23) "Your requested row data" 
echo '<br />';
$trace = $result = NULL;
 
$result = $class->Bx() && $class ->By() && $class->Bz();
echo $trace;                    //Output: --> Main::Bx --> Main::By --> Main::Bz
echo '<br />';
printf (var_dump($result));        //Output: string(23) "Your requested row data" 
echo '<br />';
$trace = $result = NULL;
 
$class->condition_B = FALSE;    // <-----  BREAK IN THE CHAIN  --------
 
$result = $class->Bx() && $class ->By() && $class->Bz();
echo $trace;                    //Output: --> Main::Bx --> Main::By
echo '<br />';
printf (var_dump($result));
echo '<br />';                    //Output: bool(false) 
$trace = $result = NULL;
 
$result = $class->Control();
echo $trace;                    //Output: --> Main::Ax --> Main::Ay --> Main::Az
echo '<br />';
printf (var_dump($result));        //Output: string(23) "Your requested row data" 
echo '<br />';
$trace = $result = NULL;
/*
$result = $class->Bx()->By()->Bz();    //Output: Fatal error: Call to a member function Bz() on a non-object in
echo $trace;                     
echo '<br />';
printf (var_dump($result));
echo '<br />';            
*/
 
($class->Ax() && $class ->Ay() && $class->Az()) ? ($result = $class->Ax()->Ay()->Az()) : ($result = FALSE);
echo $trace;                    //Output: --> Main::Ax --> Main::Ay --> Main::Az --> Main::Ax --> Main::Ay --> Main::Az
echo '<br />';
printf (var_dump($result));        //Output: string(23) "Your requested row data" 
echo '<br />';
$trace = $result = NULL;
 
($class->Bx() && $class ->By() && $class->Bz()) ? ($result = $class->Bx()->By()->Bz()) : ($result = FALSE);
echo $trace;                    //Output: Main::Bx --> Main::By
echo '<br />';
printf (var_dump($result));        //Output: bool(false) 
echo '<br />';
?>