Defining a basic contextual class - PHP

The stage pattern lets you build classes that can modify their behaviors according to the variations of a given programming context. If you want to learn more about it, then you should start reading this article now! Welcome to the final installment of the series that began with "Implementing the stage pattern in PHP 5." Made up of two articles, this series walks you through the application of this useful pattern, and complements the corresponding theory with illustrative code samples.

TABLE OF CONTENTS:

By: Alejandro Gervasio

Poor Best

Rating:

/ 4

April 25, 2007

print this article

SEARCH DEV SHED

TOOLS YOU CAN USE

// define 'CSSContext' class
class CSSContext{
   private $pageFormat=NULL;
   public function __construct(){}
   public function setPageFormat($pageFormat){
     if($pageFormat!='normal'&&$pageFormat!='print'){
       throw new Exception('Invalid value for web page
format.');
     }
     $this->pageFormat=$pageFormat;
   }
   public function getCSS(){
     if($this->pageFormat=='normal'){
       return new CSSNormal('Verdana','#f00','#eee');
     }
     else{
       return new CSSPrint('Arial','#000','#fff');
     }
   }
}

As I said before, the above class has been provided with the capacity to create a specific CSS object in accordance with the format requirements of a particular web document. As you can see, this task is performed by its "getCSS()" method, which returns to calling code either a CSS object suitable for use with computer monitors, or another one for use with printers.

All right, at this stage I have defined a contextual class that controls what type of CSS object must be used according to the specifications of a given web document. However, there's a missing piece in this scenario, since I need to create a mechanism that generates the web document in question.

In response to this requirement, below I included the definition of a brand new class. It's called "WebPage," and it is tasked with creating web pages on the fly, using a specific CSS object passed as an input parameter to the corresponding constructor.

The signature for the aforementioned class is as follows:

// define 'WebPage' class
class WebPage{
   private $title='Testing State pattern';
   private $html=NULL;
   private $css=NULL;
   public function __construct(CSS $css){
     $this->css=$css;
   }
   public function makeHeader(){
     $this->html='<html><head><title>'.$this-
>title.'</title></head>';
   }
   public function makeBody(){
     $this->html.='<body><div style="font: bold 12px '.$this-
>css->getFont().';color :'.$this->css->getColor().';background:
'.$this->css->getBackground().';">This is the default content
used to test the state pattern.</div>';
   }
   public function makeFooter(){
     $this->html.='</body></html>';
   }
   public function getHTML(){
     return $this->html;
   }
}

Now that you have seen the definition for the above "WebPage" class, I'm pretty certain that you'll see more clearly how the stage pattern is implemented in this case. Let me explain the situation briefly: on one hand, there's a contextual class that selects the proper CSS object to be used when generating a web document, while on the other hand there's another class that changes its behavior -- notice the implementation of the "makeBody()" method -- to fit the requirements of a particular page format.

Okay, at this point you hopefully understand how the stage pattern is used here. However, I think that you'll grasp the way that this pattern works even more easily if I set up a concrete example where all the previous classes are put to work in conjunction.

In the following section I'm going to develop a short script that will help to demonstrate the functionality of the stage pattern. Keep reading, please.

Next: Completing the implementation of the stage pattern >>



	>>> More PHP Articles >>> More By Alejandro Gervasio

blog comments powered by Disqus

PHP ARTICLES

- PHP Closures as View Helpers: Lazy-Loading F...
- Using PHP Closures as View Helpers
- PHP File and Operating System Program Execut...
- PHP: Effects of Wrapping Code in Class Const...
- PHP: Building Concrete Validators
- Sanitizing Input with PHP
- Executing Shell Commands with PHP
- Handling File Data with PHP
- File Security and Resources with PHP
- ArrayObject PHP Class Examples
- ArrayObject PHP Class: An Introduction
- Getting File System Data with PHP
- PHP Tools for Working with the File and Oper...
- Working with the File and Operating System w...
- PHP Proxy Patterns: Completing a Blog

Find More PHP Articles

DevShed

PHP Tutorials

Defining a basic contextual class - PHP

See Also:

Dev Shed Tutorial Topics: