Examples

5.8 Feature showcase: Accessing class interna

The XP Framework's 5.8-SERIES contains a feature that will allow the reflection API to access private and protected members. Of course, just because you can, doesn't mean you should, as this does allow you to break the encapsulation principle.

On the other side, this feature comes in handy for serialization mechanisms, as well as for reflection-based factory or delegation patterns.

Generics of primitives

Like in C# (and unlike Java), primitives can be used as components of generics in the 5.8-SERIES. Given a vector util.collections.Vector<string>, the following applies:

  // OK
  $v[]= "Hello";
  
  // Throws a lang.IllegalArgumentException 
  $v[]= 1;

Fluent XML with the XP Framework

To create an XML tree programmatically, the XP Framework has offered the xml.Tree class since its beginning in 2001. Recently, we've added a fluent interface to it, allowing for the following:

  $t= create(new Tree())->withRoot(create(new Node('book'))
    ->withChild(new Node('author', 'Timm'))
    ->withChild(new Node('isbn', '978-0000000000'))
    ->withChild(new Node('title', 'Fluent XML with the XP Framework'))
  );

Merging XAR files

With the 5.7.7-RELEASE there has a nitfy small feature been added to the xar command: merging multiple XAR files. XAR files are the archives in which XP Framework applications can ship their classes and/or resource files in a way comparable to Java`s .jar-files.

Combining multiple xar files into one can be handy one the one hand, because you can merge all dependencies and the application itself into one single file and only have to provide the one. On the other hand, for applications where startup or I/O performance is a concern, it can be useful: each xar file involved in an application comes with a startup time penalty - the file must be opened, the index must be read before the first file can be retrieved. Here, a single file instead of many files mean increased startup performance and less I/O calls of an application.

This is how it works:

Alex@mobile ~/dev/xp.public/trunk
$ xar cf one.xar ChangeLog

Alex@mobile ~/dev/xp.public/trunk
$ xar cf two.xar skeleton/VERSION=VERSION

Alex@mobile ~/dev/xp.public/trunk
$ xar mf merge.xar one.xar two.xar

Alex@mobile ~/dev/xp.public/trunk
$ xar tvf merge.xar
    58.978 ChangeLog
        10 VERSION

Reading gzip'ed websites

To reduce bandwidth some servers have their content zipped using solutions such as Apache's mod_deflate. This is done only if the Accept-Encoding request header contains the string gzip. Combining the XP Framework's peer.http API with the new io.streams.GzDecompressingInputStream one can accomplish this compression:

  $conn= new HttpConnection($args[0]);
  $response= $conn->get(array(), array('Accept-Encoding' => 'gzip'));
  
  if ('gzip' == $response->getHeader('Content-Encoding')) {
    $in= new GzDecompressingInputStream($r->getInputStream());
  } else {
    $in= $r->getInputStream();
  }
  
  // Now read $in as with any other stream...

Compressing data

The possibly easiest way to compress data in PHP is to use the string-in, string-out functions such as gzdeflate or bzcompress. For small number of bytes being passed in, this is fast and convenient, but it doesn't do well when working with large files, for example:

  FileUtil::setContents(
    $out, 
    gzdeflate(FileUtil::getContents($in))
  );

  $is= $in->getInputStream();
  $os= new DeflatingOutputStream($out->getOutputStream());
  while ($is->available() > 0) {
    $os->write($is->read());
  }
  $is->close();
  $os->close();

Type duplication in xpcli injections

It's just become another bit easier to write command line classes in the XP framework ("xpclis"). When using the @inject annotation you no longer have to specify the type parameter if you use a so-called "type hint" - so instead of writing the following:

  #[@inject(type= 'rdbms.DBConnection', name= 'caffeine')]
  public function setConnection(DBConnection $conn) { ... }

  #[@inject(name= 'caffeine')]
  public function setConnection(DBConnection $conn) { ... }

New xml.Node::withChild() method

To easily create XML documents, the xml.Node class has been extended with a new withChild() method complementing addChild(). In contrast to the latter, withChild() returns the node the child was added to instead of the added child.

Unified runners in the web

The XP framework had offered developers the power of an easy class loading setup via the new XP runners that are delivered with every release since several releases now. These runners have proven themselves very useful in day-to-day business, so we're working on porting them to the web!

With the so-called web-runners these new cool and useful features will become available for you:

• Easier classpath setup
  Classpaths will be constructed from .pth files, in the same manner as xpcli does it.


• No boilerplate "index.php"s any more
  you won't need the same index.php over and over in every project again; even more: you don't need any entrypoint .php any more even for SOAP- or JSON-endpoints.


• Multiple etc/ configuration directories
  you can switch between multipe etc/, eg. one for the test server and one for production, by changing a single file


• Overwrite arbitrary settings for special servers
  you can overwrite settings, eg. debugging settings, based on where your application runs - eg. on the development machine, you can have debugging enabled, while on production it's disabled. You don't need to have different files for them - no more mistakenly committed debug settings.

Redirecting console output

To capture output written by any of the PHP functions the ouput control functions can be used (ob_start(), ob_get_contents() and friends). These functions do not affect the output made by the util.cmd.Console class as this writes directly to the standard out and error streams. To redirect these, you can use the following:

  // Save original stream in variable, change output stream to $stream
  $out= Console::$out->getStream();
  Console::$out->setStream($stream);
  
  // Write "Hello" and a newline, this will trigger $stream's write() method
  Console::writeLine('Hello');
  
  // Finally, restore original output stream  
  Console::$out->setStream($out);

Subscribe

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

Categories