The basic idea is simple, as we do not has any kind of object signature (a unique string equivalent, usually its memory address) to use as the key, we need to store both key and value and then make a loop through all the items, doing comparison until we come across the correct one. You might think that this will cause much overhead (searching a lot) but remember that whatever type of script we used, this overhead can not be avoided.

For better performance (prevent searching whenever possible), I added a property checkExistance when adding a key (default to true) so you can turn off the default behavior by setting it to false if you sure that the key has not yet been used (of course, this can break the code if you don’t use it correctly so be careful when using this).

Here is the usage syntax (it’s quite similar to AS3) :

var d = new HDictionary();

//to set a key :
d.setKey(key, value, checkExistance);

//to get value from a key :
d.getValue(key); //should return value

//to check for key existance
d.hasKey(key); //return true / false

//to delete a key
d.deleteKey(key);

package vn.core;

class HDictionary {
	private var _map 	: List<Pair>;
	
	public function new() {
		_map  = new List<Pair>();
	}
	
	private function getPair(key: Dynamic): Pair {
		for (p in _map) {
			if (p.key == key) return p;
		}
		return null;
	}
	
	/*******************************
	 * 		PUBLIC APIS
	 ******************************/
	
	public function hasKey(key: Dynamic): Bool {
		var p = getPair(key);
		return p != null;
	}
	
	public function deleteKey(key: Dynamic): Void {
		var p = getPair(key);
		if (p != null) _map.remove(p);
	}
	
	public function getValue(key: Dynamic): Dynamic {
		var p = getPair(key);
		return p == null ? null : p.value;
	}
	
	public function setKey(key: Dynamic, value: Dynamic, checkExistance: Bool = true): Void {
		if (!checkExistance) {//prevent looking up overhead
			_map.push( { key: key, value: value} );
		} else {
			var o = getPair(key);
			if (o != null) {//modify value if key already exist
				o.value = value;
			} else {//create new Pair if key not yet exist
				_map.push( { key: key, value: value} );
			}
		}
	}
}

typedef Pair = { key: Dynamic, value: Dynamic }

Download HDictionary.hx

One class for one thing should be the way to go, though it’s heavier in term of code base, the maintainable process should be easy enough, just move it somewhere, rename the package once if needed. No missing or conflicted dependencies to worry about …

One cool thing in this version is that you don’t need to cancel out theme configuration : if a state used bold = true, we don’t need to cancel out for other state, aka, doesn’t need to put bold=false for each other states. Another one is that we can do input configuration from timeline.

There is simple usage syntax :

• From code :
  

  var input : Input = new Input().setConfig( { hint:'hello, input something here !' } );
  addChild(input.skin);
  

• From timeline textfield / timeline MovieClip

new Input()	.setConfig( { hint:'hello, input something here !' } )
		.setSkin(mc);

• From timeline textfield / timeline MovieClip

//we need firstly create a new theme
Input.addTheme(	'dark',	{color: 0xFFFFFF} //input
		,	{color: 0x555555, italic: true} //hint
		,	{border: true, borderColor: 0xff0000, color: 0xFF0000} //invalid
		,	{color : 0xAAAAAA}
		);

//then use it
input.themeId = 'dark';

And as usual, code for the ones who don’t want to download just to read : In this class, the main class is Input, other internal classes are utilities

