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

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

@@ -1,54 +1,58 @@
package haxework.log;
#if flash
import flash.events.ErrorEvent;
import flash.errors.Error;
#end
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 {
public function new() {}
public function new() {}
public function log(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
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);
public function log(level:LogLevel, tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
write(buildString(level, tag, message, error, p));
}
#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 {
log(LogLevel.DEBUG, tag, message, error, p);
}
private function write(text:String):Void {}
public function i(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.INFO, tag, message, error, p);
}
public function d(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.DEBUG, tag, message, error, p);
}
public function w(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.WARNING, tag, message, error, p);
}
public function i(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.INFO, tag, message, error, p);
}
public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
log(LogLevel.ERROR, tag, message, error, p);
}
public function w(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
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 haxework.log.BaseLogger;
class JSLogger extends BaseLogger {
private var available:Bool;
private var available:Bool;
public function new() {
super();
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;}
public function new() {
super();
available = ExternalInterface.available;
}
}
override private function write(text:String, ?p:haxe.PosInfos):Void {
if (available) {
var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
try {ExternalInterface.call("console.log", s);} catch (error:Dynamic) {available = false;}
override public function e(tag:String, message:String, ?error:Dynamic, ?p:haxe.PosInfos):Void {
if (available) {
var text:String = buildString(LogLevel.ERROR, tag, message, error);
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;
#end
class SocketLogger extends BaseLogger {
private var socket:Socket;
private var socket:Socket;
public function new() {
super();
socket = new Socket();
#if flash
socket.addEventListener(IOErrorEvent.IO_ERROR, function(error):Void {
onError(error);
});
socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function(error):Void {
onError(error);
});
socket.connect(CompilationOption.get("debug.address"), Std.parseInt(CompilationOption.get("debug.port")));
#else
public function new() {
super();
socket = new Socket();
#if flash
socket.addEventListener(IOErrorEvent.IO_ERROR, function(error):Void {
onError(error);
});
socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function(error):Void {
onError(error);
});
socket.connect(CompilationOption.get("debug.address"), Std.parseInt(CompilationOption.get("debug.port")));
#else
try {
socket.connect(new Host(CompilationOption.get("debug.address")), Std.parseInt(CompilationOption.get("debug.port")));
} catch (error: Dynamic) {
onError(error);
}
#end
}
}
private function onError(error:Dynamic):Void {
//trace("SocketLogger", "", error);
}
private function onError(error:Dynamic):Void {
//trace("SocketLogger", "", error);
}
override private function write(text:String, ?p:haxe.PosInfos):Void {
try {
var s:String = p.fileName + ":" + p.lineNumber + ": " + text + "\n";
#if flash
socket.writeUTFBytes(s);
socket.flush();
#else
socket.write(s);
#end
} catch (error:Dynamic) {}
}
override private function write(text:String):Void {
try {
#if flash
socket.writeUTFBytes(text);
socket.writeUTFBytes('\n');
socket.flush();
#else
socket.write(text);
socket.write('\n');
#end
} catch (error:Dynamic) {}
}
}
#end

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

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

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

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

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

@@ -1,61 +1,56 @@
package haxework.provider;
class Provider {
private static function key<T>(i:Class<T>, ?type:Dynamic):String {
var result = Type.getClassName(i);
if (type != null) result += ':${type}';
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';
private static function key<T>(i:Class<T>, ?type:Dynamic):String {
var result = Type.getClassName(i);
if (type != null) result += ':${Std.string(type)}';
return result;
}
}
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';
}
}
private static var factories:Map<String, Class<Dynamic>> = new Map();
private static var args:Map<String, Array<Dynamic>> = new Map();
private static var instances:Map<String, Dynamic> = new Map();
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);
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 {
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);
}
}
}
}