InfernalGames/haxework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[log] update

Browse Source
This commit is contained in:
shmyga
2018-03-19 17:38:43 +03:00
parent 086518ae42
commit 4487aedee7
7 changed files with 153 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
haxelib.json
View File

@@ -4,7 +4,7 @@
"license": "BSD", "license": "BSD",
"tags": ["flash", "openfl"], "tags": ["flash", "openfl"],
"description": "Framework.", "description": "Framework.",
"version": "0.8.0", "version": "0.8.1",
"releasenote": "Update.", "releasenote": "Update.",
"contributors": ["shmyga"], "contributors": ["shmyga"],
"classPath": "src/main", "classPath": "src/main",

84
src/main/haxework/log/BaseLogger.hx
View File

@@ -1,54 +1,58 @@
package haxework.log; package haxework.log;
#if flash
import flash.events.ErrorEvent;
import flash.errors.Error;
#end
import haxework.log.ILogger.LogLevel; import haxework.log.ILogger.LogLevel;
import haxe.CallStack;
class LoggerUtil {
public static function printPos(pos:haxe.PosInfos):String {
return '${pos.fileName}:${pos.lineNumber}:';
}
public static function printStackItem(item:StackItem):String {
return switch item {
case StackItem.CFunction: 'CFunction';
case StackItem.Module(m): m;
case StackItem.FilePos(s, file, line): '${file}:${line}';
case StackItem.Method(classname, method): '${classname}::${method}}';
case StackItem.LocalFunction(v): 'LocalFunction(${v})';
}
}
public static function printError(error:Dynamic):String {
return error == null ? '' : Std.string('${error}\n\t${CallStack.exceptionStack().map(printStackItem).join('\n\t')}');
}
}
class BaseLogger implements ILogger { class BaseLogger implements ILogger {
public function new() {} public function new() {}
public function log(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void { public function log(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
write(buildString(level, tag, message, error), p); write(buildString(level, tag, message, error, p));
}
private function buildString(level:LogLevel, tag:String, message:String, ?error:Dynamic):String {
return "[" + level + "] " + tag + " - " + message + (error == null ? "" : " {" + error2strign(error) + "}");
}
public static function error2strign(error:Dynamic):String {
#if flash
return if (Std.is(error, Error)) {
var stack:String = error.getStackTrace();
stack == null ? Std.string(error) : stack;
} else if (Std.is(error, ErrorEvent)) {
var event:ErrorEvent = cast(error, ErrorEvent);
event.type + " - " + event.text;
} else {
Std.string(error);
} }
#else
return Std.string(error);
#end
}
private function write(text:String, ?p:haxe.PosInfos):Void {} private function buildString(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):String {
return '${Date.now()} | ${LoggerUtil.printPos(p)} [${level}] ${tag} - ${message}${LoggerUtil.printError(error)}';
}
public function d(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void { private function write(text:String):Void {}
log(LogLevel.DEBUG, tag, message, error, p);
}
public function i(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void { public function d(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.INFO, tag, message, error, p); log(LogLevel.DEBUG, tag, message, error, p);
} }
public function w(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void { public function i(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.WARNING, tag, message, error, p); log(LogLevel.INFO, tag, message, error, p);
} }
public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void { public function w(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.ERROR, tag, message, error, p); log(LogLevel.WARNING, tag, message, error, p);
} }
public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.ERROR, tag, message, error, p);
}
} }

33
src/main/haxework/log/JSLogger.hx
View File