package {
	import flash.display.BlendMode;
	import flash.display.DisplayObject;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.FocusEvent;
	import flash.events.KeyboardEvent;
	import flash.text.TextField;
	import flash.ui.Keyboard;
	import flash.utils.setTimeout;

	public class Input {

		public static function addTheme(id: String, inputFormat: Object, hintFormat: Object
				, inValidFormat: Object, validFormat: Object, useAsDefault: Boolean = false): void {
			InputTheme.newTheme(id, inputFormat, hintFormat, inValidFormat, validFormat, useAsDefault);
		}

		public function Input() {
			_config		= new InputConfig();
			_content	= '';
		}

	/***************************
	 * 	SHORT CUT / CALLBACK
	 *
	 ***************************/

		private var _onChange_Func 		: Function;
		private var _onChange_Params 	: Array;

		private var _onComplete_Func	: Function;
		private var _onComplete_Params	: Array;

		public function onInputChange(func: Function, params : Array = null): Input {
			_onChange_Func		= func;
			_onChange_Params	= params;
			return this;
		}

		public function onInputComplete(func: Function, params : Array = null): Input {
			_onComplete_Func	= func;
			_onComplete_Params	= params;
			return this;
		}

	/********************
	 * 		TARGET
	 ********************/

		private var _skin			: DisplayObject;
		private var _textfield		: TextField;

		public function get skin():DisplayObject {
			if (!_skin) setSkin(InputUtils.getDefaultTextField());
			return _skin;
		}

		public function set skin(pdo:DisplayObject):void { setSkin(pdo); }

		public function setSkin(pdo:DisplayObject):Input {
			if (_textfield) removeTextField(_textfield);
			if (!pdo) return this;

			_textfield	= pdo as TextField;
			if (!_theme) _theme = InputTheme.getTheme(null); //get default theme

			if (_textfield) { //use default settings
				addTextField(_textfield);
			} else if (pdo is MovieClip) {
				var mc : MovieClip = pdo as MovieClip;
				_textfield = (mc.txt || mc.getChildAt(0)) as TextField;
				addTextField(_textfield);
				setConfig(mc.inputConfig);
			} else {
				trace(this, 'Error trying to setSkin to an invalid target, named ', pdo.name);
				return this;
			}
			_skin = pdo;
			return this;
		}

		private function addTextField(tf: TextField): void {
			tf.blendMode	= BlendMode.LAYER;
			oProps			= _theme.saveOriginalProps(_textfield);

			tf.text			= (_content == '') ? _config.hint : _content;
			refreshTheme();

			tf.addEventListener(FocusEvent.FOCUS_IN,		_onGainFocus);
			tf.addEventListener(FocusEvent.FOCUS_OUT,		_onLooseFocus);
			tf.addEventListener(KeyboardEvent.KEY_DOWN,		_onKeyDown);
			tf.addEventListener(Event.CHANGE,				_onTextChanged);
		}

		private function removeTextField(tf: TextField): void {
			_theme.revert2OriginalProps(tf, oProps);//return properties

			tf.removeEventListener(FocusEvent.FOCUS_IN,		_onGainFocus);
			tf.removeEventListener(FocusEvent.FOCUS_OUT,	_onLooseFocus);
			tf.removeEventListener(KeyboardEvent.KEY_DOWN,	_onKeyDown);
			tf.removeEventListener(Event.CHANGE,			_onTextChanged);
		}

		private function _onKeyDown(e: KeyboardEvent): void {
			if (e.keyCode == Keyboard.ENTER && !_textfield.multiline) {//apply new content
				killFocus();

			} else if (e.keyCode == Keyboard.ESCAPE) {//revert to old content
				_textfield.text	= _content;
				killFocus();
			}
		}

		private function _onTextChanged(e: Event): void {
			//TODO : adding support for delay
			if (_onChange_Func != null) _onChange_Func.apply(null, _onChange_Params);
		}

	/********************
	 * 		FOCUS
	 ********************/

		private var _isFocus 	: Boolean;

		public function get isFocus():Boolean { return _isFocus; }
		public function set isFocus(value:Boolean):void { value ? gainFocus() : killFocus(); }

		private function gainFocus(): void { _textfield.stage.focus = _textfield; }
		private function killFocus(): void { if (_textfield.stage.focus == _textfield) _textfield.stage.focus = null; }

		private function _onGainFocus(e: Event): void {
			_isFocus = true;
			if (_content == '') _textfield.text = ''; //clear hint
			refreshTheme();
		}

		private function _onLooseFocus(e: Event): void {
			_isFocus = false;
			if (_content != _textfield.text) {
				_content = _textfield.text;
				if (_onComplete_Func != null) _onComplete_Func.apply(null, _onComplete_Params);
			}

			if (_content == '') _textfield.text = _config.hint;
			refreshTheme();
		}

	/********************
	 * 		THEME
	 ********************/

		private var _theme		: InputTheme;
		private var oProps		: Object;

		public function get themeId():String { return _theme.id; }

		public function set themeId(value:String):void {
			if (_theme) _theme.revert2OriginalProps(_textfield, oProps);
			_theme	= InputTheme.getTheme(value);
			oProps	= _theme.saveOriginalProps(_textfield);
			refreshTheme();
		}

		protected function refreshTheme():void {
			if (_config.regExp) _config.regExp.lastIndex = 0;
			_vContent = (!_config.regExp || _config.regExp.test(_content)) ? _content : null;
			_theme.apply(_textfield, oProps,	_isFocus		? InputState.INPUT	:
												_content == ''	? InputState.HINT	:
												_vContent		? InputState.VALID	: InputState.INVALID);
		}

	/********************
	 * 		CONFIG
	 ********************/

		private var _config : InputConfig;

		public function setConfig(cfg: Object): Input {
			_config.reset(cfg);
			return this;
		}

	/********************
	 * 		API
	 ********************/

		private var _content	: String;
		private var _vContent	: String;

		public function get content():String { return _isFocus ? _textfield.text : _content; }

		public function set content(value:String):void {
			_content = value || '';
			_textfield.text = _content;
			refreshTheme();
		}

		public function get validatedContent(): String {
			if (_isFocus) killFocus();
			return _vContent;
		}
	}
}
[sourcecode language="Actionscript3"]
//4 different states to apply different formats
class InputState {
	public static const HINT	: int = 0;
	public static const INPUT	: int = 1;
	public static const VALID	: int = 2;
	public static const INVALID	: int = 3;
}

//Configuration for Input field – restrict input someway

class InputConfig {
	public var isRequired	: Boolean;
	public var trimSpaces	: Boolean;
	public var liveDelay	: Number; // call onInput for every text changes happens in every _liveDelay seconds
	public var hint			: String;
	public var regExp		: RegExp; //array of expressions

	public function reset(cfg: Object): void {
		hint			= cfg.hint || '';
		isRequired		= cfg.isRequired == true;
		trimSpaces		= cfg.trimSpace	!= false;
		regExp			= cfg.regExp;
		liveDelay		= parseFloat(cfg.liveDelay || '0.5');
	}
}

//Save the 4 state format information

class InputTheme {
	private static var dict			: Dictionary;
	private static var defaultTheme	: InputTheme;

