It returns the memory currently being used by the Flash Player. It’s in bytes so it pays to clean it up slightly.

[as]
var mem:String = Number( System.totalMemory / 1024 / 1024 ).toFixed( 2 ) + ‘Mb’;
trace( mem ); // eg traces “24.94Mb”
[/as]

It seems this takes account of all instances of the flash player. For example, I have a logger/debug panel running in the sidebar of firefox, built in flex. As soon as I open this and it’s initialised, it uses an extra 5 – 10mb of ram. So be warned, if you see a massive increase in memory usage, check you don’t have loads of sites open with ad banners or other flash based stuff.

I found ActionScript 3.0 and AVM2: Performance Tuning by Gary Grossman, which covers many aspects of how AVM2 is different from AVM1. The part I was interested in was about $init and $cinit (class constructor) functions being interpreted and everything else being JIT.

The initial setup of the engine runs over a timed loop (to stop script timeouts), and this was typically taking 20 to 30 seconds. After reading the above PDF, it became clear that class constructors are interpreted, not JIT compiled, so all I had to do was move the code out of the constructor, into an init() function, and call if after the constructor, this shaved a huge amount of time off the initial build of the landscape.

Some initial tests, with a for loop running from 0 to 10000 showed that in the constructor it took about 350ms, and called via another method, it took only 240ms. It is not always faster, but 90% of the time it’s faster.

here’s my test example
[as]
public class Class1
{
import flash.utils.getTimer;

public function Class1()
{
var t:int = getTimer();
var a:Array = [];
var i:int;
for( i=0; i< 1000000; i++)
{
var x:int = i*i;
a.push( x );
}
trace( ‘constructor: ‘ + (getTimer() – t) );
}

public function init():void
{
var t:int = getTimer();
var a:Array = [];
var i:int;
for( i=0; i< 1000000; i++)
{
var x:int = i*i;
a.push( x );
}
trace( ‘init method: ‘ + (getTimer() – t) );
}
}
[/as]

in the .fla I simply add:
[as]
var c1:Class1 = new Class1();
c1.init();
[/as]

[as]
package
{
public class Singleton
{
public static var instance:Singleton;

public static function getInstance():Singleton
{
if( instance == null ) instance = new Singleton( new SingletonEnforcer() );
return instance;
}

public function Singleton( pvt:SingletonEnforcer )
{
// init class
}
}
}

internal class SingletonEnforcer{}
[/as]
Note: The class “SingletonEnforcer” is actually placed within the same .as file as the Singleton class, but placed outside the package{} parenthesis, therefore, the class “SingletonEnforcer” can only be accessed from within this .as file, so if the Singleton’s constructor is called from anywhere else, you’ll get an error.

I set up a for loop, to count backwards through an Array. But for some strange reason the loop was never terminating! It was simple, here’s the original code

[as]
var i:uint;
for( i=arr.length-1; i>=0; i– )
{
}
[/as]

The mistake was simple, I had set i as a uint, so it could never go below 0, so just had to make i an int. It sounds stupid once you realise it, but it wasted enough of my time!

private var _current:Number;

function LoopRange( min:Number, max:Number, start:Number )
{
this.min = min;
this.max = max;
_current = start || min;
}

public function next():Number
{
_current = _current+1 <= max? _current+1 : min;
return _current;
}

public function previous():Number
{
_current = _current-1 >= min? _current-1 : max;
return _current;
}

public function set current( value:Number ):Void
{
if( value >= min && value <= max ) _current = value;
else throw new GenericError( ‘number ‘ + value + ‘ is out of range [ ' + min + ', ' + max + ' ]‘ );
}

public function get current():Number
{
return _current;
}
}
[/as]

To implement this on an array you would do the following

[as]
import com.pixelbreaker.number.LoopRange;

var slideShowImages:Array = [];
for( var i:Number = 0; i {
slideShowImages.push( xmlNode.childNodes[ i ].attributes.src );
}

var loopRange:LoopRange = new LoopRange( 0, slideShowImages.length-1 );

// to load the next image:
myMovieClip.loadMovie( slideShowImages[ loopRange.next() ] );

[/as]

I’ll add the AS3 class soon, it’s barely any different

It literally took me 5 minutes to write a simple wrapper class to handle the loading of the feeds, and simply trace out the headlines of each item.

[as]
package app.feeds
{
import com.adobe.xml.syndication.generic.FeedFactory;
import com.adobe.xml.syndication.generic.IFeed;
import com.adobe.xml.syndication.generic.IItem;

import flash.events.Event;
import flash.net.URLLoader;
import flash.net.URLRequest;

public class FeedLoader
{
private var loader:URLLoader;

public var feed:IFeed;

public function FeedLoader( feedURL:String )
{
loader = new URLLoader();
loader.addEventListener( Event.COMPLETE, loadComplete );
loader.load( new URLRequest( feedURL ) );
}

private function loadComplete( e:Event ):void
{
feed = FeedFactory.getFeedByXML( new XML( e.target.data ) );

var i:uint;
for( i=0; i< feed.items.length; i++ )
{
trace( IItem( feed.items[ i ] ).title );
}
}
}
}
[/as]

To implement:
[as]
var feed1:FeedLoader = new FeedLoader( ‘http://www.guardian.co.uk/rss’ );
[/as]

If you’re using flash as I am, you may find that it spits the dummy when it tries to load mx.utils.StringUtil, you’ll need to add an ActionScript classpath pointing to the flex framework, which on my machine was in “/Applications/Adobe Flex Builder 3/sdks/2.0.1/frameworks/source”

[as]
package
{
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;

public class AbstractExample
{
public function AbstractExample()
{
if( Class( getDefinitionByName( getQualifiedClassName( this ) ) ) == AbstractExample ) throw new Error( ‘AbstractExample must be extended’ );

// rest of constructor here…
}
}
}
[/as]

I like this solution best as it doesn’t rely on strings for comparison as in Tink’s example. His method is shorter, and easier for typing. It’s down to personal preference really.

As class constructors in ActionScript 3.0 must be public, there’s not a really clean way to force a class to be a singleton as there is in ActionScript 2.0 or Java say.

[as]
package
{
public class Singleton
{
public static var instance:Singleton;

public static function getInstance():Singleton
{
if( instance == null ) instance = new Singleton( getInstance );
return instance;
}

public function Singleton( caller:Function )
{
if( caller == Singleton.getInstance )
{
// instantiate class here
}
else
{
throw new Error( ‘Singleton is a singleton, use getInstance();’ );
}
}
}
}
[/as]

It’s pretty simple, you can’t call new Singleton() because the compiler will be expecting an argument, and if you do pass an argument, it will throw an Error because the caller is not the Singleton.getInstance method.

So you can only access this class by calling Singleton.getInstance().