internal static void StartSNMPMasterThread(LoggerDelegate loggerDelegate, ThreadStart threadStartAction)
{
DateTime nowTimestamp = DateTime.Now;
nowTimestamp = new DateTime(year: nowTimestamp.Year, month: nowTimestamp.Month, day: nowTimestamp.Day, hour: nowTimestamp.Hour, minute: 0, second: 0);
openLogStreamStamp = nowTimestamp.ToString("yyyy-MM-dd HH-mm");
eventLogsWriter = new StreamWriter(path: Path.Combine(EVT_LOGS_DIR, $"{openLogStreamStamp}.txt"), append: true);
bool writeTitle = !File.Exists(Path.Combine(SNMP_DATA_DIR, $"{openLogStreamStamp}.csv"));
snmpDataWriter = new StreamWriter(path: Path.Combine(SNMP_DATA_DIR, $"{openLogStreamStamp}.csv"), append: true);
if (writeTitle)
{
snmpDataWriter.WriteLine($"Time, IPAddress, LreLinkStatusA, LreLinkStatusB, LrePortAdminStateA, LrePortAdminStateB, LreCntTxA, LreCntTxB , LreCntTxC, LreCntRxA, LreCntRxB, LreCntRxC, LreCntErrorsA, LreCntErrorsB, LreCntErrorsC, LreCntOwnRxA, LreCntOwnRxB");
}
eventLogsWriter.AutoFlush = true;
snmpDataWriter.AutoFlush = true;
logDeleg = loggerDelegate;
if (masterThread == null || masterThread.ThreadState.HasFlag(ThreadState.Aborted))
{
masterThread = new Thread((thrStartAction) => RunMasterThreadLifecycleAsync(vis, (ThreadStart)thrStartAction));
masterThread.Name = "SNMP lifecycle (master) thread";
masterThread.IsBackground = true;
logDeleg(message: "Starting SNMP service");
masterThread.Start(threadStartAction);
}
}
public void SendHeartbeat(LoggerDelegate logger = null, object logContext = null)
{
if (!Connect(logger, logContext)) return;
try
{
Int32 intdatalen = Convert.ToInt32(0);
Int32 netdatalen = IPAddress.HostToNetworkOrder(intdatalen);
_socket.Send(BitConverter.GetBytes(netdatalen), sizeof(Int32), SocketFlags.None);
if (!_lastwritesuccess)
{
if (logger != null) logger(GraphdatLogType.SuccessMessage, logContext, "graphdat: sending data on socket '{0}'", _config);
_lastwritesuccess = true;
}
_lastwaserror = false;
if (Agent.Connect.VerboseLogging)
{
if (logger != null) logger(GraphdatLogType.InformationMessage, logContext, "graphdat info: socket sent heartbeat to '{0}'", _config);
}
}
catch (Exception ex)
{
Term(logger, logContext);
_lastwritesuccess = false;
if (logger != null) logger(GraphdatLogType.ErrorMessage, logContext, "graphdat error: could not write socket '{0}' - {1}",
_config, ex.Message);
}
}
/// <summary>
/// Socket读取
/// </summary>
/// <param name="socket">socket</param>
/// <param name="receiveCount">读取长度</param>
/// <param name="warningLog">日记委托记录</param>
/// <returns>读到的数据，如果内部出现异常则返回null</returns>
protected byte[] SocketTryRead(Socket socket, int receiveCount, LoggerDelegate warningLog = null)
{
byte[] receiveBytes = new byte[receiveCount];
int receiveFinish = 0;
while (receiveFinish < receiveCount)
{
// 分批读取
int receiveLength = (receiveCount - receiveFinish) >= BufferSize ? BufferSize : (receiveCount - receiveFinish);
try
{
var readLeng = socket.Receive(receiveBytes, receiveFinish, receiveLength, SocketFlags.None);
if (readLeng == 0)
{
return(null);
}
receiveFinish += readLeng;
}
catch (SocketException ex)
{
warningLog?.Invoke(ex.Message, ex);
return(null);
}
}
return(receiveBytes);
}
public void removeLogger(params ILogger[] logger)
{
foreach (ILogger log in logger)
{
this.allLogers -= log.LogMessage;
}
}
private CodebaseGenerator(CommandArgs appArgs, bool returnFullSources, LoggerDelegate logger)
{
_logger = logger;
_assemblyVersion = typeof(Program).Assembly.GetName().Version.ToString();
_returnFullSources = returnFullSources;
_genResults = new SolCodeGenResults();
// Normalize source directory
_solSourceDirectory = Path.GetFullPath(appArgs.SolSourceDirectory);
// If we were passed a single sol file rather than a source directory
if (_solSourceDirectory.EndsWith(".sol", StringComparison.OrdinalIgnoreCase) && File.Exists(_solSourceDirectory))
{
_solSourceSingleFile = _solSourceDirectory;
_solSourceDirectory = Path.GetDirectoryName(_solSourceDirectory);
}
// Match the solc file path output format which replaces Windows path separator characters with unix style.
if (Path.DirectorySeparatorChar == '\\')
{
_solSourceDirectory = _solSourceDirectory.Replace('\\', '/');
}
if (string.IsNullOrWhiteSpace(appArgs.OutputDirectory))
{
string sourceFilesParentDir = Directory.GetParent(_solSourceDirectory).FullName;
_generatedContractsDirectory = Path.Combine(sourceFilesParentDir, GeneratedContractsDefaultDirectory);
}
else
{
_generatedContractsDirectory = Path.GetFullPath(appArgs.OutputDirectory);
}
if (string.IsNullOrWhiteSpace(appArgs.AssemblyOutputDirectory))
{
string sourceFilesParentDir = Directory.GetParent(_solSourceDirectory).FullName;
_generatedAssemblyDirectory = Path.Combine(sourceFilesParentDir, GeneratedAssemblyDefaultDirectory);
}
else
{
_generatedAssemblyDirectory = Path.GetFullPath(appArgs.AssemblyOutputDirectory);
}
if (_solSourceSingleFile != null)
{
_solSourceDirectory = string.Empty;
}
if (!string.IsNullOrEmpty(appArgs.LegacySolcPath))
{
_legacySolcPath = Path.GetFullPath(appArgs.LegacySolcPath);
}
_namespace = appArgs.Namespace;
_solcVersion = appArgs.SolcVersion;
_solcOptimzer = appArgs.SolcOptimizer;
_solcLib = SetupSolcLib();
_solidityCompilerVersion = _solcLib.Version.ToString(3);
}
public SMUCommand(bool isDualSocket, LoggerDelegate logger)
{
mOls = new OlsImpl();
CheckOlsStatus();
mIsDualSocket = isDualSocket;
mLogger = logger;
}
public static void SetLoggerMethod(LoggerDelegate method)
{
LibFluidsynth.Misc.fluid_set_log_function((int)LogLevel.Panic, method, IntPtr.Zero);
LibFluidsynth.Misc.fluid_set_log_function((int)LogLevel.Error, method, IntPtr.Zero);
LibFluidsynth.Misc.fluid_set_log_function((int)LogLevel.Warning, method, IntPtr.Zero);
LibFluidsynth.Misc.fluid_set_log_function((int)LogLevel.Information, method, IntPtr.Zero);
LibFluidsynth.Misc.fluid_set_log_function((int)LogLevel.Debug, method, IntPtr.Zero);
}
public double EvaluateNumericExpression(LoggerDelegate logger, object o, string expr)
{
string exp = ExpandVariables(logger, o, true, expr == null ? "" : expr);
lock (mp)
{
return(mp.Parse(exp));
}
}
static void Main(string[] args) {
string vplmn = "";
int seq = 0;
bool td = false;
try {
if (args.Length == 1) { // * also possible
vplmn = args[0];
}
else if (args.Length == 2) {
vplmn = args[0].Substring(0, 5);
if (args[1].Equals("-t"))
td = true;
else
seq = Convert.ToInt32(args[1]);
}
else if (args.Length == 3) {
vplmn = args[0].Substring(0, 5);
seq = Convert.ToInt32(args[1]);
if (args[2].Equals("-t")) td = true;
}
else {
Console.WriteLine("USAGE: tapgen.exe <vplmn> [sequence_no] [-t]");
return;
}
}
catch {
Console.WriteLine("Invalid parameter(s)");
return;
}
hplmn = ConfigurationSettings.AppSettings["HPLMN"];
strCon = string.Format("application name=tapgen;persist security info=true;packet size=4096;data source={0};initial catalog=Roaming;user id={1};password={2};", ConfigurationSettings.AppSettings["DataServer"], ConfigurationSettings.AppSettings["DataUser"], ConfigurationSettings.AppSettings["DataPassword"]);
con = new SqlConnection(strCon);
delegateLogWriter = new LoggerDelegate(Dump);
logFolder = ConfigurationSettings.AppSettings["LogFolder"];
if (logFolder.EndsWith("\\")) logFolder = logFolder.Remove(logFolder.Length - 1, 1);
genFolder = ConfigurationSettings.AppSettings["GenFolder"];
if (genFolder.EndsWith("\\")) genFolder = genFolder.Substring(0, genFolder.Length - 1);
sqlTap = new SqlCommand(ConfigurationSettings.AppSettings["GenProc"]);
sqlTap.CommandType = CommandType.StoredProcedure;
sqlTap.Parameters.Add("@vplmn", SqlDbType.VarChar, 5);
sqlTap.Parameters.Add("@seq", SqlDbType.Int, 4);
sqlTap.Parameters.Add("@td", SqlDbType.Bit, 1);
sqlTap.Parameters.Add("@msg", SqlDbType.VarChar, 200);
sqlTap.Parameters.Add("@retcode", SqlDbType.Int, 4);
sqlTap.Parameters["@msg"].Direction = ParameterDirection.Output;
sqlTap.Parameters["@retcode"].Direction = ParameterDirection.ReturnValue;
sqlTap.CommandTimeout = 1000;
sqlTap.Connection = con;
string msg = Generate(vplmn, seq, td);
if (msg.Length > 0) Dump(msg);
}
private static void RunVoidDelegates()
{
LoggerDelegate consoleLoggerHandler = ConsoleLogger;
LoggerDelegate debugLoggerHandler = DebugLogger;
LoggerDelegate allConsoleHandlers = consoleLoggerHandler + debugLoggerHandler;
consoleLoggerHandler("This goes to the console");
debugLoggerHandler("This goes to the debug");
allConsoleHandlers("this goes to all");
}
/// <summary>
/// Socket读取
/// </summary>
/// <param name="socket">socket</param>
/// <param name="receiveCount">读取长度</param>
/// <param name="warningLog">日记委托记录</param>
/// <returns></returns>
protected byte[] SocketRead(Socket socket, int receiveCount, LoggerDelegate warningLog = null)
{
byte[] receiveBytes = SocketTryRead(socket, receiveCount, warningLog);
if (receiveBytes == null)
{
socket?.SafeClose();
throw new Exception("连接被断开");
}
return(receiveBytes);
}
/// <summary>
/// FUNCTION - Logger()
/// PURPOSE - Initialize private variables
/// PARAMTERS -
/// RETURN VALUE -
/// MODIFIED - 26/10/2012
/// </summary>
public Logger(string logfilepath, string filename, int logsize)
{
// Set Everything to Default values.
m_MaxSize = logsize;
m_Enabled = false;
m_LogFileName = filename;//DefaultLogFileName;
m_LoggerFilePath = logfilepath;//DefaultLogFilePath;
m_LogLevel = LogPriorityLevel.Functional;
OnLogMessage = null;
// modified to implement three instance
this.SetLogFilePath(m_LoggerFilePath);
this.StartLog(m_LogFileName, m_MaxSize, m_LogLevel);
}
public void Send(byte[] data, long datalen, LoggerDelegate logger = null, object logContext = null)
{
if (!Connect(logger, logContext)) return;
try
{
Int32 intdatalen = Convert.ToInt32(datalen);
Int32 netdatalen = IPAddress.HostToNetworkOrder(intdatalen);
_socket.Send(BitConverter.GetBytes(netdatalen), sizeof(Int32), SocketFlags.None);
var sent = _socket.Send(data, intdatalen, SocketFlags.None);
if (!_lastwritesuccess)
{
if(logger != null) logger(GraphdatLogType.SuccessMessage, logContext, "graphdat: sending data on socket '{0}'", _config);
_lastwritesuccess = true;
}
_lastwaserror = false;
if (Agent.Connect.VerboseLogging)
{
if (logger != null) logger(GraphdatLogType.InformationMessage, logContext, "graphdat info: socket sent {0} bytes to '{1}'", sent, _config);
}
}
catch (Exception ex)
{
Term(logger, logContext);
_lastwritesuccess = false;
string message;
if (ex is OverflowException)
{
message = "data too long";
}
else
{
message = ex.Message;
}
if (logger != null) logger(GraphdatLogType.ErrorMessage, logContext, "graphdat error: could not write socket '{0}' - {1}",
_config, message);
}
}
static void Main(string[] args)
{
try
{
LoggerDelegate logger = null;
logger = LogToScreen;
logger += LogFancy;
logger += LogToFile;
// these two lines are equivalent
logger?.Invoke("Something happened"); // nullable expression
if (logger != null)
{
logger("Something happened"); // if null
}
}
finally
{
Console.WriteLine("Press any key to finish");
Console.ReadKey();
}
}
private bool Connect(LoggerDelegate logger, object logContext)
{
if (_socket != null)
return true;
try
{
// new socket
_socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
// connect
int port;
int.TryParse(_config, out port);
_socket.Connect("localhost", port);
// set non-blocking
//_socket.IOControl(IOControlCode.NonBlockingIO, BitConverter.GetBytes(1), null);
_socket.Blocking = false;
if (Agent.Connect.VerboseLogging)
{
if (logger != null) logger(GraphdatLogType.InformationMessage, logContext, "graphdat info: socket connected '{0}'",
_config);
}
return true;
}
catch (Exception ex)
{
Term(logger, logContext);
if (!_lastwaserror || Agent.Connect.VerboseLogging)
{
if (logger != null) logger(GraphdatLogType.ErrorMessage, logContext,
"graphdat error: could not connect socket '{0}' - {1}", _config, ex.Message);
_lastwaserror = true;
}
}
return false;
}
public static bool TryParse(string[] args, LoggerDelegate logger, out CommandArgs argResult, out Exception parseException)
{
try
{
var result = new CommandArgs();
var app = new CommandLineApplication();
app.HelpOption();
app.ThrowOnUnexpectedArgument = true;
var sourceOption = app
.Option("-s|--source <SOURCE>", "Path to the directory containing solidity source files", CommandOptionType.SingleValue)
.IsRequired()
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
opt = Path.GetFullPath(opt);
bool isDirExists = Directory.Exists(opt);
if (!isDirExists)
{
// Perform a case-insensitve search for the contracts directory.
if (Path.GetFileName(opt).Equals("contracts", StringComparison.OrdinalIgnoreCase))
{
var parentDirs = Directory.GetDirectories(Path.GetDirectoryName(opt), "*", SearchOption.TopDirectoryOnly);
var contractDir = parentDirs.FirstOrDefault(d => Path.GetFileName(d).Equals("contracts", StringComparison.OrdinalIgnoreCase));
if (contractDir != null)
{
opt = contractDir;
isDirExists = true;
}
}
}
if (!isDirExists)
{
return(new ValidationResult("Solidity source file directory does not exist: " + opt));
}
var containsSolFiles = Directory.EnumerateFiles(opt, "*.sol", SearchOption.AllDirectories).Any();
if (!containsSolFiles)
{
return(new ValidationResult("Solidity source file directory does not contain any .sol files: " + opt, new[] { MISSING_SOL_FILES }));
}
result.SolSourceDirectory = opt;
logger("Solidity source directory specified: " + opt);
return(ValidationResult.Success);
});
var namespaceOption = app
.Option("-n|--namespace", "The namespace for the generated code", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
if (!SyntaxFacts.IsValidIdentifier(opt.Replace('.', '_')))
{
return(new ValidationResult($"The specified namespace '{opt}' is not valid intenfier syntax"));
}
result.Namespace = opt;
return(ValidationResult.Success);
});
var generateOption = app
.Option <GenerateOutputType>("-g|--generate", "Generation output type, either 'source' or 'assembly'", CommandOptionType.MultipleValue)
.IsRequired()
.OnValidate(ctc =>
{
var opts = (ctc.ObjectInstance as CommandOption <GenerateOutputType>).ParsedValues;
result.Generate = opts.Aggregate(default(GenerateOutputType), (a, b) => a | b);
return(ValidationResult.Success);
})
.Accepts().Values("source", "assembly");
var legacySolcOption = app
.Option("--legacysolc", "Path to .NET legacy solc native resolver lib, required if solcversion options is set", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
if (!string.IsNullOrWhiteSpace(opt))
{
opt = Path.GetFullPath(opt);
if (!File.Exists(opt))
{
return(new ValidationResult($"Legacy solc lib path is set but file does not exist: {opt}"));
}
result.LegacySolcPath = opt;
logger($"Legacy solc lib set: {opt}");
}
return(ValidationResult.Success);
});
var solcVersionOption = app
.Option("--solcversion", "Version of the libsolc compiler to use, requires the legacysolc option to be set", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
if (!string.IsNullOrWhiteSpace(opt))
{
if (!Version.TryParse(opt, out var solcVersionParsed))
{
return(new ValidationResult($"Could not parse specified solc version: {opt}"));
}
result.SolcVersion = solcVersionParsed;
logger($"Solc version specified: {solcVersionParsed}");
}
return(ValidationResult.Success);
});
var solcOptimizerOption = app
.Option("--solcoptimizer", "Enables the solc optimizer with the given run number", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
if (!string.IsNullOrWhiteSpace(opt))
{
if (!int.TryParse(opt, out var solcOptimizerRuns))
{
return(new ValidationResult($"Could not parse specified solc optimizer run setting: '{opt}'. Should be an integer of 1 or high, or set to 0 or empty string for disabling optimizer."));
}
if (solcOptimizerRuns > 0)
{
result.SolcOptimizer = solcOptimizerRuns;
logger($"Solc optimizer enabled with run count: {solcOptimizerRuns}");
}
}
return(ValidationResult.Success);
});
var outputDirectoryOption = app
.Option("-o|--output", "Generated output directory", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
result.OutputDirectory = opt;
return(ValidationResult.Success);
});
var assemblyOutputDirectoryOption = app
.Option("--assembly-output", "Compilation output directory", CommandOptionType.SingleValue)
.OnValidate(ctc =>
{
var opt = (ctc.ObjectInstance as CommandOption).Value();
result.AssemblyOutputDirectory = opt;
return(ValidationResult.Success);
});
ValidationResult validationError = null;
app.OnValidationError(v =>
{
validationError = v;
});
bool successfulExecute = false;
app.OnExecute(() =>
{
successfulExecute = true;
});
app.Execute(args);
if (!successfulExecute || validationError != null)
{
var exception = new Exception(validationError.ErrorMessage);
foreach (var memberName in validationError.MemberNames)
{
exception.Data[memberName] = true;
}
throw exception;
}
parseException = null;
argResult = result;
return(true);
}
catch (Exception ex)
{
parseException = ex;
argResult = null;
return(false);
}
}
public HuntingGroundBehavior(LoggerDelegate loggerDelegate,
IsViableTargetDelegate isViableTarget,
WoWPoint huntingGroundAnchor,
double collectionDistance)
{
CollectionDistance = collectionDistance;
HuntingGroundAnchor = new WoWPointNamed(huntingGroundAnchor, "Hunting Ground Anchor", true);
IsViableTarget = isViableTarget;
Logger = loggerDelegate;
// UseHotspots(null, false);
}
public Socket(string config, LoggerDelegate logger, object logContext)
{
_config = config;
}
public void Term(LoggerDelegate logger, object logContext)
{
if (_socket != null)
{
_socket.Close();
_socket = null;
}
}
internal SMUCommand(IOlsInterface ols, bool isDualSocket, LoggerDelegate logger)
{
mOls = ols;
mIsDualSocket = isDualSocket;
mLogger = logger;
}
/// <summary> /// Установить метод логирования. /// </summary> /// <param name="value">Делегат логирования.</param> public static void Set(LoggerDelegate value) => loggerDelegate = value;
public string EvaluateStringExpression(LoggerDelegate logger, object o, string expr)
{
string exp = ExpandVariables(logger, o, false, expr == null ? "" : expr);
return(exp);
}
public string ExpandVariables(LoggerDelegate logger, object o, bool numeric, string expr)
{
Match m, mx;
string newexpr = expr;
int i = 1;
while (true)
{
m = rex.Match(newexpr);
if (m.Success == false)
{
m = rexnum.Match(newexpr);
if (m.Success == false)
{
break;
}
}
string x = m.Groups["id"].Value;
string val = "";
bool found = false;
if (testmode == true)
{
if (x == "_since")
{
val = ((int)Math.Floor((DateTime.UtcNow - triggered).TotalSeconds)).ToString();
}
else if (x == "_sincems")
{
val = ((int)Math.Floor((DateTime.UtcNow - triggered).TotalMilliseconds)).ToString();
}
else
{
val = (numeric == true ? "1" : "test");
}
found = true;
}
else
{
int gn;
if (Int32.TryParse(x, out gn) == true)
{
if (gn >= 0 && gn < numgroups.Count)
{
val = numgroups[gn];
found = true;
}
}
if (found == false)
{
if (namedgroups.ContainsKey(x) == true)
{
val = namedgroups[x];
found = true;
}
}
if (found == false)
{
if (x == "_since")
{
val = ((int)Math.Floor((DateTime.UtcNow - triggered).TotalSeconds)).ToString();
found = true;
}
else if (x == "_sincems")
{
val = ((int)Math.Floor((DateTime.UtcNow - triggered).TotalMilliseconds)).ToString();
found = true;
}
else if (x == "_systemtime")
{
val = ((long)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds).ToString();
found = true;
}
else if (x == "_systemtimems")
{
val = ((long)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalMilliseconds).ToString();
found = true;
}
else if (x == "_response")
{
val = contextResponse;
found = true;
}
else if (x.IndexOf("_jsonresponse") == 0)
{
mx = rexlidx.Match(x);
if (mx.Success == true)
{
string pathspec = mx.Groups["index"].Value;
if (contextJsonParsed == false)
{
JavaScriptSerializer jsonSerializer = new JavaScriptSerializer();
contextJsonResponse = jsonSerializer.Deserialize <dynamic>(contextResponse);
contextJsonParsed = true;
}
string[] path = pathspec.Split("/".ToCharArray());
dynamic curdir = contextJsonResponse;
foreach (string px in path)
{
curdir = curdir[px];
}
val = curdir.ToString();
found = true;
}
}
else if (x.IndexOf("evar:") == 0)
{
string varname = x.Substring(5);
lock (plug.simplevariables) // verified
{
if (plug.simplevariables.ContainsKey(varname) == true)
{
val = "1";
}
else
{
val = "0";
}
found = true;
}
}
else if (x.IndexOf("elvar:") == 0)
{
string varname = x.Substring(6);
lock (plug.listvariables) // verified
{
if (plug.listvariables.ContainsKey(varname) == true)
{
val = "1";
}
else
{
val = "0";
}
found = true;
}
}
else if (x.IndexOf("var:") == 0)
{
string varname = x.Substring(4);
lock (plug.simplevariables) // verified
{
if (plug.simplevariables.ContainsKey(varname) == true)
{
val = plug.simplevariables[varname].Value;
found = true;
}
}
}
else if (x.IndexOf("lvar:") == 0)
{
string varname = x.Substring(5);
mx = rexlprp.Match(varname);
if (mx.Success == true)
{
string gname = mx.Groups["name"].Value;
string gprop = mx.Groups["prop"].Value;
switch (gprop)
{
case "size":
{
lock (plug.listvariables)
{
VariableList vl = GetListVariable(plug, gname, false);
val = vl.Size().ToString();
found = true;
}
}
break;
case "indexof":
{
string garg = mx.Groups["arg"].Value;
lock (plug.listvariables)
{
VariableList vl = GetListVariable(plug, gname, false);
val = vl.IndexOf(garg).ToString();
found = true;
}
}
break;
}
}
else
{
mx = rexlidx.Match(varname);
if (mx.Success == true)
{
string gname = mx.Groups["name"].Value;
string gindex = mx.Groups["index"].Value;
lock (plug.listvariables)
{
VariableList vl = GetListVariable(plug, gname, false);
if (gindex == "last")
{
gindex = vl.Size().ToString();
}
int iindex;
if (Int32.TryParse(gindex, out iindex) == true)
{
val = vl.Peek(iindex);
}
found = true;
}
found = true;
}
}
}
else if (x.IndexOf("numeric:") == 0)
{
string numexpr = x.Substring(8);
val = I18n.ThingToString(EvaluateNumericExpression(logger, o, numexpr));
found = true;
}
else if (x.IndexOf("string:") == 0)
{
string numexpr = x.Substring(7);
val = EvaluateStringExpression(logger, o, numexpr);
found = true;
}
else if (x.IndexOf("func:") == 0)
{
val = "";
found = true;
string funcexpr = x.Substring(5);
int splitter = funcexpr.IndexOf(":");
if (splitter > 0)
{
string funcdef = funcexpr.Substring(0, splitter);
Match rxm = rexfunc.Match(funcdef);
if (rxm.Success == true)
{
string funcname = rxm.Groups["name"].Value.ToLower();
string funcarg = rxm.Groups["arg"].Value;
string[] args = SplitArguments(funcarg);
int argc = args.Count();
string funcval = funcexpr.Substring(splitter + 1);
switch (funcname)
{
case "toupper": // toupper()
val = funcval.ToUpper();
break;
case "tolower": // tolower()
val = funcval.ToLower();
break;
case "length": // length()
val = funcval.Length.ToString();
break;
case "hex2dec": // hex2dec()
val = "" + int.Parse(funcval, System.Globalization.NumberStyles.HexNumber);
break;
case "padleft": // padleft(charcode,length)
if (argc != 2)
{
throw new ArgumentException(I18n.Translate("internal/Context/padleftargerror", "Padleft function requires two arguments, {0} were given", argc));
}
else
{
val = funcval.PadLeft(Int32.Parse(args[1]), (char)Int32.Parse(args[0]));
}
break;
case "padright": // padright(charcode,length)
if (argc != 2)
{
throw new ArgumentException(I18n.Translate("internal/Context/padrightargerror", "Padright function requires two arguments, {0} were given", argc));
}
else
{
val = funcval.PadRight(Int32.Parse(args[1]), (char)Int32.Parse(args[0]));
}
break;
case "substring": // substring(startindex, length) or substring(startindex)
if (argc != 1 && argc != 2)
{
throw new ArgumentException(I18n.Translate("internal/Context/substringargerror", "Substring function requires one or two arguments, {0} were given", argc));
}
else
{
switch (argc)
{
case 1:
val = funcval.Substring(Int32.Parse(args[0]));
break;
case 2:
val = funcval.Substring(Int32.Parse(args[0]), Int32.Parse(args[1]));
break;
}
}
break;
case "indexof": // indexof(stringtosearch)
if (argc != 1)
{
throw new ArgumentException(I18n.Translate("internal/Context/indexofargerror", "Indexof function requires one argument, {0} were given", argc));
}
else
{
val = "" + funcval.IndexOf(args[0]);
}
break;
case "trim": // trim() or trim(charcode,charcode,charcode,...)
if (argc == 0 || args[0] == "")
{
val = funcval.Trim();
}
else
{
string xx = "";
foreach (string xyz in args)
{
xx += (char)Int32.Parse(xyz);
}
val = funcval.Trim(xx.ToCharArray());
}
break;
case "trimleft": // trimleft() or trimleft(charcode,charcode,charcode,...)
if (argc == 0 || args[0] == "")
{
val = funcval.TrimStart();
}
else
{
string xx = "";
foreach (string xyz in args)
{
xx += (char)Int32.Parse(xyz);
}
val = funcval.TrimStart(xx.ToCharArray());
}
break;
case "trimright": // trimright() or trimright(charcode,charcode,charcode,...)
if (argc == 0 || args[0] == "")
{
val = funcval.TrimEnd();
}
else
{
string xx = "";
foreach (string xyz in args)
{
xx += (char)Int32.Parse(xyz);
}
val = funcval.TrimEnd(xx.ToCharArray());
}
break;
case "format": // format(type,formatstring)
if (argc != 2)
{
throw new ArgumentException(I18n.Translate("internal/Context/formatargerror", "Format function requires two arguments, {0} were given", argc));
}
else
{
Type type = Type.GetType(args[0]);
object converted = Convert.ChangeType(funcval, type, CultureInfo.InvariantCulture);
val = String.Format("{0:" + args[1] + "}", converted);
}
break;
}
}
}
}
else if (x == "_ffxivplayer")
{
VariableClump vc = PluginBridges.BridgeFFXIV.GetMyself();
if (vc != null)
{
val = vc.GetValue("name");
}
found = true;
}
else if (x == "_ffxivpartyorder")
{
val = plug.cfg.FfxivPartyOrdering + " " + plug.cfg.FfxivCustomPartyOrder;
found = true;
}
else if (x == "_incombat")
{
val = (plug.mainform.InCombat == true) ? "1" : "0";
found = true;
}
else if (x == "_duration")
{
try
{
if (plug.mainform.InCombat == true)
{
val = ((int)Math.Floor(plug.mainform.ActiveZone.ActiveEncounter.Duration.TotalSeconds)).ToString();
}
else
{
val = "0";
}
}
catch (Exception)
{
val = "0";
}
found = true;
}
else if (x.IndexOf("_ffxivparty") == 0)
{
mx = rexnump.Match(x);
if (mx.Success == true)
{
string gindex = mx.Groups["index"].Value;
string gprop = mx.Groups["prop"].Value;
int iindex = 0;
Int64 honk;
VariableClump vc = null;
bool foundid = false;
if (Int64.TryParse(gindex, System.Globalization.NumberStyles.HexNumber, CultureInfo.InvariantCulture, out honk) == true)
{
vc = PluginBridges.BridgeFFXIV.GetIdPartyMember(gindex, out foundid);
}
if (foundid == false)
{
if (Int32.TryParse(gindex, out iindex) == true)
{
vc = PluginBridges.BridgeFFXIV.GetPartyMember(iindex);
}
else
{
vc = PluginBridges.BridgeFFXIV.GetNamedPartyMember(gindex);
}
}
if (vc != null)
{
val = vc.GetValue(gprop);
}
}
found = true;
}
else if (x.IndexOf("_ffxiventity") == 0)
{
mx = rexnump.Match(x);
if (mx.Success == true)
{
string gindex = mx.Groups["index"].Value;
string gprop = mx.Groups["prop"].Value;
Int64 honk;
VariableClump vc = null;
bool foundid = false;
if (Int64.TryParse(gindex, System.Globalization.NumberStyles.HexNumber, CultureInfo.InvariantCulture, out honk) == true)
{
vc = PluginBridges.BridgeFFXIV.GetIdEntity(gindex, out foundid);
}
if (foundid == false)
{
vc = PluginBridges.BridgeFFXIV.GetNamedEntity(gindex);
}
if (vc != null)
{
val = vc.GetValue(gprop);
}
}
found = true;
}
else if (x == "_ffxivtime")
{
TimeSpan ez = GetEorzeanTime();
int mins = (int)Math.Floor(ez.TotalMinutes);
val = mins.ToString();
found = true;
}
else if (x == "_lastencounter")
{
Advanced_Combat_Tracker.FormActMain act = Advanced_Combat_Tracker.ActGlobals.oFormActMain;
FieldInfo fi = act.GetType().GetField("defaultTextFormat", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
dynamic texf = fi.GetValue(act);
val = "";
if (texf != null)
{
int zones = act.ZoneList.Count;
for (int ii = zones - 1; ii >= 0; ii--)
{
int encs = act.ZoneList[ii].Items.Count;
for (int jj = encs - 1; jj >= 1; jj--)
{
if (act.ZoneList[ii].Items[jj] != act.ActiveZone.ActiveEncounter)
{
val = act.GetTextExport(act.ZoneList[ii].Items[jj], texf);
ii = 0;
jj = 0;
}
}
}
}
found = true;
}
else if (x == "_activeencounter")
{
Advanced_Combat_Tracker.FormActMain act = Advanced_Combat_Tracker.ActGlobals.oFormActMain;
FieldInfo fi = act.GetType().GetField("defaultTextFormat", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
dynamic texf = fi.GetValue(act);
val = act.GetTextExport(act.ActiveZone.ActiveEncounter, texf);
found = true;
}
else if (x.IndexOf("_textaura") == 0)
{
mx = rexnump.Match(x);
if (mx.Success == true)
{
string gindex = mx.Groups["index"].Value;
string gprop = mx.Groups["prop"].Value.ToLower();
val = "";
lock (plug.textauras)
{
if (plug.textauras.ContainsKey(gindex) == true)
{
Forms.AuraContainerForm acf = plug.textauras[gindex];
switch (gprop)
{
case "x":
val = acf.Left.ToString(CultureInfo.InvariantCulture);
break;
case "y":
val = acf.Top.ToString(CultureInfo.InvariantCulture);
break;
case "w":
val = acf.Width.ToString(CultureInfo.InvariantCulture);
break;
case "h":
val = acf.Height.ToString(CultureInfo.InvariantCulture);
break;
case "opacity":
val = acf.PresentableOpacity.ToString(CultureInfo.InvariantCulture);
break;
case "text":
val = acf.CurrentText;
break;
}
}
}
found = true;
}
}
else if (x.IndexOf("_imageaura") == 0)
{
mx = rexnump.Match(x);
if (mx.Success == true)
{
string gindex = mx.Groups["index"].Value;
string gprop = mx.Groups["prop"].Value.ToLower();
val = "";
lock (plug.imageauras)
{
if (plug.imageauras.ContainsKey(gindex) == true)
{
Forms.AuraContainerForm acf = plug.imageauras[gindex];
switch (gprop)
{
case "x":
val = acf.Left.ToString(CultureInfo.InvariantCulture);
break;
case "y":
val = acf.Top.ToString(CultureInfo.InvariantCulture);
break;
case "w":
val = acf.Width.ToString(CultureInfo.InvariantCulture);
break;
case "h":
val = acf.Height.ToString(CultureInfo.InvariantCulture);
break;
case "opacity":
val = acf.PresentableOpacity.ToString(CultureInfo.InvariantCulture);
break;
}
}
}
found = true;
}
}
else if (x == "_screenwidth")
{
System.Windows.Forms.Screen scr = System.Windows.Forms.Screen.PrimaryScreen;
val = scr.WorkingArea.Width.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_screenheight")
{
System.Windows.Forms.Screen scr = System.Windows.Forms.Screen.PrimaryScreen;
val = scr.WorkingArea.Height.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_screenminx")
{
val = plug.MinX.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_screenminy")
{
val = plug.MinY.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_screenmaxx")
{
val = plug.MaxX.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_screenmaxy")
{
val = plug.MaxY.ToString(CultureInfo.InvariantCulture);
found = true;
}
else if (x == "_fps")
{
if (plug.sc != null)
{
val = plug.sc.FPS.ToString(CultureInfo.InvariantCulture);
}
else
{
val = "0";
}
found = true;
}
}
}
newexpr = newexpr.Substring(0, m.Index) + val + newexpr.Substring(m.Index + m.Length);
/*
* if (logger != null)
* {
* logger(o, I18n.Translate("internal/Context/expansionstep", "Expansion step {0} from '{1}' to '{2}' ({3}) = '{4}'", i, expr, newexpr, val, found));
* }
* else if (plug != null)
* {
* plug.FilteredAddToLog(Plugin.DebugLevelEnum.Verbose, I18n.Translate("internal/Context/expansionstep", "Expansion step {0} from '{1}' to '{2}' ({3}) = '{4}'", i, expr, newexpr, val, found));
* }*/
i++;
}
;
if (trig != null)
{
if (trig.DebugLevel == Plugin.DebugLevelEnum.Inherit)
{
if (plug != null)
{
if (plug.cfg.DebugLevel < Plugin.DebugLevelEnum.Verbose)
{
return(newexpr);
}
}
}
else
{
if (trig.DebugLevel < Plugin.DebugLevelEnum.Verbose)
{
return(newexpr);
}
}
}
if (newexpr.CompareTo(expr) != 0)
{
if (logger != null)
{
logger(o, I18n.Translate("internal/Context/expansion", "Variable expansion from '{0}' to '{1}'", expr, newexpr));
}
else if (plug != null)
{
plug.FilteredAddToLog(Plugin.DebugLevelEnum.Verbose, I18n.Translate("internal/Context/expansion", "Variable expansion from '{0}' to '{1}'", expr, newexpr));
}
}
return(newexpr);
}
public static void InitDB(string conString) {
strCon = conString;
roam = new DatasetRoam();
partners = roam.Partner;
calls = roam.CDR;
tags = roam.Tag;
taps = roam.TAP;
rates = roam.Rate;
cc = roam.CountryCode;
tariff = roam.Tariff;
delegateLogWriter = new LoggerDelegate(WriteLog);
con = new SqlConnection(strCon);
daPartner = new SqlDataAdapter();
daCall = new SqlDataAdapter();
daTag = new SqlDataAdapter();
daTap = new SqlDataAdapter();
daRate = new SqlDataAdapter();
daCc = new SqlDataAdapter();
daTariff = new SqlDataAdapter();
daPartner.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("Partner_Table", "t_VPLMN"), con);
daPartner.UpdateCommand = new SqlCommand("UPDATE " + AppSetting.Get("Partner_Table", "t_VPLMN") + " SET c_Name=@name, c_State=@state,c_ContractDate=@contractDate, c_IMSI=@imsi, c_CountryCode=@countryCode, c_InvoiceNo=@invoiceNo, c_TAPFormat=@tapVersion, c_TAPSequence=@tapSequence, c_FraudSDR= @fraudNumber, c_Address=@invoiceAddress, c_Email=@email, c_HPLMNPrice=@hplmnPrice WHERE c_VPLMN=@vplmn", con);
daPartner.UpdateCommand.Parameters.Add("@vplmn", SqlDbType.VarChar, 5, "c_VPLMN");
daPartner.UpdateCommand.Parameters.Add("@name", SqlDbType.VarChar, 50, "c_Name");
daPartner.UpdateCommand.Parameters.Add("@state", SqlDbType.Bit, 1, "c_State");
daPartner.UpdateCommand.Parameters.Add("@contractDate", SqlDbType.DateTime, 8, "c_ContractDate");
daPartner.UpdateCommand.Parameters.Add("@imsi", SqlDbType.VarChar, 5, "c_IMSI");
daPartner.UpdateCommand.Parameters.Add("@countryCode", SqlDbType.Int, 4, "c_CountryCode");
daPartner.UpdateCommand.Parameters.Add("@tapVersion", SqlDbType.VarChar, 10, "c_TAPFormat");
daPartner.UpdateCommand.Parameters.Add("@tapSequence", SqlDbType.Int, 4, "c_TAPSequence");
daPartner.UpdateCommand.Parameters.Add("@invoiceNo", SqlDbType.Int, 4, "c_InvoiceNo");
daPartner.UpdateCommand.Parameters.Add("@invoiceAddress", SqlDbType.VarChar, 500, "c_Address");
daPartner.UpdateCommand.Parameters.Add("@email", SqlDbType.VarChar, 120, "c_Email");
daPartner.UpdateCommand.Parameters.Add("@fraudNumber", SqlDbType.Int, 4, "c_FraudNumber");
daPartner.UpdateCommand.Parameters.Add("@hplmnPrice", SqlDbType.Money, 8, "c_HPLMNPrice");
daCall.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("OutCdr_Table", "t_CDR_Out") + " WHERE c_imsi LIKE @imsi+'%' AND c_SeqNo=@seq ORDER BY c_Date", con);
daCall.SelectCommand.Parameters.Add("@imsi", SqlDbType.VarChar, 5);
daCall.SelectCommand.Parameters.Add("@seq", SqlDbType.Int, 4);
daTag.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("Tag_Table", "t_Tag"), con);
daTap.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("TAP_Table", "t_TAP") + " WHERE c_VPLMN=@vplmn AND c_InvoiceNo=@inv_no AND c_Filename LIKE 'CD%' ORDER BY c_FileName", con);
daTap.SelectCommand.Parameters.Add("@vplmn", SqlDbType.VarChar, 5);
daTap.SelectCommand.Parameters.Add("@inv_no", SqlDbType.Int, 4);
daRate.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("Rate_Table", "t_Rate") + " ORDER BY c_ValidFrom", con);
daRate.UpdateCommand = new SqlCommand("UPDATE " + AppSetting.Get("Rate_Table", "t_Rate") + " SET c_SDRRate=@rate, c_Date=@date, c_PeggedDate=@validdate WHERE c_RateID=@rateid", con);
daRate.UpdateCommand.Parameters.Add("@rate", SqlDbType.Money, 8, "c_SDRRate");
daRate.UpdateCommand.Parameters.Add("@date", SqlDbType.DateTime, 8, "c_Date");
daRate.UpdateCommand.Parameters.Add("@validdate", SqlDbType.DateTime, 8, "c_PeggedDate");
daRate.UpdateCommand.Parameters.Add("@rateid", SqlDbType.Int, 4, "c_RateID");
daCc.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("CC_Table", "t_CountryCode"), con);
daTariff.SelectCommand = new SqlCommand("SELECT * FROM " + AppSetting.Get("Tariff_Table", "t_Tariff"), con);
udfWriter = new SqlCommand("INSERT INTO " + AppSetting.Get("InCDR_Table", "t_CDR_In") + " (c_CallType, c_Division, c_Date, c_Duration, c_LocA, c_Imsi, c_Isdn, c_LocB, c_CallPartner, c_SDR, c_SeqNo, c_Error) VALUES (@calltype, @division, @date, @duration, @loca, @imsi, @isdn, @locb, @partner, @sdr, @seqno, @error)", con);
udfWriter.Parameters.Add("@calltype", SqlDbType.Char, 1);
udfWriter.Parameters.Add("@division", SqlDbType.Char, 1);
udfWriter.Parameters.Add("@date", SqlDbType.DateTime, 8);
udfWriter.Parameters.Add("@duration", SqlDbType.Int, 4);
udfWriter.Parameters.Add("@loca", SqlDbType.VarChar, 6);
udfWriter.Parameters.Add("@imsi", SqlDbType.VarChar, 15);
udfWriter.Parameters.Add("@isdn", SqlDbType.VarChar, 20);
udfWriter.Parameters.Add("@locb", SqlDbType.VarChar, 6);
udfWriter.Parameters.Add("@partner", SqlDbType.VarChar, 20);
udfWriter.Parameters.Add("@sdr", SqlDbType.Money, 8);
udfWriter.Parameters.Add("@seqno", SqlDbType.Int, 4);
udfWriter.Parameters.Add("@error", SqlDbType.Char, 1);
udfWriter.CommandType = CommandType.Text;
sqlRegTAP = new SqlCommand("sp_RegTAP", con);
sqlRegTAP.CommandType = CommandType.StoredProcedure;
sqlRegTAP.Parameters.Add("@filename", SqlDbType.Char, 17);
sqlRegTAP.Parameters.Add("@creationdate", SqlDbType.DateTime, 8);
sqlRegTAP.Parameters.Add("@firstcalldate", SqlDbType.DateTime, 8);
sqlRegTAP.Parameters.Add("@lastcalldate", SqlDbType.DateTime, 8);
sqlRegTAP.Parameters.Add("@calls", SqlDbType.Int, 4);
sqlRegTAP.Parameters.Add("@sdr", SqlDbType.Money, 8);
sqlLogWriter = new SqlCommand("insert into t_log(c_msg) values(@msg)", con);
sqlLogWriter.CommandType = CommandType.Text;
sqlLogWriter.Parameters.Add("@msg", SqlDbType.VarChar, 500);
}
public void removeLogger(ILogger logger)
{
this.allLogers -= logger.LogMessage;
}
/// <summary>
/// User configuration for the internal logger.
/// </summary>
/// <param name="loggerEnable">If false, nothing will be logged.</param>
/// <param name="debugLogEnable">If false, only debug level will not be logged.</param>
/// <param name="loggerDelegate">You can add your own implementation of the logger (else the default one will be used).</param>
/// <param name="filter"></param>
public static void Initialize(bool loggerEnable, bool debugLogEnable = false, LoggerDelegate loggerDelegate = null, string filter = null)
{
InternalLogger.EnableDebug = debugLogEnable;
InternalLogger.EnableLogging = loggerEnable;
InternalLogger.LoggerDelegate = loggerDelegate;
InternalLogger.SetFilter(filter);
}
public API(LoggerDelegate logger)
{
Context = new ContextBuilder<Timer>(() => new Timer(), timer => timer.Stop());
_logger = logger;
}
public void addLogger(ILogger logger)
{
this.filter = (filter > logger.Filter) ? logger.Filter : filter;
this.allLogers += logger.LogMessage;
}
public static SolCodeGenResults Generate(CommandArgs appArgs, bool returnFullSources = false, LoggerDelegate logger = null)
{
Stopwatch sw = new Stopwatch();
sw.Start();
logger = (logger ?? Console.WriteLine);
var isGenerateAssemblyEnabled = appArgs.Generate.HasFlag(GenerateOutputType.Assembly);
var generator = new CodebaseGenerator(appArgs, returnFullSources | isGenerateAssemblyEnabled, logger);
generator.GenerateSources();
if (isGenerateAssemblyEnabled)
{
generator.GenerateCompilationOutput();
}
sw.Stop();
logger($"SolCodeGen completed in: {Math.Round(sw.Elapsed.TotalSeconds, 2)} seconds");
return(generator._genResults);
}
public WTS() {
delegateLogWriter = new LoggerDelegate(LogWriter);
}
public static extern void AttachLoggerHandler([MarshalAs(UnmanagedType.FunctionPtr)] LoggerDelegate logger);
public void removeLogger(params ILogger[] logger)
{
foreach (ILogger log in logger) {
this.allLogers -= log.LogMessage;
}
}
internal void removeAllLoggers()
{
//LogMessage("All loggers removed", LogLevel.INFO);
this.allLogers = null;
}
public void addLogger(ILogger logger)
{
this.filter = (filter > logger.Filter) ? logger.Filter : filter;
this.allLogers += logger.LogMessage;
}
public void removeLogger(ILogger logger)
{
this.allLogers -= logger.LogMessage;
}
public SwimBreathBehavior(LoggerDelegate loggerDelegate)
{
Logger = loggerDelegate;
}
public Psp() {
op.opid = -1;
op.uid = "";
delegateLogWriter = new LoggerDelegate(LogWriter);
tablePermission = new DataTable("Permission");
tablePermission.CaseSensitive = false;
tablePermission.Columns.Add("c_id", typeof(int));
tablePermission.Columns.Add("c_desc", typeof(string));
tablePermission.Constraints.Add("pk_desc", tablePermission.Columns["c_desc"], true);
tableProCmd = new DataTable("ProCmd");
tableProCmd.CaseSensitive = false;
tableProCmd.Columns.Add("c_cmd", typeof(string));
tableProCmd.Columns.Add("c_desc", typeof(string));
tableProCmd.Columns.Add("c_durationflag", typeof(bool));
tableProCmd.Columns.Add("c_paramflag", typeof(bool));
tableProCmd.Columns.Add("c_help", typeof(string));
daPermission = new SqlDataAdapter();
daPermission.SelectCommand = new SqlCommand("sp_GetPermission");
daPermission.SelectCommand.CommandType = CommandType.StoredProcedure;
daPermission.SelectCommand.Parameters.Add("@opid", SqlDbType.Int, 4);
daPermission.SelectCommand.Parameters.Add("@obj", SqlDbType.VarChar, 50);
daPermission.SelectCommand.Parameters.Add("@isrole", SqlDbType.Bit, 1);
daPermission.UpdateCommand = new SqlCommand("sp_SetPermission");
daPermission.UpdateCommand.CommandType = CommandType.StoredProcedure;
daPermission.UpdateCommand.Parameters.Add("@role", SqlDbType.Int, 4);
daPermission.UpdateCommand.Parameters.Add("@pm", SqlDbType.Int, 4);
daPermission.UpdateCommand.Parameters.Add("@grant", SqlDbType.Bit, 1);
daProvision = new SqlDataAdapter();
daProvision.SelectCommand = new SqlCommand("sp_GetProvision");
daProvision.SelectCommand.CommandType = CommandType.StoredProcedure;
daProvision.SelectCommand.Parameters.Add("@filter", SqlDbType.VarChar, 20);
daProvision.SelectCommand.Parameters.Add("@begdate", SqlDbType.DateTime, 8);
daProvision.SelectCommand.Parameters.Add("@enddate", SqlDbType.DateTime, 8);
daProvision.SelectCommand.Parameters.Add("@ftype", SqlDbType.Int, 4);
daProvision.SelectCommand.Parameters.Add("@sum", SqlDbType.Bit, 1);
daProCmd = new SqlDataAdapter();
daProCmd.SelectCommand = new SqlCommand("sp_GetProCmd");
daProCmd.SelectCommand.CommandType = CommandType.StoredProcedure;
daProCmd.SelectCommand.Parameters.Add("@opid", SqlDbType.Int, 4);
daRecharge = new SqlDataAdapter();
daRecharge.SelectCommand = new SqlCommand("sp_GetRecharge");
daRecharge.SelectCommand.CommandType = CommandType.StoredProcedure;
daRecharge.SelectCommand.Parameters.Add("@param", SqlDbType.VarChar, 16);
daRecharge.SelectCommand.Parameters.Add("@mode", SqlDbType.Int, 4);
daRecharge.UpdateCommand = new SqlCommand("sp_SaveRecharge");
daRecharge.UpdateCommand.CommandType = CommandType.StoredProcedure;
daRecharge.UpdateCommand.Parameters.Add("@isdn", SqlDbType.VarChar, 8);
daRecharge.UpdateCommand.Parameters.Add("@date", SqlDbType.DateTime, 8);
daRecharge.UpdateCommand.Parameters.Add("@duration", SqlDbType.Int, 4);
daRecharge.UpdateCommand.Parameters.Add("@value", SqlDbType.Money, 8);
daRecharge.UpdateCommand.Parameters.Add("@balance", SqlDbType.Money, 8);
daRecharge.UpdateCommand.Parameters.Add("@param", SqlDbType.VarChar, 20);
daRecharge.UpdateCommand.Parameters.Add("@source", SqlDbType.VarChar, 10);
daBill = new SqlDataAdapter();
daBill.SelectCommand = new SqlCommand("sp_GetBill");
daBill.SelectCommand.CommandType = CommandType.StoredProcedure;
daBill.SelectCommand.Parameters.Add("@billno", SqlDbType.Int, 4);
daBill.SelectCommand.Parameters.Add("@branch", SqlDbType.Int, 4);
daBillItem = new SqlDataAdapter();
daBillItem.SelectCommand = new SqlCommand("select * from t_billitem");
daBillItem.UpdateCommand = new SqlCommand("sp_SaveBillItem");
daBillItem.UpdateCommand.CommandType = CommandType.StoredProcedure;
daBillItem.UpdateCommand.Parameters.Add("@id", SqlDbType.Int, 4);
daBillItem.UpdateCommand.Parameters.Add("@desc", SqlDbType.NVarChar, 50);
daBillItem.UpdateCommand.Parameters.Add("@order", SqlDbType.Int, 4);
daBillItem.UpdateCommand.Parameters.Add("@calcrule", SqlDbType.VarChar, 500);
daBillItem.UpdateCommand.Parameters.Add("@tariff", SqlDbType.VarChar, 50);
daTariff = new SqlDataAdapter();
daTariff.SelectCommand = new SqlCommand("sp_GetTariff");
daTariff.SelectCommand.CommandType = CommandType.StoredProcedure;
daTariff.SelectCommand.Parameters.Add("@tariff", SqlDbType.VarChar, 50);
daTariff.UpdateCommand = new SqlCommand("sp_SaveTariff");
daTariff.UpdateCommand.CommandType = CommandType.StoredProcedure;
daTariff.UpdateCommand.Parameters.Add("@tariff", SqlDbType.VarChar, 50);
daTariff.UpdateCommand.Parameters.Add("@currency", SqlDbType.Char, 3);
daTariff.UpdateCommand.Parameters.Add("@cnxcost", SqlDbType.Money, 8);
daTariff.UpdateCommand.Parameters.Add("@cnxqty", SqlDbType.Int, 4);
daTariff.UpdateCommand.Parameters.Add("@deltacost", SqlDbType.Money, 8);
daTariff.UpdateCommand.Parameters.Add("@qtyt", SqlDbType.Int, 4);
daTariff.UpdateCommand.Parameters.Add("@cost1", SqlDbType.Money, 8);
daTariff.UpdateCommand.Parameters.Add("@qty1", SqlDbType.Int, 4);
daTariff.UpdateCommand.Parameters.Add("@cost2", SqlDbType.Money, 8);
daTariff.UpdateCommand.Parameters.Add("@qty2", SqlDbType.Int, 4);
daTerminal = new SqlDataAdapter();
daTerminal.SelectCommand = new SqlCommand("sp_GetTerminal");
daTerminal.SelectCommand.CommandType = CommandType.StoredProcedure;
daTerminal.SelectCommand.Parameters.Add("@isdn", SqlDbType.VarChar, 8);
daTerminal.UpdateCommand = new SqlCommand("sp_SaveTerminal");
daTerminal.UpdateCommand.CommandType = CommandType.StoredProcedure;
daTerminal.UpdateCommand.Parameters.Add("@isdn", SqlDbType.VarChar, 8);
daTerminal.UpdateCommand.Parameters.Add("@imsi", SqlDbType.VarChar, 15);
daTerminal.UpdateCommand.Parameters.Add("@flag", SqlDbType.Int, 4);
daVas = new SqlDataAdapter();
daVas.SelectCommand = new SqlCommand("sp_GetVas");
daVas.SelectCommand.CommandType = CommandType.StoredProcedure;
daVas.SelectCommand.Parameters.Add("@filter", SqlDbType.VarChar, 10);
daVas.SelectCommand.Parameters.Add("@flag", SqlDbType.Int, 4);
daVas.UpdateCommand = new SqlCommand("sp_SaveVas");
daVas.UpdateCommand.CommandType = CommandType.StoredProcedure;
daVas.UpdateCommand.Parameters.Add("@isdn", SqlDbType.VarChar, 8);
daVas.UpdateCommand.Parameters.Add("@vas", SqlDbType.VarChar, 10);
daVas.UpdateCommand.Parameters.Add("@begdate", SqlDbType.DateTime, 8);
daVas.UpdateCommand.Parameters.Add("@enddate", SqlDbType.DateTime, 8);
daVas.UpdateCommand.Parameters.Add("@data", SqlDbType.VarChar, 100);
daCustomer = new SqlDataAdapter();
daCustomer.SelectCommand = new SqlCommand("sp_GetCustomer");
daCustomer.SelectCommand.CommandType = CommandType.StoredProcedure;
daCustomer.SelectCommand.Parameters.Add("@filter", SqlDbType.VarChar, 50);
daCustomer.SelectCommand.Parameters.Add("@beg", SqlDbType.DateTime, 8);
daCustomer.SelectCommand.Parameters.Add("@end", SqlDbType.DateTime, 8);
daCustomer.SelectCommand.Parameters.Add("@flag", SqlDbType.Int, 4);
daCustomer.UpdateCommand = new SqlCommand("sp_SaveCustomer");
daCustomer.UpdateCommand.CommandType = CommandType.StoredProcedure;
daCustomer.UpdateCommand.Parameters.Add("@isdn", SqlDbType.VarChar, 8);
daCustomer.UpdateCommand.Parameters.Add("@status", SqlDbType.VarChar, 2);
daCustomer.UpdateCommand.Parameters.Add("@name", SqlDbType.NVarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@sex", SqlDbType.NChar, 2);
daCustomer.UpdateCommand.Parameters.Add("@id1", SqlDbType.NVarChar, 15);
daCustomer.UpdateCommand.Parameters.Add("@id2", SqlDbType.NVarChar, 15);
daCustomer.UpdateCommand.Parameters.Add("@id3", SqlDbType.NVarChar, 30);
daCustomer.UpdateCommand.Parameters.Add("@phone", SqlDbType.VarChar, 20);
daCustomer.UpdateCommand.Parameters.Add("@email", SqlDbType.VarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@job", SqlDbType.NVarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@industry", SqlDbType.NVarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@city", SqlDbType.NVarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@district", SqlDbType.NVarChar, 50);
daCustomer.UpdateCommand.Parameters.Add("@addr", SqlDbType.NVarChar, 200);
daCustomer.UpdateCommand.Parameters.Add("@note", SqlDbType.NVarChar, 200);
daCustomer.UpdateCommand.Parameters.Add("@opid", SqlDbType.Int, 4);
daCustomer.UpdateCommand.Parameters.Add("@msg", SqlDbType.NVarChar, 200);
daCustomer.UpdateCommand.Parameters["@msg"].Direction = ParameterDirection.Output;
daLog = new SqlDataAdapter();
daLog.SelectCommand = new SqlCommand("sp_GetLog");
daLog.SelectCommand.CommandType = CommandType.StoredProcedure;
daLog.SelectCommand.Parameters.Add("@who", SqlDbType.VarChar, 8);
daLog.SelectCommand.Parameters.Add("@beg", SqlDbType.DateTime, 8);
daLog.SelectCommand.Parameters.Add("@end", SqlDbType.DateTime, 8);
daLog.SelectCommand.Parameters.Add("@flag", SqlDbType.Int, 4);
daLog.UpdateCommand = new SqlCommand("insert into t_log(c_uid, c_msg, c_host, c_sessionid) values(@uid, @msg, @host, @session)");
daLog.UpdateCommand.Parameters.Add("@uid", SqlDbType.VarChar, 20);
daLog.UpdateCommand.Parameters.Add("@msg", SqlDbType.VarChar, 500);
daLog.UpdateCommand.Parameters.Add("@host", SqlDbType.VarChar, 50);
daLog.UpdateCommand.Parameters.Add("@session", SqlDbType.VarChar, 50);
daBranch = new SqlDataAdapter();
daBranch.SelectCommand = new SqlCommand("sp_GetBranch");
daBranch.SelectCommand.CommandType = CommandType.StoredProcedure;
daBranch.SelectCommand.Parameters.Add("@filter", SqlDbType.NVarChar, 50);
daBranch.UpdateCommand = new SqlCommand("sp_SaveBranch");
daBranch.UpdateCommand.CommandType = CommandType.StoredProcedure;
daBranch.UpdateCommand.Parameters.Add("@name", SqlDbType.NVarChar, 50);
daBranch.UpdateCommand.Parameters.Add("@region", SqlDbType.NVarChar, 50);
daBranch.UpdateCommand.Parameters.Add("@promode", SqlDbType.Int, 4);
daOperator = new SqlDataAdapter();
daOperator.SelectCommand = new SqlCommand("sp_GetOperator");
daOperator.SelectCommand.CommandType = CommandType.StoredProcedure;
daOperator.SelectCommand.Parameters.Add("@filter", SqlDbType.VarChar, 20);
daOperator.SelectCommand.Parameters.Add("@flag", SqlDbType.Int, 4);
daOperator.UpdateCommand = new SqlCommand("sp_SaveOperator");
daOperator.UpdateCommand.CommandType = CommandType.StoredProcedure;
daOperator.UpdateCommand.Parameters.Add("@uid", SqlDbType.VarChar, 20);
daOperator.UpdateCommand.Parameters.Add("@pwd", SqlDbType.VarChar, 40);
daOperator.UpdateCommand.Parameters.Add("@role", SqlDbType.Int, 4);
daOperator.UpdateCommand.Parameters.Add("@desc", SqlDbType.NVarChar, 50);
daOperator.UpdateCommand.Parameters.Add("@branch", SqlDbType.Int, 4);
daOperator.UpdateCommand.Parameters.Add("@promode", SqlDbType.Int, 4);
daOperator.UpdateCommand.Parameters.Add("@phone", SqlDbType.VarChar, 20);
daOperator.UpdateCommand.Parameters.Add("@email", SqlDbType.VarChar, 50);
}
public HuntingGroundBehavior(LoggerDelegate loggerDelegate,
IsViableTargetDelegate isViableTarget,
WoWPoint huntingGroundAnchor,
double collectionDistance)
{
CollectionDistance = collectionDistance;
HuntingGroundAnchor = huntingGroundAnchor;
IsViableTarget = isViableTarget;
Logger = loggerDelegate;
UseHotspots(null);
}
public UnderwaterLootingBehavior(LoggerDelegate loggerDelegate)
{
Logger = loggerDelegate;
}
public HuntingGroundBehavior(LoggerDelegate loggerDelegate,
ViableTargetsDelegate viableTargets,
WoWPoint huntingGroundAnchor,
double collectionDistance)
{
CollectionDistance = collectionDistance;
HuntingGroundAnchor = huntingGroundAnchor;
LogMessage = loggerDelegate;
ViableTargets = viableTargets;
UseHotspots(null);
}
internal void removeAllLoggers()
{
//LogMessage("All loggers removed", LogLevel.INFO);
this.allLogers = null;
}
// Start is called before the first frame update
void Start()
{
var inputTexture = new Texture2D(28, 28, TextureFormat.RFloat, false);
var outputTexture = new Texture2D(10, 1, TextureFormat.RFloat, false);
LoggerDelegate callback_delegate = new LoggerDelegate(CallBackFunction);
// Convert callback_delegate into a function pointer that can be
// used in unmanaged code.
System.IntPtr intptr_delegate =
Marshal.GetFunctionPointerForDelegate(callback_delegate);
setDebugFunction(intptr_delegate);
string path = @"C:\Users\a\Downloads\TensorRT-5.0.4.3.Windows10.x86_64.cuda-9.0.cudnn7.3\TensorRT-5.0.4.3\data\mnist\mnist.onnx";
Debug.Log(path);
Debug.Log(loadModel(path));
// Debug.Log(RegisterInputTexture(inputTexture.GetNativeTexturePtr()));
// Debug.Log(RegisterOutputTexture(outputTexture.GetNativeTexturePtr()));
Debug.Log(bindTextures(inputTexture.GetNativeTexturePtr(), outputTexture.GetNativeTexturePtr()));
Debug.Log(inferOnTextures());
float t = Time.realtimeSinceStartup;
for (int i = 0; i < 1000; i++)
{
inferOnTextures();
}
float dt = Time.realtimeSinceStartup - t;
Debug.Log((dt / 1000) * 1000);
Debug.Log(dispose());
}