	public static function newTheme(id: String, hint: Object, input:Object, valid:Object, invalid:Object, useAsDefault: Boolean = false): InputTheme {
		if (!dict) dict = new Dictionary();
		if (dict[id]) trace('[InputTheme :: overwritting the existed theme with id=' + id + ']');

		var theme : InputTheme = new InputTheme(id, hint, input, valid, invalid);
		dict[id] = theme;
		if (useAsDefault) defaultTheme = theme;

		return theme;
	}

	public static function getTheme(id: String = null): InputTheme {
		var theme : InputTheme = dict && id ? dict[id] : null;
		if (!theme) {
			if (!defaultTheme) {
				defaultTheme = new InputTheme('default',
						{ textColor: 0x888888 , italic : true, border: true, borderColor:  0x888888},
						{ textColor: 0x555555, border: true, borderColor: 0x0000ff },
						{ textColor: 0x000000, border: true, borderColor: 0x000000 },
						{ textColor: 0x880000, border: true, borderColor: 0x880000 }
					);

			}
			return defaultTheme;
		}
		return theme;
	}

	private var format		: Array;
	public var id			: String;

	public function InputTheme(id: String, hint: Object, input:Object, valid:Object, invalid:Object) {
		this.id = id;
		format = [hint || {}, input || {}, valid || {}, invalid || {}];
	}

	public function apply(tf: TextField, oProps : Object, type:int): void {
		var obj :Object = InputUtils.copyProps(oProps);
		obj = InputUtils.copyProps(format[type], obj)
		InputUtils.formatText(tf, obj);
	}

	public function saveOriginalProps(tf: TextField): Object {
		var propList : Object = { };

		//values are not important !
		InputUtils.copyProps(format[0], propList);
		InputUtils.copyProps(format[1], propList);
		InputUtils.copyProps(format[2], propList);
		InputUtils.copyProps(format[3], propList);

		return InputUtils.getDefaultProps(tf, propList);
	}

	public function revert2OriginalProps(tf: TextField, oProps: Object): void {
		InputUtils.formatText(tf, oProps);
	}
}

//Various utilities use internally – duplicated to be stand alone

class InputUtils {

	private static var txtFormat : Object = { bold: 1, italic: 1, underline : 1, color : 1, font : 1, size : 1, align : 1, blockIndent : 1, indent : 1, kerning : 1, leading	: 1, leftMargin : 1, rightMargin : 1, tabStops : 1, letterSpacing : 1, bullet : 1, url : 1, target : 1 };

	public static function formatText(txt: TextField, props: Object): TextField {
		var formatObj : Object = { };

		for (var prop : String in props) {
			trace('formatting :: ', prop, props[prop]);
			if (prop in txtFormat) {
				formatObj[prop] = props[prop];
			} else {//set direct
				txt[prop] = props[prop];
			}
		}

		var tf : TextFormat = txt.getTextFormat();
		for (prop in formatObj) {
			tf[prop] = formatObj[prop];
		}
		txt.setTextFormat(tf);
		txt.defaultTextFormat = tf;

		return txt;
	}

	public static function copyProps(src: Object, tar: Object = null): Object {
		if (!tar) tar = { };
		for (var s : String in src) { tar[s] = src[s]; }
		return tar;
	}

	public static function getDefaultProps(tf: TextField, src: Object): * {
		var tfm		: TextFormat = tf.defaultTextFormat;
		var props	: Object = {};

		//trace('here is default props :: ');

		for (var s: String in src) {
			props[s] = (s in txtFormat) ? tfm[s] : tf[s];
			//trace('s :: ', s, props[s]);
		}

		return props;
	}

	public static function getDefaultTextField(): TextField {
		return formatText(new TextField(), { type: TextFieldType.INPUT, multiline: false, width: 150, height: 25, size: 16 } );
	}
}

I found this class still missing some of the basic features like supportting for password (in configuration). There should be an update once i got to use it in a real project, stay tune !

I don’t know how hard it is for the Flash CS team to add an api allowing us to catch and stop when there are errors building .fla file, but this surely make enough troublesome for me : Once there are errors, i need to wait for the batch building complete then compile one by one manually… so finally decision, there must be a way to do it in jsfl.

The basic idea is although we can’t know directly if there are errors in the building process, we can save the compile errors into a temporary file, then read it back, parse the string and find if there are errors before trying to build the next one. Here is the simplest form :

function exportAll(){ 
	var docs=fl.documents;
	var docs_length=docs.length;
	for (var i=0; i<docs_length; i++) {  
		var doc=docs[i];
		doc.publish();
		
		var docErrorURI= "file:///c|/"+doc.name + ".errors";
		fl.compilerErrors.save(docErrorURI);
		var contents	= FLfile.read(docErrorURI);
		var arr	= contents.split("\n");
		var errorCount	= arr[arr.length-1].split(" ")[0];
		FLfile.remove(docErrorURI);
		
		if (errorCount == 0){
			doc.close(false);
		} else {
			break;
		}
	}
}
exportAll();

There are many other features you may want to add like open all .fla files inside a folder (with exceptions ?), delete .aso files, save file open state, monitor building log and allow continue build after errors for specific module is fixed or a specific .swf file to run after the build completes …

