private static string GetHelp(AbstractParser parser)
{
if (parser != null && parser.CurrentOptions != null) {
return parser.CurrentOptions.Help();
}
return new DefaultOptions().Help();
}
public void ExistTable_TableExist_ReturnTrue()
{
AbstractParser xmlParser = CreateXMLParser();
Database testDatabase = ObjectConstructor.CreateDatabaseFull("test2");
xmlParser.SaveDatabase(testDatabase);
IEnumerator <ITable> enumerator = testDatabase.GetTableEnumerator();
if (enumerator.MoveNext())
{
Assert.IsTrue(xmlParser.ExistTable(testDatabase.databaseName, enumerator.Current.tableName));
}
else
{
Assert.Fail("there is no tables idiot!");
}
}
public Page(PageConfig pc) : this(pc.Url)
{
Template = TemplateFactory.GetInstance().GetExistingTemplate(pc.Template);
Parser = AbstractParser.NewInstance(Template.PageType);
RefreshDelay = pc.Refresh * 60; // convertir les minutes en secondes
Enabled = pc.Enabled;
IsNewBehavior = pc.IsNewBehavior;
if (string.IsNullOrEmpty(pc.Name) == false)
{
PageName = pc.Name;
}
else
{
PageName = Template.PageName;
}
}
private static async Task <List <T> > GetObjectListAsync <T>(string dataUrl, AbstractParser <T> parser)
{
var request = (HttpWebRequest)WebRequest.Create(dataUrl);
request.Method = "GET";
var response = await Task.Factory.FromAsync((callback, stateObject) => request.BeginGetResponse(callback, request), request.EndGetResponse, null);
using (var reader = new System.IO.StreamReader(response.GetResponseStream())) {
string responseText = reader.ReadToEnd();
var lines = responseText.Split(new string[] { System.Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
var objectList = parser.Parse(lines);
return(objectList);
}
}
/// <summary>
/// Caches the read.
/// </summary>
/// <param name="s">The s.</param>
/// <param name="asDictionaryKey">if set to <c>true</c> [as dictionary key].</param>
/// <param name="p">The p.</param>
/// <returns></returns>
public object CacheRead(string s, bool asDictionaryKey, AbstractParser p)
{
if (s.Length != 0)
{
if (CacheCode(s))
{
return cache[CodeToIndex(s)];
}
else if (WriteCache.IsCacheable(s, asDictionaryKey))
{
if (index == WriteCache.MaxCacheEntries)
{
Init();
}
return cache[index++] = (p != null ? p.ParseString(s) : s);
}
}
return p != null ? p.ParseString(s) : s;
}
/// <summary>
/// Caches the read.
/// </summary>
/// <param name="s">The s.</param>
/// <param name="asDictionaryKey">if set to <c>true</c> [as dictionary key].</param>
/// <param name="p">The p.</param>
/// <returns></returns>
public object CacheRead(string s, bool asDictionaryKey, AbstractParser p)
{
if (s.Length != 0)
{
if (CacheCode(s))
{
return(cache[CodeToIndex(s)]);
}
else if (WriteCache.IsCacheable(s, asDictionaryKey))
{
if (index == WriteCache.MaxCacheEntries)
{
Init();
}
return(cache[index++] = (p != null ? p.ParseString(s) : s));
}
}
return(p != null?p.ParseString(s) : s);
}
public void Start(OperationContext context)
{
HasStarted = true;
var task = runAsync();
Analysis.IgnoreArgument(task);
async Task runAsync()
{
try
{
IsRunningService = true;
foreach (var envVar in StartInfo.Environment)
{
Environment.SetEnvironmentVariable(envVar.Key, envVar.Value);
}
var args = AbstractParser.CommonSplitArgs(StartInfo.Arguments);
var exitCode = StartInfo.FileName.EndsWith("DepSvc.exe", StringComparison.OrdinalIgnoreCase)
? await RunDeploymentProxyWithCacheServiceAsync(args)
: await RunCacheServiceAsync(args);
Exit(exitCode);
}
catch (Exception ex)
{
Exit(-2);
Analysis.IgnoreArgument(ex);
}
finally
{
IsRunningService = false;
}
}
}
public object Representation(object obj)
{
return(AbstractParser.FormatDateTime((DateTime)obj));
}
private static Boolean ValidateScenario(string scenarioFile)
{
Regex schemaFileRegex = new Regex("SchemaLocation=\"(.*?)\"");
// First, find the schema file name in the scenario file;
//string dddClientDir = String.Format("\\\\{0}\\DDDClient", System.Environment.MachineName) + "\\";
string dddClientDir = "\\\\" + ServerOptions.DDDClientPath + "\\";// Path.GetDirectoryName(ServerOptions.ScenarioSchemaPath) + "\\";
//string dddClientDir = ServerOptions.ScenarioSchemaPath + "\\";
namedSchemaFile = "DDDSchema_4_0.xsd";//default setting
string oneLine;
try
{
StreamReader scenarioReader = new StreamReader(scenarioFile);
while ((oneLine = scenarioReader.ReadLine()) != null)
{
if (schemaFileRegex.IsMatch(oneLine))
{
Match m = schemaFileRegex.Match(oneLine);
namedSchemaFile = m.Groups[1].Value;
if (".xsd" != namedSchemaFile.Substring(namedSchemaFile.Length - 4).ToLower())
{
namedSchemaFile += ".xsd";
}
switch (namedSchemaFile)
{ //
case "DDDSchema_4_0.xsd":
parser = new Parser_4_0(); //DDD SP1
break;
case "DDDSchema_4_0_2.xsd":
parser = new Parser_4_0_2(); //DDD 4.0 SP2
break;
case "DDDSchema_4_1.xsd":
parser = new Parser_4_1();
break;
case "DDDSchema_4_1_1.xsd":
parser = new Parser_4_1();
break;
case "DDDSchema_4_2.xsd":
parser = new Parser_4_2();
break;
default:
System.Windows.Forms.MessageBox.Show("Unknown Schema File: " + namedSchemaFile);
throw new ApplicationException("Unknown schema file: " + namedSchemaFile);
}
scenarioReader.Close();
break;
}
}
}
catch (SystemException e)// only occurs for i/o errors, not for unfound schema name
{
System.Windows.Forms.MessageBox.Show("Error reading scenario file " + scenarioFile + ": " + e.Message);
throw new ApplicationException("Error reading scenario file " + scenarioFile, e);
}
/*
* at this point
* Have found the schema file (or there was none)
* Have used schema file to choose appropriate parser
*/
namedSchemaFile = dddClientDir + namedSchemaFile;
Boolean returnValue = true;
// Create the XmlNodeReader object.
XmlDocument doc = new XmlDocument();
doc.Load(scenarioFile);
XmlNodeReader nodeReader = new XmlNodeReader(doc);
// Set the validation settings.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas.Add(null, namedSchemaFile);//+".xsd");
settings.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler);
settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
// Create a validating reader that wraps the XmlNodeReader object.
XmlReader reader = XmlReader.Create(nodeReader, settings);
parser.SetReader(reader);
// Parse the XML file.
try
{
while (reader.Read())
{
;
}
}
catch (SystemException e)
{
returnValue = false;
System.Windows.Forms.MessageBox.Show("Error in XML Validation:\n"
+ " Scenario File: " + scenarioFile + "\n"
+ "Schema File : " + namedSchemaFile + "\n"
+ e.Message);
}
finally
{
nodeReader.Close();
reader.Close();
}
return(returnValue);
}
public void SplitArgsTests(string input, string[] expectedArgs)
{
var actualArgs = AbstractParser.CommonSplitArgs(input);
Assert.Equal(expectedArgs, actualArgs);
}
// public LoadService()
// {
//// this.textureFactory = textureFactory;
//// this.colorFactory = colorFactory;
// }
public void ParseFiles(Dictionary <string, byte[]> files, IEngine engine, SaveFlags saveFlags)
{
Reset();
var watch = Stopwatch.StartNew();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
LoadSystem(files);
}
// Step 2 (optional). Load up the Lua script
if ((saveFlags & SaveFlags.Code) == SaveFlags.Code)
{
//var scriptExtension = ".lua";
var paths = files.Keys.Where(s => textExtensions.Any(x => s.EndsWith(x))).ToList();
foreach (var fileName in paths)
{
parser = LoadScript(fileName, files[fileName]);
AddParser(parser);
}
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
// parser = LoadSystemColors(files);
// if (parser != null)
// AddParser(parser);
// Add the color parser
parser = LoadColors(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
// TODO this is a legacy parcer and should be depricated
parser = LoadColorMap(files);
if (parser != null)
{
AddParser(parser);
}
// // This will be the new parser moving forward
// parser = LoadColorPalette(files);
// if(parser != null)
// AddParser(parser);
// TODO need to rename SaveFlags.ColorMap to SaveFlags.ColorPalette
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
parser = LoadSprites(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.FlagColors) == SaveFlags.FlagColors)
{
LoadFlagColors(files);
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
LoadTilemap(files);
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var fontExtension = ".font.png";
var paths = files.Keys.Where(s => s.EndsWith(fontExtension)).ToArray();
foreach (var fileName in paths)
{
var fontName = fileName.Split('.')[0];
parser = LoadFont(fontName, files[fileName]);
if (parser != null)
{
AddParser(parser);
}
}
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
parser = LoadMetaData(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
LoadSounds(files);
// if (parser != null)
// AddParser(parser);
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
LoadMusic(files);
// if (parser != null)
// AddParser(parser);
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
LoadSaveData(files);
// if (parser != null)
// AddParser(parser);
}
totalParsers = parsers.Count;
currentParserID = 0;
watch.Stop();
// UnityEngine.Debug.Log("Parser Setup Time - " + watch.ElapsedMilliseconds);
}
private void Run(AbstractParser parser) => parser.Parse();
private void ParserThreadCallback()
{
while (!_tokenSource.Token.IsCancellationRequested)
{
//Check if the MRE has been set
if (!_mre.WaitOne(100))
{
continue;
}
if (!_queue.TryDequeue(out QueueData data))
{
_mre.Reset();
continue;
}
//The vertical bar is a pipe character. inputA | inputB = run command B with the output of command A
string[] inputs = data.Input.Split('|');
if (inputs.Length > 1)
{
//If we have a piped command, send it off to a new thread to be handled,
//As each command needs to be handled in order
Thread pipeThread = new Thread(() => PipeThreadCallback(inputs, data.Callback, data.Context));
pipeThread.Start();
_mre.Set();
continue;
}
string input = data.Input; //We don't lower the data because case sensitivity is an option for command matching
CommandMetadata metadata;
lock (_lock)
{
//Lock the metadata collection, and grab the first metadata that has a matching executor
List <CommandMetadata> metadatas = _metadata.Where(m => m.GetFirstOrDefaultExecutorData(input) != null).ToList();
metadata = metadatas.FirstOrDefault();
}
if (metadata == null)
{
data.Callback?.Invoke(InputResult.Unhandled, null);
//No command matches, so ignore this input
_mre.Set();
continue;
}
CommandExecutorData exeData = metadata.GetFirstOrDefaultExecutorData(input);
RegexString trigger = exeData.ExecutorAttribute.CommandMatcher;
input = trigger.RemoveMatchedString(input).TrimStart();
AbstractParser parser = _registry.GetParser(_registry, input, null, metadata, exeData, data.Context, data.Callback);
try
{
parser.Start();
}
finally
{
//Our job is done, so prepare for the next input
_mre.Set();
}
}
_mre.Dispose();
}
public void SetUp()
{
_parser = new Parser();
}
public virtual void ParseFiles(string[] files, IEngine engine, SaveFlags saveFlags)
{
Reset();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
LoadSystem(files);
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
// Add the color parser
parser = LoadColors(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
// TODO this is a legacy parcer and should be depricated
parser = LoadColorMap(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
parser = LoadSprites(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
LoadTilemap(files);
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var paths = files.Where(s => s.EndsWith(".font.png")).ToArray();
foreach (var fileName in paths)
{
// var fontName = GetFileName(fileName).Split('.').First();
var imageParser = new PNGFileReader(fileName, _fileLoadHelper, targetEngine.ColorChip.maskColor);
AddParser(new FontParser(imageParser, targetEngine.ColorChip, targetEngine.FontChip));
// parser = LoadFont(fontName, ReadAllBytes(fileName));
// if (parser != null)
// AddParser(parser);
}
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
parser = LoadMetaData(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
LoadSounds(files);
// Get all of the wav files
var wavFiles = files.Where(x => x.EndsWith(".wav")).ToArray();
if (wavFiles.Length > 0)
{
AddParser(new WavParser(wavFiles, _fileLoadHelper, targetEngine));
}
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
LoadMusic(files);
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
LoadSaveData(files);
}
// Step 12 (optional). Look for meta sprites
if ((saveFlags & SaveFlags.MetaSprites) == SaveFlags.MetaSprites)
{
LoadMetaSprites(files);
}
ParseExtraFileTypes(files, engine, saveFlags);
}
private void PageTypeSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
Workflow.PageTemplate.PageType = (string)PageTypeSelector.SelectedItem;
Parser = AbstractParser.NewInstance(Workflow.PageTemplate.PageType);
}
public ConnectionString(String origin)
{
_parser = new ParsersCascade(origin, Environment.GetEnvironmentVariables(EnvironmentVariableTarget.Process));
}
public LoginDialog()
{
this.InitializeComponent();
isLoginSuccessed = false;
parser = new AbstractParser();
}
