/// <inheritdoc cref="NtCore.SetLogger"/>
public void SetLogger(LogFunc func, LogLevel minLevel)
{
Logger logger = Logger.Instance;
logger.SetLogger(func);
logger.MinLevel = minLevel;
}
private static void DoCommand_NoTrans(LogFunc log, string connectionString, string sql, Action <SqlCommand> postAction, params object[] parameters)
{
try
{
using var connection = new SqlConnection(connectionString);
sql = ReplaceQuestionMark(sql);
using var cmd = new SqlCommand(sql, connection);
connection.Open();
try
{
AddParams_ReplaceQuestionMark(cmd, parameters);
postAction?.Invoke(cmd);
}
catch (Exception ex)
{
log?.Invoke(ex, $"-@@ connectionString: '{connectionString}', sql: '{sql}' @@");
throw ex;
}
}
catch (Exception ex)
{
log?.Invoke(ex, $"@@ connectionString: '{connectionString}', sql: '{sql}' @@");
throw ex;
}
}
public DBHelper(string connectionString, LogFunc log = null) : base(connectionString, log)
{
_AppLogTable = new AppLogTable(connectionString, log);
_CompanyTable = new CompanyTable(connectionString, log);
_MaterialTable = new MaterialTable(connectionString, log);
_ReceiptTable = new ReceiptTable(connectionString, log);
_RecordTable = new RecordTable(connectionString, log);
}
public static uint SetLogHandler(IntPtr logDomain, LogLevelFlags flags, LogFunc logFunc)
{
uint result = g_log_set_handler(logDomain, flags, LogFuncTrampoline, logFunc);
EnsureHash();
handlers[result] = logFunc;
return(result);
}
/// <summary>
/// Sets the logger to be used when an error is encountered by NetworkTables
/// </summary>
/// <param name="func">The function to use to log</param>
/// <param name="minLevel">The minimum level required to log</param>
public static void SetLogger(LogFunc func, LogLevel minLevel)
{
#if CORE
CoreMethods.SetLogger(func, minLevel);
#else
Logger logger = Logger.Instance;
logger.SetLogger(func);
logger.MinLevel = minLevel;
#endif
}
public static uint SetLogHandler (string logDomain, LogLevelFlags flags, LogFunc logFunc)
{
IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain);
uint result = g_log_set_handler (ndom, flags, logFunc, IntPtr.Zero);
Marshaller.Free (ndom);
EnsureHash ();
handlers [result] = logFunc;
return result;
}
public static uint SetLogHandler(string logDomain, LogLevelFlags flags, LogFunc logFunc)
{
IntPtr ndom = Marshaller.StringToPtrGStrdup(logDomain);
uint result = g_log_set_handler(ndom, flags, LogFuncTrampoline, logFunc);
Marshaller.Free(ndom);
EnsureHash();
handlers [result] = logFunc;
return(result);
}
/// <summary>
/// Assigns a method to be called whenever a log statement occurs in the internal
/// network table library.
/// </summary>
/// <param name="func">The log function to assign.</param>
/// <param name="minLevel">The minimum level to log.</param>
public static void SetLogger(LogFunc func, LogLevel minLevel)
{
s_nativeLog = (level, file, line, msg) =>
{
string message = ReadUTF8String(msg);
string fileName = ReadUTF8String(file);
func((LogLevel)level, fileName, (int)line, message);
};
Interop.NT_SetLogger(s_nativeLog, (uint)minLevel);
}
public static ValueTuple <UnmanagedLogFunc, IntPtr> CreateDelegate(LogFunc func, bool isAsync = false)
{
var data = new UnmanagedLogFuncFuncData {
IsAsync = isAsync,
Func = func,
UnmanagedFunc = UnmanagedFunc,
UnmanagedNotify = null,
};
var gcHandle = GCHandle.Alloc(data);
return(data.UnmanagedFunc, (IntPtr)gcHandle);
}
public static uint SetHandler(string logDomain, LogLevelFlags logLevels, LogFunc logFunc)
{
if (logFunc == null)
{
throw new ArgumentNullException(nameof(logFunc));
}
var logDomain_ = GMarshal.StringToUtf8Ptr(logDomain);
var(logFunc_, destroy_, userData_) = UnmanagedLogFuncFactory.CreateNotifyDelegate(logFunc);
var ret = g_log_set_handler_full(logDomain_, logLevels, logFunc_, userData_, destroy_);
GMarshal.Free(logDomain_);
return(ret);
}
static void NativeCallback(IntPtr log_domain_native, LogLevelFlags flags, IntPtr message_native, IntPtr user_data)
{
if (user_data == IntPtr.Zero)
{
return;
}
string log_domain = Marshaller.Utf8PtrToString(log_domain_native);
string message = Marshaller.Utf8PtrToString(message_native);
GCHandle gch = (GCHandle)user_data;
LogFunc func = gch.Target as LogFunc;
if (func != null)
{
func(log_domain, flags, message);
}
}
public static uint SetLogHandler(string logDomain, LogLevelFlags flags, LogFunc logFunc)
{
if (native_handler == null)
{
native_handler = new LogFuncNative(NativeCallback);
}
IntPtr ndom = Marshaller.StringToPtrGStrdup(logDomain);
GCHandle gch = GCHandle.Alloc(logFunc);
uint result = g_log_set_handler(ndom, flags, native_handler, (IntPtr)gch);
Marshaller.Free(ndom);
EnsureHash();
handlers [result] = gch;
return(result);
}
/// <summary>
/// Installs a default log handler which is used if no log handler
/// has been set for the particular log domain and log level combination.
/// </summary>
/// <param name="logFunc">the log handler function</param>
/// <returns>the previous default log handler</returns>
public static LogFunc SetDefaultHandler(LogFunc logFunc)
{
if (_nativeHandler == null)
{
_nativeHandler = NativeCallback;
}
var prev = GLib.GLogSetDefaultHandler(_nativeHandler, (IntPtr)GCHandle.Alloc(logFunc));
if (prev == null)
{
return(null);
}
var invoker = new Invoker(prev);
return(invoker.Handler);
}
public static LogFunc SetDefaultHandler(LogFunc log_func)
{
if (native_handler == null)
{
native_handler = new LogFuncNative(NativeCallback);
}
LogFuncNative prev = g_log_set_default_handler(native_handler, (IntPtr)GCHandle.Alloc(log_func));
if (prev == null)
{
return(null);
}
Invoker invoker = new Invoker(prev);
return(invoker.Handler);
}
/// <summary>
/// Adds a line to a text box, and treats it like a log.
/// Should be thread safe.
/// </summary>
/// <param name="msg"></param>
private void AddLogLine(TextBox box, string msg)
{
if (box.InvokeRequired)
{
object[] args = new object[1];
args[0] = msg;
LogFunc target = new LogFunc(AddLogLine);
box.BeginInvoke(target, args);
return;
}
List <String> lines = new List <string>(box.Lines);
if (lines.Count > 2000)
{
int nremove = lines.Count - 2000;
lines.RemoveRange(0, nremove);
}
lines.Add(msg);
box.Lines = lines.ToArray();
}
private static bool TryConvertValue <T>(LogFunc log, object obj, out T outValue, T defaultValue = default(T))
{
try
{
if (obj == DBNull.Value)
{
obj = null;
}
outValue = (T)Convert.ChangeType(obj, typeof(T));
return(true);
}
catch (Exception ex)
{
log?.Invoke(ex, $"@type: '{typeof(T)}', obj: '{obj}'@");
outValue = defaultValue;
return(false);
}
}
private static T?ConvertToNull <T>(LogFunc log, object obj) where T : struct
{
try
{
if (obj == DBNull.Value)
{
obj = null;
}
if (obj == null)
{
return(null);
}
return((T)Convert.ChangeType(obj, typeof(T)));
}
catch (Exception ex)
{
log?.Invoke(ex, $"@type: '{typeof(T)}', obj: '{obj}'@");
return(null);
}
}
public static void SetDefaultHandler(LogFunc logFunc)
{
if (logFunc == null)
{
throw new ArgumentNullException(nameof(logFunc));
}
var oldHandler = defaultHandler;
if (logFunc == DefaultHandler)
{
g_log_set_default_handler(g_log_default_handler, IntPtr.Zero);
defaultHandler = default(GCHandle);
}
else
{
var(logFunc_, userData_) = UnmanagedLogFuncFactory.CreateDelegate(logFunc);
g_log_set_default_handler(logFunc_, userData_);
defaultHandler = (GCHandle)userData_;
}
if (oldHandler.IsAllocated)
{
oldHandler.Free();
}
}
public void SetDefaultLogger()
{
m_func = DefLogFunc;
}
public void SetLogger(LogFunc func)
{
m_func = func;
}
public static extern void LogCallback(LogFunc func);
static extern uint g_log_set_default_handler(
LogFunc log_func,
IntPtr user_data);
public static LogFunc SetDefaultHandler (LogFunc log_func)
{
if (native_handler == null)
native_handler = new LogFuncNative (NativeCallback);
LogFuncNative prev = g_log_set_default_handler (native_handler, (IntPtr) GCHandle.Alloc (log_func));
if (prev == null)
return null;
Invoker invoker = new Invoker (prev);
return invoker.Handler;
}
public static extern void SetLoger(LogFunc logFunc);
protected SqlHelper(string connectionString, LogFunc log = null)
{
_ConnectionString = connectionString;
_Log = log;
}
public MaterialTable(string connectionString, LogFunc log = null) : base(connectionString, log)
{
}
private static extern void SetLogFunc(LogFunc f);
public static uint SetLogHandler (string logDomain, LogLevelFlags flags, LogFunc logFunc)
{
if (native_handler == null)
native_handler = new LogFuncNative (NativeCallback);
IntPtr ndom = Marshaller.StringToPtrGStrdup (logDomain);
GCHandle gch = GCHandle.Alloc (logFunc);
uint result = g_log_set_handler (ndom, flags, native_handler, (IntPtr) gch);
Marshaller.Free (ndom);
EnsureHash ();
handlers [result] = gch;
return result;
}
static extern uint g_log_set_handler(IntPtr log_domain, LogLevelFlags flags, LogFunc2 log_func, LogFunc user_data);
public void SetLoggerFunc(LogFunc logFunc)
{
log = logFunc;
}
public static ValueTuple <UnmanagedLogFunc, UnmanagedDestroyNotify, IntPtr> CreateNotifyDelegate(LogFunc func)
{
var data = new UnmanagedLogFuncFuncData {
IsAsync = false,
Func = func,
UnmanagedFunc = UnmanagedFunc,
UnmanagedNotify = UnmanagedNotify,
};
var gcHandle = GCHandle.Alloc(data);
return(data.UnmanagedFunc, data.UnmanagedNotify, (IntPtr)gcHandle);
}
public RecordTable(string connectionString, LogFunc log = null) : base(connectionString, log)
{
}
/// <summary>
/// Sets the log handler for a domain and a set of log levels.
/// </summary>
/// <param name="logDomain">the log domain, or <see langword="null" /> for the default "" application domain</param>
/// <param name="flags">the log levels to apply the log handler for</param>
/// <param name="logFunc">the log handler function</param>
/// <returns>the id of the handler</returns>
public static uint SetLogHandler(string logDomain, Enums.LogLevelFlags flags, LogFunc logFunc)
{
if (_nativeHandler == null)
{
_nativeHandler = NativeCallback;
}
var gch = GCHandle.Alloc(logFunc);
var result = GLib.GLogSetHandler(logDomain, flags, _nativeHandler, (IntPtr)gch);
_handlers.AddOrUpdate(result, gch, (k, v) => gch);
return(result);
}
static extern uint g_log_set_handler(IntPtr log_domain, LogLevelFlags flags, LogFunc log_func, IntPtr user_data);
public CompanyTable(string connectionString, LogFunc log = null) : base(connectionString, log)
{
}