I might update the file with new features in future releases, but as it’s for now doing the job, i will stick with it at least for sometime. (there won’t be any planned updates in near future)

UPDATE 05.NOV.2011 ——————————————————————————————

For files that are not yet open, we have a way to build them directly, this resulted in faster compiled time. Using the method above to break the building stack if there are errors, we can now build a list of fla files within a single click. Remember that this is only available for flash CS4 10.0.2 and later. For earlier version of the IDE, you will still need to open the file before publish it.

And here is the code, you can change the basePath and the fileList once for each project and then you are good to go.

basePath	= "file:///D:/"
fileList	=	[	'file1.fla',
				'file2.fla'
			];

//CS5 :
for (i=0; i<fileList.length; i++){
	fl.publishDocument(basePath + fileList[i]);
	var docErrorURI= basePath + fileList[i].split(".fla")[0] + ".errors";
	fl.compilerErrors.save(docErrorURI);
	var contents	= FLfile.read(docErrorURI);
	var arr	= contents.split("\n");
	var errorCount	= arr[arr.length-1].split(" ")[0];
	FLfile.remove(docErrorURI);
	if (errorCount > 0) break;
}

Once again, this is not the ultimate solution, there are other features to add like checking for the IDE version by parsing fl.version so it will compatible with all IDEs. But at least it’s doing right for my need, i will keep this simple version.

_sourceDict : Dictionary; /* map IEventDispatchers to _eventObjects */
_eventObject : Object; /* map eventName to _handlerDict */
_handlerDict : Dictionary; /* map handler to its params */

For faster check and overwrite the existed _handler for a specific source and eventName we need to use a Dictionary for _handlerDict instead of an Array, and by the way, add support for user parameters.

This data structure of course will still work without any problem even though the code looks busy by nested properties access. We might also got slow down by looping through those nested structure. Let’s have a look through another implementation where we save multiple values as the key instead of only one.

//how about :
function addListener(source, eventName, handler, params): void {
	mkd.setValue(function (e: Event): void {
		handler.apply(null, params);
	}, source, eventName, handler); // --> value, key1, key2, key3
}

//instead of 
function addListener(source, eventName, handler, params): void {
	var evtObj	: Object = _dict[ source] ||= {};
	var handlerDict	: Dictionary = evtObj[eventName] || new Dictionary();
	handlerDict[handler] = function (e: Event): void {
		handler.apply(null, params);
	}
}

package vn.core.data 
{
	import flash.utils.Dictionary;
	/**
	 * ...
	 * @author thienhaflash
	 */
	public class MultiKey 
	{
		private var keys 		: Dictionary;
		private var keyCnt		: int;
		private var key2Value	: Dictionary; /* Object should also be fine here */
		
		private function combineKeys(autoNew: Boolean, keyList: Array): Array {
			if (!keys) return null;
			var arr	 : Array = [];
			var ckey : * ;
			var l	 : int = keyList.length;
			
			for (var i: int = 0; i <l; i++) {//keep the order !
				ckey = keys[keyList[i]];
				if (!ckey) { //skip zero !
					if (autoNew) {
						keys[keyList[i]]	= ++keyCnt;
						keys[keyCnt]		= keyList[i];
						ckey				= keyCnt;
					} else {
						return null;
					}
				}
				arr.push(ckey);
			}
			//arr.sort(Array.NUMERIC); /* so the key is unique */
			return arr;
		}
		
		private function isValidKey(keys : Array, combine: Array): Boolean {
			var l: int = combine.length;
			for (var i: int = 0; i < l; i++) {
				if (keys.indexOf(''+combine[i]) == -1) {//can not found some key
					return false;
				}
			}
			return true;
		}
		
		public function break2Key(s: String): Array {
			var arr : Array = s.split('*');
			for (var i: int = arr.length - 1; i > -1; i--) {
				arr[i] = keys[arr[i]];
			}
			return arr;
		}
		
		public function removeValue(...keyList): * {
			var s 		: String = combineKeys(false, keyList).join('*');
			var value	: * ;
			if (s) {
				value = key2Value[s];
				delete key2Value[s];
			}
			return value;
		}
		
		public function filterValues(keyList: Array, returnValues: Boolean = true): Array {
			var combined	: Array = combineKeys(false, keyList);
			var result		: Array = [];
			for (var s : String in key2Value) {
				if (isValidKey(s.split('*'), combined)) {
					result.push(returnValues ? key2Value[s] : s);
				}
			}
			return result;
		}
		
		public function removeValues(keyList: Array, returnValues: Boolean = true): Object {
			var combined	: Array = combineKeys(false, keyList);
			var result		: Object = {};
			for (var s : String in key2Value) {
				if (isValidKey(s.split('*'), combined)) {
					result[s] = key2Value[s];
					delete key2Value[s];
				}
			}
			return result;
		}
		
		public function getValue(...keyList): * {
			var combined	: Array = combineKeys(false, keyList);
			return combined ? key2Value[combined.join('*')] : null;
		}
		
		public function setValue(value: *, ...keyList): void {
			if (!keys) {
				keys = new Dictionary();
				key2Value = new Dictionary();
			}
			key2Value[combineKeys(true, keyList).join('*')] = value;
		}
	}
}

I. THE GENERAL IDEA :