@@ -4,27 +4,26 @@ import haxework.log.ILogger.LogLevel;
import flash.external.ExternalInterface; import flash.external.ExternalInterface;
import haxework.log.BaseLogger; import haxework.log.BaseLogger;
class JSLogger extends BaseLogger { class JSLogger extends BaseLogger {
private var available:Bool; private var available:Bool;
public function new() { public function new() {
super(); super();
available = ExternalInterface.available; available = ExternalInterface.available;
}
override public function e(tag:String, message:String, error:Dynamic = null, p:haxe.PosInfos = null):Void {
if (available) {
var text:String = buildString(LogLevel.ERROR, tag, message, error);
var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
try {ExternalInterface.call("console.error", s);} catch (error:Dynamic) {available = false;}
} }
}
override private function write(text:String, ?p:haxe.PosInfos):Void { override public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
if (available) { if (available) {
var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n"; var text:String = buildString(LogLevel.ERROR, tag, message, error);
try {ExternalInterface.call("console.log", s);} catch (error:Dynamic) {available = false;} try {ExternalInterface.call("console.error", text);} catch (error:Dynamic) {available = false;}
}
}
override private function write(text:String):Void {
if (available) {
try {ExternalInterface.call("console.log", text);} catch (error:Dynamic) {available = false;}
}
} }
}
} }

58
src/main/haxework/log/SocketLogger.hx
View File

@@ -15,45 +15,47 @@ import sys.net.Host;
import sys.net.Socket; import sys.net.Socket;
#end #end
class SocketLogger extends BaseLogger { class SocketLogger extends BaseLogger {
private var socket:Socket; private var socket:Socket;
public function new() { public function new() {
super(); super();
socket = new Socket(); socket = new Socket();
#if flash #if flash
socket.addEventListener(IOErrorEvent.IO_ERROR, function(error):Void { socket.addEventListener(IOErrorEvent.IO_ERROR, function(error):Void {
onError(error); onError(error);
}); });
socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function(error):Void { socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function(error):Void {
onError(error); onError(error);
}); });
socket.connect(CompilationOption.get("debug.address"), Std.parseInt(CompilationOption.get("debug.port"))); socket.connect(CompilationOption.get("debug.address"), Std.parseInt(CompilationOption.get("debug.port")));
#else #else
try { try {
socket.connect(new Host(CompilationOption.get("debug.address")), Std.parseInt(CompilationOption.get("debug.port"))); socket.connect(new Host(CompilationOption.get("debug.address")), Std.parseInt(CompilationOption.get("debug.port")));
} catch (error: Dynamic) { } catch (error: Dynamic) {
onError(error); onError(error);
} }
#end #end
} }
private function onError(error:Dynamic):Void { private function onError(error:Dynamic):Void {
//trace("SocketLogger", "", error); //trace("SocketLogger", "", error);
} }
override private function write(text:String, ?p:haxe.PosInfos):Void { override private function write(text:String):Void {
try { try {
var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n"; #if flash
#if flash socket.writeUTFBytes(text);
socket.writeUTFBytes(s); socket.writeUTFBytes('\n');
socket.flush(); socket.flush();
#else #else
socket.write(s); socket.write(text);
#end socket.write('\n');
} catch (error:Dynamic) {} #end
} } catch (error:Dynamic) {}
}
} }
#end #end

17
src/main/haxework/log/TextFieldLogger.hx
View File

@@ -2,16 +2,17 @@ package haxework.log;
import flash.text.TextField; import flash.text.TextField;
class TextFieldLogger extends BaseLogger { class TextFieldLogger extends BaseLogger {
private var textField:TextField; private var textField:TextField;
public function new(textField:TextField) { public function new(textField:TextField) {
super(); super();
this.textField = textField; this.textField = textField;
} }
override private function write(text:String, ?p:haxe.PosInfos):Void { override private function write(text:String):Void {
this.textField.text += ("\n" + text); this.textField.text += ("\n" + text);
} }
} }

13
src/main/haxework/log/TraceLogger.hx
View File

@@ -1,14 +1,13 @@
package haxework.log; package haxework.log;
import haxework.log.ILogger.LogLevel;
class TraceLogger extends BaseLogger { class TraceLogger extends BaseLogger {
public function new() { public function new() {
super(); super();
} }
override private function write(text:String, ?p:haxe.PosInfos):Void { override private function write(text:String):Void {
haxe.Log.trace(text, p); haxe.Log.trace(text);
} }
} }

