Debug.moduleEnabled(ModuleType.VIEW);

Debug.runstack.run( OperationType.LOGIN );

Debug.runstack.complete( OperationType.LOGIN );

while (bytes.bytesavailable) { bytesObj.writeByte(bytes.readByte()); }

trace('sync call');

setTimeout( function():void { trace('async call');} , 1000 );

throw new Error('Something happened error');

package debug

{

        import flash.utils.Dictionary;

 

        public class ModulesGuide

        {

                public static function module(point:int, processing:Boolean):void

                {

                        if (processing) { 

 

                                if ( hasFalse( point) )        {

                                        _statusMask |= point;

                                } else {

                                        // duplication enabled

                                }

 

                        } else {

 

                                if ( hasTrue( point ) ) {

                                        _statusMask ^= point;

                                } else {

                                        // duplication disabled

                                }

                        }

                }

 

                public static function getModuleLive(status:Boolean = true):Vector.<String>

                {

 

                        var links:Dictionary = route.getLinks();

 

                        var res:Vector.<String> = new Vector.<String>;

 

                        var checker:Function;

 

                        switch (status) {

                                case true:

                                        checker = hasTrue;

                                        break;

 

                                case false:

                                        checker = hasFalse;

                                        break;

                        }

 

                        for ( var key:String in links) {

 

                                if ( checker( links[key] ) ) res.push( key );

                        }

 

                        return res;

                }

 

                public static function bind(type:String):void {

                        route.bind( type );

                }

 

                public static function keyOfType(type:String):int {

                        return route.typeConvertor( type );

                }

 

                private static var _statusMask:int = 0x0;

                private static var _route:ModuleLinkages;

 

                private static function hasTrue( key: int ):* {

                        return _statusMask & key;

                }

 

                private static function hasFalse( key: int ):* {

                        return hasTrue(key) ^ key;

                }

 

                private static function get route():ModuleLinkages {

 

                        if (!_route) _route = new ModuleLinkages();

                        return _route;

                }

        }

 

}

 

import flash.utils.Dictionary;

internal class ModuleLinkages {

 

        public function ModuleLinkages() {

 

                step         = 0;

                register= 0x1;

                range        = 0x10;

 

                claster = new <int>

                        [        0x1,

                                0x2,

                                0x4,

                                0x8

                        ];

 

                linkages = new Dictionary();

        }

 

        public function getLinks():Dictionary {

                return linkages;

        }

 

        public function bind(humanIdKey:String):void {

 

                if (linkages.hasOwnProperty(humanIdKey)) {

                        throw new ArgumentError('Already reservation Key :: '+humanIdKey);

                        return;

                }

 

                linkages[humanIdKey] = newKey;

        }

 

        public function typeConvertor(type:String):int

        {

                if (linkages.hasOwnProperty( type ) ) {

                        return linkages[type];

                }

 

                return 0;

        }

 

        private function get newKey():int{

 

                var key:int = register*claster[step++];

 

                if (step == claster.length) {

                        step = 0;

                        register *= range;

                }

 

                return key;

        }

 

        private var linkages:Dictionary;        

 

        private var step:int;

        private var register:int;

        private var range:int;

        private var claster:Vector.<int>;

}

package

{

        import flash.utils.getTimer;

 

        import debug.ModulesGuide;

 

        public class Debug

        {

                private static var history:Vector.<String> = new Vector.<String>;

 

                public static function lazyStartLifecycle( type:String ):void {

                        module(type,true,true); 

                }

 

                public static function lazyStopLifecycle( type:String ):void {

                        module(type,false); 

                }

 

                public static function reservationTypes( type:String ):void {

                        ModulesGuide.bind( type );        

                }

 

                public static function module( type:String, completeLabel:Boolean, autobind:Boolean = false ):void {

 

                        if (autobind) reservationTypes( type );

 

                        var key:int = ModulesGuide.keyOfType(type);

                        logger("Module[ "+type+" ] <"+key+"> :: "+ completeLabel);

 

                        if (key) {        

                                ModulesGuide.module

                                (        key, 

                                        completeLabel

                                );

                        } else {

                                logger("Unregistered key[ "+type+" ]");

                        }

                }

 

                public static function getLifecycleLive():Array{

 

                        return rebuilder( 

                                ModulesGuide.getModuleLive() 

                        );

                }

 

                public static function getLifecycleDead():Array{

 

                        return rebuilder(        

                                ModulesGuide.getModuleLive(false) 

                        );

                }

 

                public static function getLifecycleLiveString():String{

 

                        return rebuilder(

                                Debug.getLifecycleLive()

                        ).join("\n");

                }

 

                public static function getLifecycleDeadString():String{

 

                        return rebuilder(

                                Debug.getLifecycleDead()

                        ).join("\n");

                }

 

                public static function getHistory():String{

                        return history.join("\n");

                }

 

                public static function logger( msg:String ):void {

 

                        var msec:Number = getTimer();

                        var sec:Number = Math.floor(.001*msec);        

                                msec -= (sec*1000);

 

                        var timeFormat:String = String(sec)+'.'+String(msec);

                        var delim:String = " :: ";

 

                        history.push( timeFormat + delim + msg );

                }

 

                private static function rebuilder(obj:*):Array {

                        var res:Array = new Array();

 

                        for each(var data:* in obj) {

                                res.push(data);

                        }

                        return res;

                }

        }

}

package

{

        import flash.display.Sprite;

 

        public class SomeApp extends Sprite

        {

                public function SomeApp()

                {

                        Debug.module('module1',true,true); // начало работы модуля1 

                        Debug.module('module1',false);       // конец работы модуля1 

                        Debug.module('module2',false,true);// конец работы модуля2 

                        Debug.module('module3',true,true); // начало работы модуля3

 

                        trace( Debug.getLifecycleLiveString() );

                        trace( Debug.getLifecycleDeadString() );

                }

        }

}

public function SomeApp2()

{

        Debug.reservationTypes( TYPE.SOMETYPE_1 );

        Debug.reservationTypes( TYPE.SOMETYPE_2 );

        Debug.reservationTypes( TYPE.SOMETYPE_3 );

 

        Debug.module( TYPE.SOMETYPE_1, true ); 

        Debug.module( TYPE.SOMETYPE_1, false);

        Debug.module( TYPE.SOMETYPE_2, false);

        Debug.module( TYPE.SOMETYPE_3, true);

 

        trace( Debug.getLifecycleLiveString() );

}

Debug.lazyStartLifecycle( 'SOMETYPE_1' );

Debug.lazyStopLifecycle( 'SOMETYPE_1' );

Debug.getHistory()

Debug.lazyStartLifecycle( 'имя_метки1' );

Debug.lazyStopLifecycle( 'имя_метки1' );