We have a single linked list (to cut memory cost 30% compared to double linked list), every item has a {.next} pointer point to the next item in the list. Every item has a {.priority} property to be used as mandatory sort term, a {.time} stamp for secondary sort term, this way, every item is unique and can be compared to each other without equality worries.

Besides the normal linked list implementation we have another Array {_grid} to keep track of pivots items at some rough space {_gridSize}, that means for every roughly {_gridSize} items in the list we save an item into the {_grid}. This kind of indexing will enable binary search for position of any item in the list which means fast random access to items (fixed (and small) time to reach any item in the list). Of course, this won’t beat Array’s random access, but it’s fast enough for practical use !

II. THE LAZY PIVOT CREATION STRATEGY :

We don’t need to refresh the pivot table for every item insert / remove as it’s not efficient.  As a new pivot can be introduced for every {_gridSize} items added, we only need to refresh the {_grid} for every {_gridSize } items added to the list. Besides that simple check, we can add others checks for special case when new items are always added to the last position (and this seems to be the most popular case in practice) :  we will only need to push new pivots  items into the {_grid} instead of refresh the whole list.

When we iterate through the list using iterStart(), iterNext(), the indexes and pivots will also be updated if needed.

III. THE LAZY DIRTY MARKING / CLEANING STRATEGY :

We divide the _dirty status into 3 states :

• NONE – no dirty at all, all items’ indexes are correct
• SIMPLE – items comes after dirty position {_dirty} have the same index offset {_offset}
• COMPLEX – items comes after _dirty have non-ordered indexes (arbitrary).

So, first thought in your mind : Why should we care about SIMPLE or COMPLEX dirty state instead of just a simple boolean _dirty flag, it’s dirty anyway, what’s the different ? Well, if you have a closer look about SIMPLE you might see that we can know the correct index immediately by a simple check : if the items is before _dirty, its index is correct, if not, the index should be + an offset. So we don’t need to update every _dirty items for every changes and this will improve the performance very much.

Now, second question might raise up : But the SIMPLE case is rare, as we insert/remove two (or more) items into the NONE dirty list, we get COMPLEX dirty and there are no use for SIMPLE at all, right ?  No, it’s not that simple, when a new  item {_new} is insert into the list, we will update the items between {_new} and {_dirty}. After that, we update the _dirty and _offset to the correct values. This way, the list will be at the SIMPLE state almost all the time.

Third question : What if the space between the {_dirty} and {_new} is too large, might be approximated to the length of the whole list ? Isn’t that mean we need to travel through the whole list when that item being inserted ? Well, in the implementation we have a range check, if the number of items need to be updated is more than some specific value {_maxUpdate} we just skip the update and change the _dirty state to COMPLEX. We also have another refined check to keep the list at SIMPLE dirty state for this case : if the {_dirty} or the {_new} is really near to the last item in the list {_last} we will update items from it (the item that is very near to {_last}) to {_last} instead of update the items between {_dirty} and {_new}. We can see that we will never need to update more than {_maxUpdate} items for every item insert / remove

A rather popular solution is using Linked List – either double or single. Linked list has ability to add and remove items very fast at an arbitrary position as no item is being migrated. Double linked list cost more memory (~ 1.5x ) and a bit slower than single Linked List (which, consume 2x more memory than Array) but it allows traversing in both direction. For some operations, the doubles run faster (~ 2x faster) than single ones. But as we won’t have random access to items by numeric indexes like Arrays, it’s really slow if we need to skip forward / backward to get to some random position. In short : Linked List is slowed down by skipping to specific position 

In the classic presentation of Array and Linked List above, Array performs better than Linked List. It’s a popular fact that Linked List out performs Array in term of inserting / removing items at specific position, remember that it’s only true if our current position is also the needed-to-be remove item’s position (a popular case is we are trying to remove a dead item at current position while traversing through the whole linked list). Randomly remove an item in linked list will be much slower than that as we need to skip to the delete item’s position.

So if you have a fixed set of data items like book indexes, address indexes … using Array will be fit for most of the case. Prevent using Linked List unless you really know how it works, as the rule of thumb : Never try random access on a Linked List. There are also cases that we don’t have all data items available at the beginning as items getting added to / removed from the list at random position, random time : a delayed tween queue or a loading queue. In this case, using Array.sort() once for every insertion or call Linked List’s insert() won’t yield any in good performance as the complexity of inserting n items randomly in both case is o(n^2).

We definitely have some better way doing that !

• With Array, we can use a binary search for position and insert new items using splice(). The complexity is now o(log2(n)) + o(n) = o(n).
• With Linked list, we have several options to choose from, regarding Binary Tree, Bias Linked List, or Indexed Linked List. These methods use various strategies to index items so we can both traverse to a specific position faster than linked list, with o(l0g2(n)) complexity.

The Linked List speed gains come with some memory suffers (2x more) for saving indexes positions, initialization (the structure is more complex and heavy) and maintain works (some kind of tree status checking and make changes in the structure as data items come in / out). To minimize the initialization delay and maintain works, Linked List should implements lazy-loading to minimize the works needed for performance gains. Without lazy loading implemented, Linked List is not really a considerable option to choose.

