Examples

The XP APIs by topic

The documentation website now contains an overview of the XP framework's APIs by topic - Databases, I/O, XML, Dates, Collections, Web and Imaging. Although the overview is initially done, there is still lots of text to write.

The first two topics to be covered are Databases in general and our Object persistence API.

Writing a parser: Calculator example

In many situations, we need to transform user input to machine readable data. Mostly, a regular expression, sscanf or even very simple handling via string functions will be sufficient. For more complex (and forgiving) input, and when we want to tell users what went wrong where these methods may not be enough.

Imagine a situation in which you would like to evaluate mathematical expressions, so, for example, the user would be inputting something like 1 + 2 or -1 / (3 * 6) and you would like output the expression's result. Something like this:

Using sscanf

To parse strings, you've probably used different of the many string functions that come bundled with PHP, strtok, explode, strstr, regular expressions and maybe even the more "exotic" C-like strcspn or strcasecmp. One of the candidates most often overlooked is sscanf.

Here are some examples.

Enum usecases: Replace switch/case blocks

When migrating parts of my photoblog's import scripts to command classes I stumbled upon the following block of code:

<?php 
  switch ($group= $param->value('group')) {
    case 'day': $strategy= new GroupByDayStrategy(); break;
    case 'hour' : $strategy= new GroupByHourStrategy(); break;
    default: throw new IllegalArgumentException('No such grouping method "'.$group.'"');
  }
?>

Enum usecases: Profiling

As you might now, from time to time, I investigate PHP language features on their performance. Examples include if / elseif vs. if / else if (no difference), testing control structures (switch vs. if / else cascades vs. the ternary operator - if / else cascades are the fastest, see entry #179) or whether default arguments have an impact (none).

What I did to compare these was to create a class for each strategy, use reflection to load it depending on the command line argument passed and then run it, printing out profiling information gathered via util.profiling.Timer. See here for an example.

The downsides of this approach were:

• There was no way to run all strategies at once
• Every strategy I added needed to be manually added to the usage
• The profiling / runner sourcecode was copied every time

XPCLI: Command line classes

It's been a while since RFC #0102 has been implemented, and since then a couple of questions have arisen on how to use the runnable classes proposed within it and what their benefits over plain-old PHP scripts are.

Let's start with an overview of command line scripts' requirements:

• Parameter handling
• Usage
• Output informational text to standard output, errors to standard error
• Simulation mode/testability

Loading resources

Yesterday we talked about what is the most elegant way to load a resource existing "alongside" a class. With "alongside", we mean:

$ ls -a de/thekid/demo/
.  ..  BusinessLogic.class.php  bl-config.ini

<?php 
  $r= ClassLoader::getDefault()->getResource(
    strtr($this->getClass()->getPackage()->getName(), '.', '/').'/bl-config.ini'
  );
?>

<?php 
  $r= $this->getClass()->getPackage()->getResource('bl-config.ini');
?>

Tokenizing

To split up a string into tokens, you may have used strtok() (although it has problems, as is documented here). The XP Framework offers a replacement - the text.StringTokenizer class, which you may use as follows:

<?php 
  $st= new StringTokenizer("Hello World!\nThis is an example", " \n");
  while ($st->hasMoreTokens()) {
    printf("- %s\n", $st->nextToken());
  }
?>

Showcase: The create() function

As a side product of RFC #0106, the create() core functionality, which is used to create generic objects, provides an overloaded variant of itself: When passed an object, it will return it.

This may seem a bit strange (and kind of useless) in the first moment, but actually solves a deficit in the PHP parser, which does not allow chaining after new:

<?php 
  $c= new Criteria()->add('author_id', 501, EQUAL);  // Parse error
?>

<?php 
  $c= create(new Criteria())->add('author_id', 501, EQUAL);
?>

Introducing Generics

With RFC #0106 implemented, the collection API now offers generics support.

What are generics?
To best explain what generics are let's start with a non-generic example of a container class:

<?php 
  class Container extends Object {
    public $elements= array();
  
    public function add(Generic $o) {
      $this->elements[]= $o;
    }
  }
?>

<?php 
  $container= new Container();
  $container->add(new Integer(5));
  $container->add(new Integer(1));
  
  // ... and then somewhere later on:
  $container->add(new String('Hello'));
  
  // ... and finally, somewhere completely different:
  foreach ($container->elements() as $number) {
    Console::writeLine($number->intValue());
  }
?>

Subscribe

You can subscribe to the XP framework's news by using RSS syndication.

Categories