2008 - Eric Feminella

Package-level function closures in ActionScript

Package-level function closures are very useful for creating generalized functionality which does not require a class (static methods) or instance of a class (instance methods).

Unlike static and instance methods package-level function closures are not associated with a class or instance of a class but rather with a package. There are no syntactical differences between package-level functions and static or instance methods.

Package-level functions are for the most part utility functions; for instance the flash.utils package contains a number of package-level functions, the most common of which are describeType(), getDefintionByName(), getTimer() and so forth.

Package-level function closures are created by defining a function directly inside the body of a package (where class and interfaces are defined), as can be seen in the following example:

package com.ericfeminella.display

{

import flash.display.Bitmap;

import flash.display.IBitmapDrawable;

import mx.graphics.ImageSnapshot;

public function createSnapShot(target:IBitmapDrawable) : Bitmap

{

return new Bitmap( ImageSnapshot.captureBitmapData( target ) );

}

Calling a package level function is straightforward, simply import the function just as you would a class or interface and then invoke the function directly…

// import package function

import com.ericfeminella.display.createSnapShot;

// once imported the function can be invoked

createSnapShot( this );

Typically you will find that most functionality can be grouped to a Class or an instance object, however on occasion you may identify specific functionality which is common to packaged functionality as opposed to a specific object, and in these cases utilizing package-level functions is a great option.

May 6, 2008 Object Oriented Design / Software Engineering

11 Comments

Passing …(rest) parameters between functions

At some point when developing an application with ActionScript 3 you may need to pass a …(rest) parameter to a subsequent function call, and although at first this may appear to be pretty straightforward, doing so will not produce the results one might expect.

For example, consider the following method doSomething which accepts a single …rest parameter:

public function doSomething(...rest) : void {

var n:int = rest.length;

trace( "...rest.length = " + n );

for (var i:int = 0; i < n; i++) {

trace( rest[i] );

}

doSomething("a","b","c");

// outputs:

// ...rest.length = 3

// a

// b

// c

Let’s say we also have another function we need to invoke called doSomethingElse which accepts a …(rest) parameter as well:

public function doSomethingElse(...rest) : void {

var n:int = rest.length;

trace( "...rest.length = " + n );

for (var i:int = 0; i < n; i++) {

trace( rest[i] );

}

Now suppose we need to pass the ...(rest) parameter from the doSomething function to the doSomethingElse function. The result would be as follows:

public function doSomething(...rest) : void {

var n:int = rest.length;

trace( "...rest.length = " + n );

for (var i:int = 0; i < n; i++) {

trace( rest[i] );

}

doSomethingElse( rest);

}

// doSomething outputs:

// ...rest.length = 3

// a

// b

// c

// doSomethingElse outputs:

// ...rest.length = 1

// a,b,c

So what went wrong? What happens is the original …rest parameter (passed to doSomething) is now being passed as a single parameter of type Array to the subsequent function (doSomethingElse), not as an Array of individual arguments as you may have expected.

This can easily be resolved by using Function.apply(); as can be seen in the following:

public function doSomething(...rest) : void {

var n:int = rest.length;

trace( "...rest.length = " + n );

for (var i:int = 0; i < n; i++) {

trace( rest[i] );

}

doSomethingElse.apply( null, rest);

}

// doSomething outputs:

// ...rest.length = 3

// a

// b

// c

// doSomethingElse outputs:

// ...rest.length = 3

// a

// b

// c

What we are doing is applying the call to the doSomethingElse function with the original rest parameter as if we were invoking the function directly. So keep this in mind should you ever need to pass a …rest parameter to a subsequent function.

April 22, 2008 News

7 Comments

Web-Based UML Sequence Diagram Generator

If you need to create sequence diagrams quickly and do not have the time to use the more traditional Software Modeling tools; Together, Enterprise Architect, Visio etc. you should take a look at www.websequencediagrams.com.

This handy little tool is pretty capable for a free web based utility and is very easy to use. It took me just seconds to create the simple sequence diagram below…

So the next time you need to create UML sequence diagrams in a hurry make sure to check out this very useful tool.

April 14, 2008 Software Engineering

2 Comments

Collections API update

I recently made a number of updates to my collections API which include some minor changes to the existing code as well as a few additional classes and interfaces which have been added.

The most significant updates involve three additional operations which have been added to the IMap interface which are as follows:

putAll(table:Dictionary) : void;
Allows an Object or Dictionary instance of key / value pairs to be added to an IMap implementation.

putEntry(entry:IHashMapEntry) : void;
Serves as a pseudo-overloaded implementation of the put(key:*, value:*); method in order to allow Strongly typed key / value implementations to be added to a map.

getEntries() : IList;
Returns an IList of HashMapEntry objects based on all key/value pairs

I have also added two new additional IMap implementations to the collections API; LocalPersistenceMap, which can be utilized to provide an IMap implementation into a local SharedObject and ResourceMap which allows developers to work with a ResourceBundles via an IMap implementation. All IMap implementations; HashMap, ResourceMap and LocalPersistenceMap have been updated to implement the new operations.

The IIterator interface has been renamed to Iterator. In addition the remove() operation has been omitted in order to enforce that a concrete implementations can not modify an aggregate. Additionally, ICollectionViewSortHelper has been renamed to CollectionSortUtil.

Some design decisions worth mentioning involve the inclusion of multiple IMap implementations; HashMap, ResouceMap and LocalPersistanceMap. Initially I identified an AbstractMap from which these classes would extend, however I realize some developers may want to minimize dependencies as much as possible therefore I decided to simply have each concrete map implement the IMap interface rather than extend an abstract map implementation.

The source, binary and ASDocs for the new Collections API can be downloaded here.

The Collections API is published under the MIT license.

April 2, 2008 News

13 Comments

Cairngen Project moved to Google Code!

Since the initial release of Cairngen 1.0 there has been an amazing amount of interest in the project and your feedback has been very encouraging. In addition I have received a number of extremely valuable customizations from community members, many of which have made it into subsequent releases.

In order to provide a solid foundation to help facilitate a collaborative Open Source initiative for the Cairngen Project I have decided to move the project to Google Code.

Moving Cairngen to Google Code allows for a number of significant development benefits for the Cairngorm Community. This includes regular development updates, access to all releases, availability of all source code revisions, better documentation, defect lists, feature requests and much more.

I am currently accepting requests for new contributors so if you feel you have added new functionality which would provide benefit to the project visit the Become a Contributor page. All comments on the project are welcome and encouraged. In addition I strongly recommend the if you have any issues with Cairngen, especially environmental issues you should log them to the Issues Page.

Along with the new Cairngen Google Code Project I have also released Cairngen 2.1.1 which aligns the source project with the new SVN repository.

So go check out all of the new information on Cairngen at the new Cairngen Project Home.

March 31, 2008 News

1 Comment

Using multiline values in properties files

When building localized Flex applications with ResourceBundle there are a few tricks you may not be aware of which can come in handy should you need them.

I have had quite a few people ask how multiline values can be specified in a properties file. This is a pretty common question and luckily the answer is very simple: backslash (\).

For example, suppose you have a properties file which contains a string resource with a really long value, like a paragraph. Typically the property value will just be one really long String on one line. However you can use the backslash (\) character to continue the value on multiple lines in order to make the properties file more legible, such as in the following example:

title = Welcome

message = Lorem ipsum dolor sit amet, consectetur elit, \

sed do eiusmod tempor incididunt ut labore et dolore magna \

aliqua. Ut enim ad minim veniam, quis nostrud exercitation \

ullamco laboris nisi ut aliquip ex ea commodo consequat. \

Duis aute irure dolor in reprehenderit in voluptate velit \

esse cillum dolore eu fugiat nulla pariatur. Excepteur sint\

occaecat cupidatat non proident, sunt in culpa qui officia \

deserunt mollit anim id est laborum.

So if you have properties with very long values remember to use backslash (\) to help clean up your resources.

example

March 24, 2008 News

3 Comments