I might update this post with some performance benchmark so you guys can see how each one performs yourself. Specific details on how Linked List being implemented might not fit into a single post so let’s wait for some other ones ….

I. THE STATIC CLASS METHODS IMPLEMENTATION :

Let’s have a look through a simple library class :

package {
	public class MyUtility {
		public static function methodA(): void {
			//do A things here
		}
		public static function methodB(): void {
			//do B things here
		}
	}
}

And its simple usage syntax

MyUtility.methodA();//call method A
MyUtility.methodB();//call method B

1. Memory cost : Static class members will need memory to store all the data, just as class instances, the problem is, the memory got allocated by static class should never be disposed, as its method can be called any time from various places in your (or other guy’s ) code. How can we be able to clear references to static methods of a class ? We can’t. This single factor will degrade our application dramatically over time, as modules get loaded, more and more static classes being deployed got stuck in the memory, and memory footprint raised up.
2. Modules file size : all class libraries got compiled into every modules used them, that means there might be many library duplication over modules, of course, it’s not very efficient if the size of library is big or you are using a lot of static libraries – you force users waiting for things you already have, to be loaded again and again.
3. Rigid binding between these libraries : this will not only disable the ability to unit test them, but also, disable developer to change the dependent libraries later on. Let’s say, if we have a Transition library TransA that got to use a tween engine TweenA then if we are referencing TweenA directly from TransA, TransA will never be able to live without TweenA. That say, if user want to use TransA with some other TweenB engine, he just can’t do that without modify TransA heavily. That’s bad, strong coupling like this is very bad practice and needless to say, we must avoid it.

There is also another popular library implementation : Singleton.

II. THE POPULAR AS3 SINGLETON IMPLEMENTATION :

Basically singleton is just as simple as “prevent user to instantiate a Class and use the only one instance provided instead”. Let’s have a look through the most popular singleton implementation in AS3.

package {
	public class MyUtility {
		function methodA(): void;
		function methodB(): void;

		public function MyUtility(){
			if (_instance) throw
				new Error("MyUtility is singleton and can not be instantiated !");
		}

		protected var _instance : MyUtility = new MyUtility();
		public static function getInstance(): MyUtility { return _instance; }
//you can also change the static function getInstance() to a getter instance for shorter syntax, but the getInstance() is more popular as from my awareness ...
	}
}

Ok, for perfectionist : this is NOT the perfect singleton implementation, yet, as user can still instantiate the class by using try / catch. But it’s non sense fighting for the perfect version as developers won’t use our library just for breaking purpose. As long as they can’t instantiate, they will know it’s singleton and use .getInstance(), that’s enough… Think ! Don’t put your-smart-codes in just to make the library more complex. There are no need for any kind of SingletonEnforcer or secretKey here.

What’s good here is that MyUtility now has only one static method (and one variable) to keep reference to an instance of MyUtility and as long as we want to dispose the Utility we can dispose the only _instance and get back the memory cost (but i don’t see that it will happen very often).

What’s bad here is the usage syntax :

MyUtility.getInstance().methodA();
MyUtility.getInstance().methodB();

Why should i need to .getInstance() all the time ? If there are only one thing to choose from, why should we need to choose? Hey, we don’t need to type that !

Other bad things like module file size cost and rigid binding is still remains.This implementation only solves one problem (memory cost) while introduces another one (stupid syntax).

That’s why you are being told that static is bad and devil and you should keep away from it. Well, i don’t really think that we should keep away from it, but just be careful when it comes to static cases. Static is a language feature, it’s exist for some reasons but it matters how you used it, so again, be careful !

III. A BETTER WAY AROUND :

First thought comes to our mind is that we need to implement an Interface to have Strong typing and smaller file size for modules, basically, modules will only have reference to the Interface instead of the implementation class, the implementation classes will only get compiled into main module. We modify the Singleton a little bit to implements IMyUtility !

package {//first, the interface
	public interface IMyUtility {
		function methodA(): IMyUtility;
		function methodB(): IMyUtility;
	}
}

package {//second, the class implementation
	internal class MyUtilityCore implements IMyUtility {
		public function methodA(): IMyUtility {};
		public function methodB(): IMyUtility {};
	}
}

At this point we have a normal class library implementation with with the present of an interface. You may have noticed that we now have a better jQuery style syntax where methods can be chained. The MyUtilityCore class is now internal, completely prevent users to accidentally instantiate it.

To prevent the heavy MyUtilityCore class gets into the compiled modules, we make another two classes, one for modules to get access to MyUtilityCore functionalities through IMyUtility interface, one for main module to initialize (do inject MyUtilityCore implementation to MyUtility). Here is the simplest version !

package {//fourth, the initialize package function
	public var myUtility : IMyUtility; /* [GETTER] don't change this variable ! */
}

package {//fourth, the initialize package function
	public function initMyUtility(): IMyUtility {
		if (!myUtility) myUtility = new MyUtilityCore();
		return myUtility;
	}
}

For simplicity purpose we don’t want to force myUtility to be a getter as it should be (in that case, we will need another internal class to save the reference to the MyUtilityCore instance because we can not declare a package variable together with a package function in the same file). Make a caution for our developers, that’s enough.

Let’s see what we have up to now. We need to init MyUtility before use, call it only once from the main Module, where the MyUtilityCore class got injected :

