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 />';
?>

[Dormilich]

I’d go along with Markus, Exceptions are easy to handle and extend, plus you can catch Exceptions a) anywhere and b) globally with set_exception_handler() (although that will finish the script).

in this special case, I’d rather build the DB connecting into the select_row() method, so that I don’t even require chaining.

public function select_row()
{
    try
    {
        $this->database();
        $this->connect();
    }
    catch (Exception $e)
    {
        logException($e);
        return false;
    }
    // select row code
    return true;
}

[shulace717]

I first want to apologize to Markus. :)
My inexperience with PHP (and lack of any knowledge of exceptions) drove me to try and find a way to try and out smart the method chain, instead of logically handling the situation as PHP was designed to do.

I've since studied exceptions and now have yet another wonderful tool in my PHP belt.

Thank you for your responce, Dormilich.

I've learned a lot from this thread and am glad I've registered with bytes.