99
src/main/haxework/provider/Provider.hx
View File

@@ -1,61 +1,56 @@
package haxework.provider; package haxework.provider;
class Provider { class Provider {
private static function key<T>(i:Class<T>, ?type:Dynamic):String { private static function key<T>(i:Class<T>, ?type:Dynamic):String {
var result = Type.getClassName(i); var result = Type.getClassName(i);
if (type != null) result += ':${type}'; if (type != null) result += ':${Std.string(type)}';
return result; return result;
}
//private static var factories:Map<String, Class<Dynamic>> = new Map();
private static var factories:Map<String, Class<Dynamic>> = cast [
#if (!neko)
key(haxework.net.manage.LoaderManager) => haxework.net.manage.ILoaderManager
#end
];
private static var args:Map<String, Array<Dynamic>> = new Map();
private static var instances:Map<String, Dynamic> = new Map();
public static function setFactory<T>(i:Class<T>, clazz:Class<T>, ?type:Dynamic, ?args:Array<Dynamic>):Void {
var key = key(i, type);
factories.set(key, clazz);
if (args != null) Provider.args.set(key, args);
}
public static function set<T>(i:Class<T>, instance:T, ?type:Dynamic):Void {
var key = key(i, type);
instances.set(key, instance);
}
public static function get<T>(i:Class<T>, ?type:Dynamic):T {
var key = key(i, type);
if (instances.exists(key)) {
return instances.get(key);
} else if (factories.exists(key)) {
var instance:T = Type.createInstance(factories.get(key), args.exists(key) ? args.get(key) : []);
instances.set(key, instance);
return instance;
} else {
throw 'Factory for "${key}" not found';
} }
}
public static function build<T>(i:Class<T>, ?type:Dynamic):T { private static var factories:Map<String, Class<Dynamic>> = new Map();
var key = key(i, type); private static var args:Map<String, Array<Dynamic>> = new Map();
if (factories.exists(key)) { private static var instances:Map<String, Dynamic> = new Map();
var instance:T = Type.createInstance(factories.get(key), args.exists(key) ? args.get(key) : []);
return instance;
} else {
throw 'Factory for "${key}" not found';
}
}
public static function setProperty<T>(i:Class<T>, field:String, value:Dynamic, ?type:Dynamic):Void { public static function setFactory<T>(i:Class<T>, clazz:Class<T>, ?type:Dynamic, ?args:Array<Dynamic>):Void {
var o:Dynamic = get(i, type); var key = key(i, type);
if (o != null && Reflect.hasField(o, field)) { factories.set(key, clazz);
Reflect.setProperty(o, field, value); if (args != null) Provider.args.set(key, args);
}
public static function set<T>(i:Class<T>, instance:T, ?type:Dynamic):Void {
var key = key(i, type);
instances.set(key, instance);
}
public static function get<T>(i:Class<T>, ?type:Dynamic):T {
var key = key(i, type);
if (instances.exists(key)) {
return instances.get(key);
} else if (factories.exists(key)) {
var instance:T = Type.createInstance(factories.get(key), args.exists(key) ? args.get(key) : []);
instances.set(key, instance);
return instance;
} else {
throw 'Factory for "${key}" not found';
}
}
public static function build<T>(i:Class<T>, ?type:Dynamic):T {
var key = key(i, type);
if (factories.exists(key)) {
var instance:T = Type.createInstance(factories.get(key), args.exists(key) ? args.get(key) : []);
return instance;
} else {
throw 'Factory for "${key}" not found';
}
}
public static function setProperty<T>(i:Class<T>, field:String, value:Dynamic, ?type:Dynamic):Void {
var o:Dynamic = get(i, type);
if (o != null && Reflect.hasField(o, field)) {
Reflect.setProperty(o, field, value);
}
} }
}
} }