initMyUtility();//only call once in the main module

And for each modules, the usage is just the same as the static class method implementation (well, actually a bit better with j-Query chain) :

//use extensively in modules
myUtility.methodA()//call method A
		.methodB();//then call method B

As a brief  conclusion about this implementation :

1. We replace one heavy class (MyUtilityCore) in modules by several lightweight one (myUtility, IMyUtility) to minimize file size in modules.
2. We may keep memory low by disposing the only the instance of MyUtilityCore at anytime by setting myUtility = null.
3. We prevent the rigid classes binding by using interface, later on, if user don’t like our myUtilityCore implementation they can change to another one without worring about code overlaps / fightings.
4. We will need to write more code for each library as there are now 4 instead of just one class. The implementation is a bit more complex, but for me, as long as the result looks best to our users, it’s worth implemeting this !

And that’s it – A better AS3 Singleton implementation. If you have any idea about improving this implementation or a better way doing it, don’t hesitate to raise up your voice, we are all ears listening !

You can also download the sample code FD project 

1. A little bit more on deeplink, ApplicationDomain, and Scaffold :
• When a page is not yet load, we tell Gaia to go to a page with some deeplink, the onDeepLink is not called, why not check and call it manually so developers don’t need doing that themselves ? <will i need to insert sample code here (?)>.
• The domain in site.xml should be “current” by default as that’s beginner assumption if they don’t know anything about ApplicationDomain. I myself don’t use domain other than “current” very often.
• How about one toggle button to enable / disable scaffolding in Gaia panel instead of // on every file in the constructor to toggling them on/off ?
2. Better templating creation : How about we just need to specify a layout folder, Gaia will automatically generate the site.xml based on the pngs / jpgs files in that folder, we can add some naming rules for these files, of course ? And in the generated flas, a layer is also created with the corresponding layout file so we can have a quick reference, we can make an option for user to choose if they want to guide the layer or not ? And of course we can always change the site.xml file then sync if the generation is not perfectly match our idea.
3. Visual pages creation in Gaia panel : It’s easy to open site.xml and edit it, yep, but why should i leave Gaia panel ? How about adding a visual tree then we can add pages just as folders (index should be the root and can not be replaced ? ) and assets can be represented just as files ? Adding / Removing (or even disable items are now visual and quick). This will make Gaia even easier to beginners. For advanced options (other node properties beyond id, src, title) we can either have a datagrid that only show when a page is selected (hey, this is visual, quick, easy and safe as we don’t need to remember the node’s properties) or ignore these and let developers change the site.xml file whenever they need. For temporary removing a page, we can uncheck the box that goes before each page (equivalent to commented out in site.xml ?)
4. Enable template for pages : There are many case that we have several pages with just the same or mostly the same (gallery, video for example), just different data. What if we can define template pages and then specify the template for each page created in site.xml ? This will minimize the efforts for creating multiple deeplink pages with the same structure, the only different is the asset data. If we agree on implementing the tree based pages creation above, we can add visual template binding to pages, too. <do i need to insert a suggested layout for this one here ?>. This also allow us to write simple site editor based on template pages. All we need to do is open site.xml and add more pages based on the existed templates, no rebuild needed to adding / removing pages that are based on the template !
5. Enable option to switch transition style of a page between timeline / code : There are times when you need to do page animation by code (dynamic data, liquid size …) together with some kind of an intro page, so you will need to create pages using actionscript template except one or some pages, how can we do then ? We need to manually copy the frames in the template .fla files and paste ? Any better way?
6. One more Build button : When we modify a page, most of the time we only need to build it then open main.swf, this works faster for big projects, especially for projects with many pages, so how about allow us to select the pages to rebuild for faster project test ? The idea is we will now have 2 build buttons, a big one for complete project rebuild and a smaller one to build only selected pages?
7. Better layer settings : Gaia currently only allow one page to appear a time, what if we need some overlay content ? We mostly will need to implement it in the nav page with will available for all children pages. What if we need some background content ? We mostly will need to put it in to the index page. Why don’t let us specify layers in site.xml ? and then for each layer, there are only one <content> to be shown at a time ? That means we can easily have multiple overlay contents, for a common setup we will have 3 layers : <background><content><navigation>

1. There are no shift-delete and i can’t find a way to delete a file without move it to trash first, it takes time and not efficient.
2. You can not show desktop (windows+D) without installing a utility (use F11 for quick windows hide)
3. You can not use function keys for functions, just you it for the brightness / volume adjust … you will need to install a utility then (try function flip).
4. You can force move files around by cmd+drag just like shift+drag/drop on windows
5. You can force copy files by alt+drag just like ctrl+drag/drop on windows
6. There are no end/home/pageUp/pageDown keys, use cmd+arrows instead
7. The delete button actually is backspace, there are no pc-like delete button
8. The mouse has only 1 button, want right click ? tap with two fingers
9. Replace cmd for pc’s ctrl : cmd+c for copy, cmd+v for paste, cmd+x for cut (editor only, won’t work on Finder), cmd+z for undo
10. Delete a file / folder : cmd+delete, just press delete won’t have any effect (why?)
11. Need to scroll down / up a file ? hold 2 fingers on the mouse pad and move at the same time – just works exactly like your mouse wheel.
12. Want to unzip a file ? double click onto it, the file will be extract to a folder. Want to view the content of the zip without extract ? you can’t do it without install a small utility. Want to zip a folder or a file ? right click, choose archive, a new archive.zip file will be created, you can change the name after that.
13. You can read an NTFS drive from Mac but can not write to it, use some utility to enable write (with slow speed to be cared about)
14. Disable creation of .DS_STORE and other .CLEAN_FILES files (only for network volumes): open terminal and type the following defaults write com.apple.desktopservices DSDontWriteNetworkStores true or use Tinker tool, any suggestion for completely remove .FILES for shared volumes between Mac + PC ? BlueHarvest ?

to be continued …

Lần em buồn khi công việc không như ý, anh đến công ty em chỉ để gửi lá thư, có một dòng: “Can đảm lên, người yêu! Anh luôn bên em!”.

Anh còn nhớ, với gương mặt hỉ hả anh xách về cho em một túi cà chua và không ngừng kể công: “Cà chua sạch đấy!”. Quên sao được cảnh thi thoảng anh thức dậy kê lại cái gối chân cho vợ đang có bầu khỏi mỏi. Anh còn đảm đang dậy sớm nấu ăn sáng, để vợ ngủ thêm chút nữa, vì thương vợ khó ngủ.

Anh còn nhớ lần em buột miệng than khi trời đã tối khuya, rằng xe máy phanh hơi sâu và vào số hơi nặng? Anh không quản ngại, lôi đồ nghề ra chỉnh lại luôn, bởi sáng hôm sau phải đi làm sớm nhỡ không kịp.

Từng hành động quan tâm nhỏ cùng những tháng ngày hạnh phúc ấy, chẳng khi nào em quên. Còn anh?

Ngày công ty khủng hoảng, hết việc, hơn tháng ròng đồng cam cộng khổ, chia ngọt sẻ bùi ấy, vợ chồng mình đã cùng sợ cho cảnh đứa con sắp chào đời bị nhếch nhác, thương cho tương lai mờ mịt, nhưng nước mắt đã được em lau khô mỗi buổi sáng và em cũng biết nỗi trăn trở mỗi đêm đã được anh giấu vào lòng. Anh lại ôm em thủ thỉ: “Cố gắng nào, chắc chắn gia đình mình sẽ mãi hạnh phúc”.

Vì không muốn để ba mẹ phải lo lắng nên mình giấu việc anh thất nghiệp, vậy là cuộc sống vốn bí bách lại càng thêm cùng quẫn khi vừa lo ăn từng bữa, vừa phải dành dụm rồi nói khó khi cứ bị ba mẹ giục giã mau trả nợ cô út để sắp tới cô xây nhà. Món nợ từ thời anh đi học văn bằng 2 đó treo lơ lửng trên đầu hai đứa.

Qua những ngày nín thở lo lắng, hồi hộp, bắt đầu đi làm, anh mừng rỡ báo tin về cho gia đình khiến họ càng thêm hãnh diện về anh. Nhưng anh lại “quên” không khai số lương thử việc ít ỏi anh được nhận trong hai tháng, khiến mẹ tưởng con trai mình tài hoa hơn người, kiếm bộn tiền lắm. Trong khi em vẫn phải đau đầu lo chi tiêu cho gia đình thì cạnh đó mẹ vẫn trách móc, con dâu chẳng biết điều, khiến em khổ tâm muốn khóc. Thôi thì đã có lời anh an ủi: “Anh hiểu em là đủ”, dĩ nhiên rồi, nếu không có người chồng tâm lý, yêu thương vợ hết mực ở bên, làm sao em vượt qua được bao sóng gió.

Anh còn nhớ từng nói với em, sẽ không bao giờ để vợ con phải khổ, sau này con sẽ tự hào vì có người cha như anh. Em sẽ không phải hối hận vì đã quyết tâm lấy anh, chịu đựng cuộc sống ban đầu thiếu thốn.

Và những vất vả dần được tháo gỡ, anh đã sáng suốt khi đi theo một minh quân, sếp anh là người xuất chúng, có tầm nhìn xa trông rộng, những kế hoạch của ông từ to đến bé đều ít nhiều thành công. Vậy là những “công thần” bên ông cũng được đãi ngộ xứng đáng. Công sức của anh đã được nhìn nhận và coi trọng. Sự nghiệp đã khiến anh đạt được những gì mình mong muốn, giúp đỡ gia đình, anh em hai bên, rồi đến “một người làm quan, cả họ được nhờ”.

Song các cuốn sách luyện lý trí, rèn nghị lực, gương danh nhân… giờ có còn chút nào đọng lại trong suy nghĩ của anh? Anh còn nhớ ngày anh miệt mài đọc chúng, tâm đắc đến nỗi còn dành thời gian đánh máy thành ebook để gửi lên thư viện, anh còn nhớ đã từng nói: “Chúng sẽ là cẩm nang để anh vượt qua những cám dỗ tầm thường, tránh đi theo vết xe đổ của những kẻ lắm tiền đi ruồng rẫy vợ con”.

Những điều đó có lẽ anh đã quên cả rồi, thì cô ấy mới có thể xen vào cuộc sống hạnh phúc của vợ chồng mình như thế!

Link bài viết gốc :