public void StructuredFileWriterXMLEncodeTest() { var writeFile = new StructuredFile { ID = "Write", FileName = Path.Combine(m_ApplicationDirectory, "StructuredFileOutputXML.txt"), SqlStatement = "Read", InOverview = true, JSONEncode = false }; var cols = DetermineColumnFormat.GetWriterSourceColumns(writeFile, CancellationToken.None); var sb = new StringBuilder(); sb.AppendLine("<?xml version=\"1.0\"?>\n"); sb.AppendLine("<rowset>"); writeFile.Header = sb.ToString(); sb.Clear(); sb.AppendLine(" <row>"); foreach (var col in cols) { sb.AppendFormat(" <{0}>{1}</{0}>\n", HTMLStyle.XmlElementName(col.Header), string.Format(System.Globalization.CultureInfo.InvariantCulture, StructuredFileWriter.cFieldPlaceholderByName, col.Header)); } sb.AppendLine(" </row>"); writeFile.Row = sb.ToString(); writeFile.Footer = "</rowset>"; var writer = new StructuredFileWriter(writeFile, CancellationToken.None); _ = writer.Write(); }
public void StructuredFileWriterJSONEncodeTest() { var writeFile = new StructuredFile { ID = "Write", FileName = Path.Combine(m_ApplicationDirectory, "StructuredFileOutputJSON.txt"), SqlStatement = "Read", InOverview = true, JSONEncode = true }; var cols = DetermineColumnFormat.GetWriterSourceColumns(writeFile, CancellationToken.None); writeFile.Header = "{\"rowset\":[\n"; var sb = new StringBuilder("{"); // { "firstName":"John", "lastName":"Doe"}, foreach (var col in cols) { sb.AppendFormat("\"{0}\":\"{1}\", ", HTMLStyle.JsonElementName(col.Header), string.Format(System.Globalization.CultureInfo.InvariantCulture, StructuredFileWriter.cFieldPlaceholderByName, col.Header)); } if (sb.Length > 1) { sb.Length -= 2; } sb.AppendLine("},"); writeFile.Row = sb.ToString(); var writer = new StructuredFileWriter(writeFile, CancellationToken.None); _ = writer.Write(); }
/// <summary> /// Create a new FullStrategy object from file /// Filename : contains path to file to load /// PatternFilename : contains path to pattern file to load /// </summary> public FullStrategy(string Filename, string PatternFilename) { if ((Filename == null) || (PatternFilename == null)) { throw(new Exception("Invalid Filename/PatternFilename")); } // Read files StructuredFile StrategyFile = new StructuredFile(Filename); StrategyFile.Parse(PatternFilename); // Store data into private data // Store PATTERN_STRATEGY_NAME _StrategyName = StrategyFile.GetValue("PATTERN_STRATEGY_NAME", "Undefined"); _DefaultSpeed = StrategyFile.GetValue("PATTERN_DEFAULT_SPEED", "50"); // Store initial cmd (setpos) EnumCmd CurrentCmd = Command.GetCmdFromString(StrategyFile.GetValue("PATTERN_INIT_CMD", "App_SetNewPos")); EnumCmdType CurrentCmdType = Command.GetCmdTypeFromString(StrategyFile.GetValue("PATTERN_INIT_CMD_TYPE", "NonBlocking")); String ParamX = StrategyFile.GetValue("PATTERN_INIT_POS_X", "0"); String ParamY = StrategyFile.GetValue("PATTERN_INIT_POS_Y", "0"); String ParamAngle = StrategyFile.GetValue("PATTERN_INIT_POS_ANGLE", "0.0"); EnumStrategyFlag ActiveSensors = Command.GetSensorsFlagFromString(StrategyFile.GetValue("PATTERN_INIT_ACTIVE_SENSORS", "APP_PARAM_APPFLAG_NONE")); _InitialCmd = new Command(CurrentCmd, CurrentCmdType, null, ParamX, ParamY, ParamAngle, ActiveSensors); // Read other items (Loops) // Try to read all loops for (int iLoop = 0; iLoop <= StrategyFile.GetMaxLoopID(); iLoop++) { for (int iCount = 0; iCount <= StrategyFile.GetMaxGID(iLoop); iCount++) { // Read ActionID and NextActionID int ActionID = StrategyFile.GetActionID(iLoop, iCount); int NextActionID = StrategyFile.GetNextActionID(iLoop, iCount); int TimeoutID = StrategyFile.GetTimeoutID(iLoop, iCount); // If current action is valid if (ActionID >= 0) { // Read command data from StratgeyFile Command ReadCommand = StrategyFile.GetCommand(iLoop, iCount); // If current command is valid, we store it if (ReadCommand != null) { // If current list is empty, we create it if (_Strategy == null) { _Strategy = new List <StrategyItem>(); } // Create new entry _Strategy.Add(new StrategyItem(ReadCommand, ActionID, NextActionID, TimeoutID)); } } } } }
public void StructuredFileTestCTOR() { var test = new StructuredFile(); Assert.IsTrue(string.IsNullOrEmpty(test.FileName)); var test2 = new StructuredFile("Hello"); Assert.AreEqual("Hello", test2.FileName); }
public void CsvFileCopyTo() { var test = new StructuredFile(); m_StructuredFile.CopyTo(test); m_StructuredFile.AllPropertiesEqual(test); // Test Properties that are not tested Assert.AreEqual(m_StructuredFile.Mapping.Count, test.Mapping.Count, "FieldMapping"); Assert.AreEqual(TrimmingOption.Unquoted, test.TrimmingOption, "TrimmingOption"); Assert.IsTrue(m_StructuredFile.Mapping.CollectionEqualWithOrder(test.Mapping), "Mapping"); Assert.IsTrue(m_StructuredFile.Column.CollectionEqualWithOrder(test.Column), "Column"); Assert.IsTrue(m_StructuredFile.FileFormat.Equals(test.FileFormat), "FileFormat"); Assert.IsTrue(test.Equals(m_StructuredFile), "Equals"); }
/// <summary> /// Sauvegarde des informations de la substrategy dans le fichier spécifié en paramètre /// </summary> /// <param name="fileName">Nom du fichier pour la sauvegarde</param> /// <returns>Retourne le nombre d'action sauvegardée, -1 en cas d'erreur</returns> public int Save(String fileName) { int Ret = -1; int counter = 0; StructuredFile outputFile = null; StructuredFileGroup groupToAdd = null; if (fileName != null) { // Création du fichier pour la sauvegarde (fichier sans pattern) outputFile = new StructuredFile(); // Création des objets globaux groupToAdd = new StructuredFileGroup(0); groupToAdd.AddKey(new StructuredFileKey("SubStrategyName", _subStrategyName)); groupToAdd.AddKey(new StructuredFileKey("SubStrategyID", _subStrategyID)); // Ajout des objets outputFile.AddGroup(groupToAdd); groupToAdd = null; // Création des objets relatifs aux RobotAction if (_actions != null) { foreach (RobotAction currentRobotAction in _actions) { // Creation du groupe pour stocker les données groupToAdd = currentRobotAction.Export(); // Ajout des données outputFile.AddGroup(groupToAdd); groupToAdd = null; counter = counter + 1; } } try { outputFile.SaveTo(fileName); Ret = counter; } catch (Exception ex) { Ret = -1; } } return(Ret); }
public void GetFileWriterTest() { var setting = new CsvFile { FileName = UnitTestInitializeCsv.GetTestPath("AlternateTextQualifiers.txt") }; var test = FunctionalDI.GetFileWriter(setting, new CustomProcessDisplay(UnitTestInitializeCsv.Token)); Assert.IsInstanceOfType(test, typeof(CsvFileWriter)); var setting2 = new StructuredFile { FileName = UnitTestInitializeCsv.GetTestPath("AlternateTextQualifiers.txt") }; var test2 = FunctionalDI.GetFileWriter(setting2, new CustomProcessDisplay(UnitTestInitializeCsv.Token)); Assert.IsInstanceOfType(test2, typeof(StructuredFileWriter)); }
public async Task StructuredFileWriterJSONEncodeTestAsync() { var writeFile = new StructuredFile { ID = "Write", FileName = "StructuredFileOutputJSON.txt", SqlStatement = c_ReadID, InOverview = true, JSONEncode = true }; var sb = new StringBuilder("{"); using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token)) { var cols = await DetermineColumnFormat.GetSqlColumnNamesAsync(writeFile.SqlStatement, writeFile.Timeout, processDisplay.CancellationToken); writeFile.Header = "{\"rowset\":[\n"; // { "firstName":"John", "lastName":"Doe"}, foreach (var col in cols) { sb.AppendFormat("\"{0}\":\"{1}\", ", HTMLStyle.JsonElementName(col), string.Format(CultureInfo.InvariantCulture, StructuredFileWriter.cFieldPlaceholderByName, col)); } if (sb.Length > 1) { sb.Length -= 2; } sb.AppendLine("},"); writeFile.Row = sb.ToString(); var writer = new StructuredFileWriter(writeFile, processDisplay); var result = await writer.WriteAsync(writeFile.SqlStatement, writeFile.Timeout, t => processDisplay.SetProcess(t, 0, true), processDisplay.CancellationToken); Assert.AreEqual(7L, result); } }
/// <summary> /// Function to export current strategy into extern file /// </summary> /// <param name="Filename">File to write</param> /// <param name="PatternFilename">Pattern to use for writting the file</param> /// <returns></returns> public bool WriteFile(string Filename, string PatternFilename) { bool Ret = false; List <StructuredFileKey> ExportFile = new List <StructuredFileKey>(); StructuredFile OutputStructuredFile = null; // First, we have to create the StrucuredFileKey in order to create a Strucutred File // Create items that are not included into Loop ExportFile.Add(new StructuredFileKey(-1, 0, "PATTERN_STRATEGY_NAME", _StrategyName)); ExportFile.Add(new StructuredFileKey(-1, 0, "PATTERN_DEFAULT_SPEED", _DefaultSpeed)); // Store initial cmd (setpos) ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_CMD", Command.GetCmdToString(_InitialCmd.Cmd))); ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_CMD_TYPE", Command.GetCmdTypeToString(_InitialCmd.CmdType))); ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_POS_X", _InitialCmd.Param2)); ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_POS_Y", _InitialCmd.Param3)); ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_POS_ANGLE", _InitialCmd.Param4)); ExportFile.Add(new StructuredFileKey(-1, 1, "PATTERN_INIT_ACTIVE_SENSORS", Command.GetSensorsFlagToString(_InitialCmd.ActiveSensors))); if (_Strategy != null) { // Create Loops foreach (StrategyItem Item in _Strategy) { ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_CMD", Command.GetCmdToString(Item.Cmd.Cmd))); ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_CMD_TYPE", Command.GetCmdTypeToString(Item.Cmd.CmdType))); ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_ACTIVE_SENSORS_FLAG", Command.GetSensorsFlagToString(Item.Cmd.ActiveSensors))); ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_PARAMS", Item.Cmd.ExportParamsIntoString())); ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_NEXT_ACTION_ID", Item.NextActionID.ToString())); ExportFile.Add(new StructuredFileKey(Item.LoopID, Item.GID, "PATTERN_TIMEOUT_ID", Item.TimeoutID.ToString())); } } OutputStructuredFile = new StructuredFile(ExportFile); OutputStructuredFile.WriteFile(Filename, PatternFilename); return(Ret); }
public async Task StructuredFileWriterXMLEncodeTest() { var writeFile = new StructuredFile { ID = "Write", FileName = "StructuredFileOutputXML.txt", SqlStatement = c_ReadID, InOverview = true, JSONEncode = false }; var sb = new StringBuilder(); using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token)) { var cols = await DetermineColumnFormat.GetSqlColumnNamesAsync(writeFile.SqlStatement, writeFile.Timeout, processDisplay.CancellationToken); sb.AppendLine("<?xml version=\"1.0\"?>\n"); sb.AppendLine("<rowset>"); writeFile.Header = sb.ToString(); sb.Clear(); sb.AppendLine(" <row>"); foreach (var col in cols) { sb.AppendFormat(" <{0}>{1}</{0}>\n", HTMLStyle.XmlElementName(col), string.Format(CultureInfo.InvariantCulture, StructuredFileWriter.cFieldPlaceholderByName, col)); } sb.AppendLine(" </row>"); writeFile.Row = sb.ToString(); writeFile.Footer = "</rowset>"; var writer = new StructuredFileWriter(writeFile, processDisplay); await writer.WriteAsync(writeFile.SqlStatement, writeFile.Timeout, null, processDisplay.CancellationToken); } }
/// <summary> /// Import a new strategy from an external file (given as parameter) /// </summary> /// <param name="inputFileName">filename of internal file</param> /// <param name="patternFileName">pattern file to use for the importation</param> /// <returns></returns> public int Import(String inputFileName, String patternFileName) { int Ret = -1; int patternLineIndex = 0; int importLineIndex = 0; int minLineIndex = 0; int nbLineToRemove = 0; int currentLineIndex = 0; int counter = 0; TextFile patternFile = new TextFile(); // Fichier pattern pour l'import des données TextFile fileToImport = new TextFile(); // Fichier à importer StructuredFile importFile = new StructuredFile(); // Fichier utiliser pour lire les données List <String> patternLoop = new List <string>(); // Pour stocker les lignes du pattern à repeter dans la rubrique LOOP String lineRead = ""; // Variable pour lire les données du fichier StructuredFileKey currentKey = null; try { // Verification des paramètres if ((inputFileName != null) && (patternFileName != null)) { // Lecture du fichier modele patternFile.Load(patternFileName); // Lecture du fichier à importer fileToImport.Load(inputFileName); // Si les fichiers sont valides, on les prépare pour les importer if ((patternFile.Count() > 0) && (fileToImport.Count() > 0)) { #region PreparationDesFichiers // Suppression des tabulations patternFile.ReplaceInFile("\t", ""); fileToImport.ReplaceInFile("\t", ""); // Suppression des lignes inutiles patternFile.RemoveEmptyLine(); fileToImport.RemoveEmptyLine(); // Mise en correspondance des fichiers // Recherche de l'index du début de boucle importLineIndex = fileToImport.GetFirstIndexLine(PrivateConst.subStrategyBeginTag, 0); patternLineIndex = patternFile.GetFirstIndexLine(PrivateConst.subStrategyBeginTag, 0); // Verification de la presence de la boucle dans les 2 fichiers if ((importLineIndex >= 0) && (patternLineIndex >= 0)) { // Lecture du minimum de ligne minLineIndex = Math.Min(importLineIndex, patternLineIndex); // Verification si un ecart existe dans le positionnement du tag de debut de boucle if (importLineIndex != patternLineIndex) { // Suppression des lignes en trop dans le fichier d'import nbLineToRemove = importLineIndex - minLineIndex; for (int i = 0; i < nbLineToRemove; i++) { fileToImport.RemoveLine(minLineIndex); } // Suppression des lignes en trop dans le fichier de modèle nbLineToRemove = patternLineIndex - minLineIndex; for (int i = 0; i < nbLineToRemove; i++) { patternFile.RemoveLine(minLineIndex); } } // Creation des boucles // 1 - Lecture des lignes du modèle do { // Lecture de la ligne lineRead = patternFile.GetLine(minLineIndex + 1); // Verification du contenu if ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyBeginTag) == false) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)) { patternLoop.Add(lineRead); // Ajout de la ligne courante patternFile.RemoveLine(minLineIndex + 1); } }while ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)); if (patternLoop.Count() > 0) { // 2 - Duplication des données du modele en fonction des données du fichier à importer currentLineIndex = minLineIndex + 1; // On se place au début de la boucle counter = 0; // Initialisation du compteur pour dupliquer le pattern do { // Lecture de la ligne lineRead = fileToImport.GetLine(currentLineIndex); if ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyBeginTag) == false) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)) { // Verification du compteur if (counter >= patternLoop.Count()) { counter = 0; } // Ajout de la ligne de pattern en conséquence patternFile.AddLine(patternLoop[counter], currentLineIndex); counter = counter + 1; } currentLineIndex = currentLineIndex + 1; }while ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)); } } // Ajout des lignes dans le fichier d'import si les tailles ne correspondent pas while (patternFile.Count() > fileToImport.Count()) { fileToImport.AddLine("EMPTY LINE"); } // Ajout des lignes dans le fichier pattern si les tailles ne correspondent pas while (fileToImport.Count() > patternFile.Count()) { patternFile.AddLine("EMPTY LINE"); } #endregion #region LectureDesDonnees // Ajout du fichier pattern importFile.SetPatternFile(patternFile); // Lecture du fichier importFile.Import(fileToImport); #endregion #region TraitementDesDonnees if (importFile.Count() > 0) { // Lecture des groupes un par un foreach (StructuredFileGroup currentGroup in importFile.GetAllGroup()) { // Lecture de la clé contenant le nom de la Stategy currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_SubStrategyName); // Si la clé courante fait partie d'une stratégie if (currentKey != null) { // Si le group actuel appartient à une stratégie, lecture du nom de la stratégie String subStrategyName = currentKey.valueString; RobotAction actionToImport = new RobotAction(); // Si il s'agit d'une action à ajouter à la stratégie if (actionToImport.Import(currentGroup) == true) { bool isAdded = false; for (int i = 0; i < _subStrategies.Count(); i++) { // Si la clé lue appartient à la stratégie courante, on l'ajoute if (subStrategyName == _subStrategies[i].Name) { _subStrategies[i].AddAction(actionToImport); isAdded = true; } } // Si la clé n'a pas été ajoutée, on l'ajoute if (isAdded == false) { int subStrategyID = Convert.ToInt32(Math.Floor(actionToImport.ID / 100.0)); SubStrategy subStrategyToAdd = new SubStrategy(subStrategyName, subStrategyID); subStrategyToAdd.AddAction(actionToImport); _subStrategies.Add(subStrategyToAdd); } } } else { // Sinon la clé est ajoutée aux variables globales de l'appli (si la clé est nécessaire) // Lecture du nom de la stratégie currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_StrategyName); if (currentKey != null) { _strategyName = currentKey.valueString; } // Variables pour la position initiale currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosX); if (currentKey != null) { _initialPos.param2 = currentKey.valueString; } currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosY); if (currentKey != null) { _initialPos.param3 = currentKey.valueString; } currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosA); if (currentKey != null) { _initialPos.param4 = currentKey.valueString; } // Valeur par défaut currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultSpeed); if (currentKey != null) { _defaultSpeed = currentKey.valueInt; } // Valeur par défaut currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultPivotSpeed); if (currentKey != null) { _defaultPivotSpeed = currentKey.valueInt; } } } } #endregion } } } catch (Exception ex) { _debugTool.WriteLine("Strategy Import() : " + ex.Message); Ret = -1; } return(Ret); }
/// <summary> /// Export current strategy into an external file (given as parameter) /// </summary> /// <param name="outputFileName">filename of output file</param> /// <param name="patternFileName">pattern file to use for the exportation</param> /// <returns></returns> public int Export(String outputFileName, String patternFileName) { int Ret = -1; int iLine = 0; // iterator bool loopSubStrategyPatternFlag = false; // Flag pour indiquer si la ligne en cours est une ligne de sub-stratégie pattern String currentLine = ""; // Ligne courrante (pour copie et/ou analyse) StructuredFile outputFile = new StructuredFile(); // Fichier de sortie TextFile patternFile = new TextFile(); // Fichier pattern TextFile outputPatternFile = new TextFile(); // Fichier pattern à utiliser pour écrire le fichier de sortie List <String> loopSubStrategyPattern = new List <string>(); // Lignes à répéter pour les subStratégies dans le fichier de sortie try { // Verification des paramètres d'entrée et des paramètres internes if ((outputFileName != null) && (patternFileName != null) && (_subStrategies != null)) { // Chargement du fichier model patternFile.Load(patternFileName); // Verification du fichier pattern et création du fichier réel de sortie if (patternFile.Count() > 0) { // On parcourt tout le fichier et on copie toutes les lignes qui n'appartiennent pas à boucle de stratégie for (iLine = 0; iLine < patternFile.Count(); iLine++) { // Lecture de la ligne currentLine = patternFile.GetLine(iLine); // Analyse de la ligne // Est-ce dans une boucle de lecture de pattern if (loopSubStrategyPatternFlag == true) { if (loopSubStrategyPatternFlag == true) { // A-t-on trouver le flag de fin de boucle if (currentLine.ToUpper().Contains(PrivateConst.subStrategyEndTag.ToUpper()) == true) { // La fin de boucle a été trouvée. On abaisse le flag loopSubStrategyPatternFlag = false; // On duplique le modèle en fonction des données en interne // Pour toutes les sub-stratégies for (int iSubStrategy = 0; iSubStrategy < _subStrategies.Count(); iSubStrategy++) { SubStrategy currentSubStrategy = _subStrategies[iSubStrategy]; // Export des données de la sous-stratégie for (int i = 0; i < currentSubStrategy.Count(); i++) { // Ecriture des infos de la stratégie foreach (String patternLineToAdd in loopSubStrategyPattern) { outputPatternFile.AddLine(patternLineToAdd); } } // Ecriture d'un saut de ligne pour la mise en page outputPatternFile.AddLine(""); } // On ajoute la Tag de fin de boucle outputPatternFile.AddLine(currentLine); } else { // Nous ajoutons la ligne courante au pattern loopSubStrategyPattern.Add(currentLine); } } } else { if (currentLine.ToUpper().Contains(PrivateConst.subStrategyBeginTag.ToUpper()) == true) { loopSubStrategyPatternFlag = true; } // Nous sommes en lecture normale, cette ligne sera copiée dans le fichier de pattern final outputPatternFile.AddLine(currentLine); } } } // Si le fichier pattern est prêt, nous écrivons les données dans le fichier de sortie if (outputPatternFile.Count() > 0) { StructuredFileGroup groupToAdd = null; // Creation des données génériques groupToAdd = new StructuredFileGroup(0); // Creation du groupe générique groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_StrategyName, _strategyName)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultSpeed, _defaultSpeed)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultPivotSpeed, _defaultPivotSpeed)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosX, _initialPos.param2)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosY, _initialPos.param3)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosA, _initialPos.param4)); // Ajout du groupe outputFile.AddGroup(groupToAdd); // Creation des données spécifiques if (_subStrategies.Count() > 0) { // Pour chaque sous stratégies foreach (SubStrategy currentSubStrategy in _subStrategies) { String currentSubStrategyName = currentSubStrategy.Name; if (currentSubStrategy.Count() > 0) { // Pour chacune des actions de la stratégie foreach (RobotAction currentAction in currentSubStrategy.GetAllActions()) { groupToAdd = currentAction.Export(); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_SubStrategyName, currentSubStrategyName)); outputFile.AddGroup(groupToAdd); } } } } // Ecriture du fichier final outputFile.SetPatternFile(outputPatternFile); outputFile.Export(outputFileName); // Sauvegarde des données Save(); } } } catch (Exception ex) { _debugTool.WriteLine("Strategy Export() : " + ex.Message); Ret = -1; } return(Ret); }
/// <summary> /// Charge les informations de la stratégie donnée en paramètre /// </summary> /// <param name="strategyName">Nom de la stratégie à chargée</param> public void Load(String strategyName) { try { String inputDir = Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir + strategyName + "/"; StructuredFile mainFile = new StructuredFile(); StructuredFileGroup currentGroup = null; StructuredFileKey currentKey = null; SubStrategy currentSubStrategy = null; // Verification du répertoire d'import if (Directory.Exists(inputDir) == true) { // Chargement des données générale mainFile.Load(inputDir + strategyName + ".strategy"); if (mainFile != null) { // Lecture des informations générales --------------------------------------------------------- // On ne charge les données que si le fichier de base est disponible currentGroup = mainFile.GetGroupByID(0); if (currentGroup != null) { // Chargement des données générale currentKey = currentGroup.GetFirstKey(PrivateConst.mainStrategyName); if (currentKey != null) { _strategyName = currentKey.valueString; } else { _strategyName = "NewStrategy"; } // InitPosX currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosX); if (currentKey != null) { _initialPos.param2 = currentKey.valueString; } else { _initialPos.param2 = "1500"; } // InitPosY currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosY); if (currentKey != null) { _initialPos.param3 = currentKey.valueString; } else { _initialPos.param3 = "1000"; } // InitPosA currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosA); if (currentKey != null) { _initialPos.param4 = currentKey.valueString; } else { _initialPos.param4 = "0"; } // DefaultSpeed currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultSpeed); if (currentKey != null) { _defaultSpeed = currentKey.valueInt; } else { _defaultSpeed = 50; } // DefaultPivotSpeed currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultPivotSpeed); if (currentKey != null) { _defaultPivotSpeed = currentKey.valueInt; } else { _defaultPivotSpeed = 50; } } // Lecture des sous-stratégies ---------------------------------------------------------------- // Récupération des noms de fichier IEnumerable <String> inputFiles = Directory.EnumerateFiles(inputDir, "*.sfile"); foreach (String currentFile in inputFiles) { // Chargement du fichier currentSubStrategy = new SubStrategy("NewSubStrategy", 1); currentSubStrategy.Load(currentFile, -1); if (currentSubStrategy.Name == PrivateConst.mainStrategyName) { _subStrategies[0] = currentSubStrategy; } else { _subStrategies.Add(currentSubStrategy); } } } } else { _debugTool.WriteLine("Strategy.cs = Directory '" + strategyName + "' not found !"); } } catch (Exception ex) { _debugTool.WriteLine("Strategy.cs = " + ex.Message); } }
/// <summary> /// Crée un dossier ayant le nom de la stratégie dans le dossier "Data" à coté de l'executable /// La stratégie principale + toutes les sous-stratégies sont exportées dans des fichiers indépendants /// ATTENTION : Si le sous dossier existe déjà, il est détruit et remplacé par la sauvegarde courante (sans confirmation) /// </summary> public void Save() { // Verification des données internes if ((_strategyName != null) && (_subStrategies != null)) { try { String outputDir = Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir + _strategyName + "/"; // Verification du répertoire de sortie if (Directory.Exists(Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir) != true) { // Si le dossier n'existe pas, il faut le créer Directory.CreateDirectory(Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir); } // Verification du sous répertoire de sortie if (Directory.Exists(outputDir) == true) { // Si le dossier existe, il faut le vider Directory.Delete(outputDir, true); } while (Directory.Exists(outputDir) == true) { Thread.Sleep(500); } // Creation du répertoire de sortie while (Directory.Exists(outputDir) == false) { Thread.Sleep(1000); Directory.CreateDirectory(outputDir); } // Sauvegarde des informations générales StructuredFile mainFile = new StructuredFile(); StructuredFileGroup mainGroup = new StructuredFileGroup(0); mainGroup.AddKey(new StructuredFileKey(PrivateConst.mainStrategyName, _strategyName)); mainGroup.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosX, _initialPos.param2)); mainGroup.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosY, _initialPos.param3)); mainGroup.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosA, _initialPos.param4)); mainGroup.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultSpeed, _defaultSpeed)); mainGroup.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultPivotSpeed, _defaultPivotSpeed)); mainFile.AddGroup(mainGroup); mainFile.SaveTo(outputDir + _strategyName + ".strategy"); mainFile = null; mainGroup = null; // Sauvegarde des sub-stratégies foreach (SubStrategy currentSubStrategy in _subStrategies) { currentSubStrategy.Save(outputDir + currentSubStrategy.Name + ".sfile"); // Verification du répertoire d'import if (Directory.Exists(Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir) != true) { // Si le dossier n'existe pas, il faut le créer Directory.CreateDirectory(Directory.GetCurrentDirectory().ToString() + "/" + PrivateConst.outputDir); } } } catch (Exception ex) { MessageBox.Show("Erreur d'écriture de la stratégie !", "Strategy Generator", MessageBoxButtons.OK, MessageBoxIcon.Error); _debugTool.WriteLine("Strategy.cs = " + ex.Message); } } }
static void Main(string[] args) { // ############################################################################################################################ // ##### TextFile // ############################################################################################################################ #region TexteFile //Declaration des variables TextFile textFileFromFile = null; // Fichier permettant de lire un fichier depuis le disque TextFile newTextFile = null; // Fichier pour tester l'ajout et la suppression de ligne bool Validated = true; // Test 0101 : Creation d'un fichier texte __________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0101 - Creation et chargement d'un fichier texte : \n"); Console.WriteLine(" -> Creation du fichier"); textFileFromFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement du fichier de test :"); if (textFileFromFile.Load("TestFiles/Test_Load.txt") >= 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement du fichier vide : "); if (textFileFromFile.Load("TestFiles/Test_EmptyFile.txt") >= 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Tentative d'ouverture d'un fichier inexistant : "); if (textFileFromFile.Load("InvalidFile") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> FilePath vide : "); if (textFileFromFile.Load("") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 100 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_100Lines.txt") == 100) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 1000 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_1000Lines.txt") == 1000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 10000 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_10000Lines.txt") == 10000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0101 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0102 : Verification des propriétés __________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0102 - Test des priorités : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier vide :"); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier normal (100 Lignes) :"); newTextFile.Load("TestFiles/Test_100Lines.txt"); if (newTextFile.Count() == 100) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier normal (1000 Lignes) :"); newTextFile.Load("TestFiles/Test_1000Lines.txt"); if (newTextFile.Count() == 1000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0102 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0103 : Ajout de ligne _______________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0103 - Ajout de nouvelle ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne dans un fichier vide:"); newTextFile.AddLine("Ligne 01"); if (newTextFile.Count() == 1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne vide :"); newTextFile.AddLine(null); if (newTextFile.Count() == 1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne sans contenu :"); newTextFile.AddLine(""); if (newTextFile.Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne avec un index erroné :"); newTextFile.AddLine("Ligne -1", -1); if (newTextFile.Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne à un index spécifié :"); newTextFile.AddLine("Ligne 00", 0); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne null à un index spécifié :"); newTextFile.AddLine(null, 0); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne à un index erroné :"); newTextFile.AddLine(null, -1); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0103 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0104 : Récupération d'une ligne _____________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0104 - Lecture d'une ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne dans un fichier vide:"); if (newTextFile.GetLine(0) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne avec un index négatif :"); newTextFile.AddLine("Ligne 01"); newTextFile.AddLine("Ligne 02"); newTextFile.AddLine("Ligne 03"); if (newTextFile.GetLine(-1) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne avec un index erroné :"); if (newTextFile.GetLine(100) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne valide :"); if (newTextFile.GetLine(0) == "Ligne 01") { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture de la dernière ligne du fichier :"); if (newTextFile.GetLine(2) == "Ligne 03") { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0104 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0105 : Sauvegarde du fichier ________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0105 - Sauvegarde des fichiers : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier non initialisé :"); if (newTextFile.Save() == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier null :"); if (newTextFile.SaveTo(null) == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier non valide :"); if (newTextFile.SaveTo("Invalid") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde dans un fichier valide :"); newTextFile.Load("TestFiles/Test_100Lines.txt"); if (newTextFile.SaveTo("TestFiles/Test_100Lines_ouptut_SaveTo.txt") == 100) { Console.Write(" Ok + Verification manuelle à réaliser\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier valide :"); newTextFile.SaveTo("TestFiles/Test_100Lines_ouptut_Save.txt"); if (newTextFile.Save() == 100) { Console.Write(" Ok + Verification manuelle à réaliser\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0105 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0106 : Caractère spéciaux ___________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0106 - Utilisation de caractères spéciaux : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); String textToCheck = "\t&@éèàûîêäëïç'§µ%"; newTextFile.AddLine(textToCheck); // ------------------------------------------------------------------------------------------ Console.Write(" -> Ecriture du fichier :"); if (newTextFile.SaveTo("TestFiles/SpecificChar.txt") > 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Relecture du fichier :"); newTextFile.Load("TestFiles/SpecificChar.txt"); if (newTextFile.GetLine(0) == textToCheck) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0106 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0107 : Suppression d'une ligne ______________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0107 - Suppression d'une ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne dans un fichier vide :"); newTextFile.RemoveLine(0); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne non valide :"); newTextFile.RemoveLine(-1); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne dans un fichier :"); newTextFile.AddLine("Ligne01"); newTextFile.AddLine("Ligne02"); newTextFile.AddLine("Ligne03"); newTextFile.RemoveLine(0); if ((newTextFile.Count() == 2) && (newTextFile.GetLine(0) == "Ligne02")) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression de toutes les lignes d'un fichier :"); newTextFile.AddLine("Ligne01"); newTextFile.AddLine("Ligne02"); newTextFile.AddLine("Ligne03"); newTextFile.RemoveAllLine(); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0107 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFileKey // ############################################################################################################################ #region StructuredFileKey StructuredFileKey testKey = null; // Test 0201 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0201 - StructuredFileKey : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testKey = new StructuredFileKey(); if ((null != testKey) && (testKey.keyName == null) && (testKey.valueString == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyString', 'valueString') :"); testKey = new StructuredFileKey("keyString", "valueString"); if ((null != testKey) && (testKey.keyName == "keyString") && (testKey.valueString == "valueString")) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyInt', 100) :"); testKey = new StructuredFileKey("keyInt", 100); if ((null != testKey) && (testKey.keyName == "keyInt") && (testKey.valueInt == 100)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyDouble', 1.2) :"); testKey = new StructuredFileKey("keyDouble", 1.2); if ((null != testKey) && (testKey.keyName == "keyDouble") && (testKey.valueDouble == 1.2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0201 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFileGroup // ############################################################################################################################ #region StructuredFileGroup StructuredFileGroup testKeyGroup = null; StructuredFileGroup testKeyGroup1 = null; StructuredFileGroup testKeyGroup2 = null; // Test 0301 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0301 - StructuredFileGroup : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testKeyGroup = new StructuredFileGroup(0); if ((testKeyGroup.ID == 0) && (testKeyGroup.GetAllKeys() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres (groupID = 0 et key = null) :"); testKeyGroup = new StructuredFileGroup(0, null); if ((testKeyGroup.ID == 0) && (testKeyGroup.GetAllKeys() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres (groupID=0 et key=(TestKey, TestValue) :"); testKeyGroup = new StructuredFileGroup(5, new StructuredFileKey("TestKey", "TestValue")); if ((testKeyGroup.ID == 5) && (testKeyGroup.GetAllKeys().Count == 1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Add() :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("1", "1")); testKeyGroup.AddKey(new StructuredFileKey("2", "2")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetAllKeys().Count == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Add(List<>) :"); testKeyGroup = new StructuredFileGroup(1); List <StructuredFileKey> listToAdd = new List <StructuredFileKey>(); listToAdd.Add(new StructuredFileKey("1", "1")); listToAdd.Add(new StructuredFileKey("2", "2")); testKeyGroup.AddKey(listToAdd); if ((testKeyGroup.ID == 1) && (testKeyGroup.Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Count() :"); testKeyGroup = new StructuredFileGroup(1, null); testKeyGroup1 = new StructuredFileGroup(1, new StructuredFileKey("Key1", "Value1")); testKeyGroup2 = new StructuredFileGroup(2, new StructuredFileKey("Key1", "Value1")); testKeyGroup2.AddKey(new StructuredFileKey("Key2", "Value2")); if ((testKeyGroup.Count() == 0) && (testKeyGroup1.Count() == 1) && (testKeyGroup2.Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction GetAllKeys() :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("Key1", "Value1")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value2")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetAllKeys().Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction GetKeys(keyID) :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("Key1", "Value1")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value2")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value22")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetKeys("Key3") == null) && (testKeyGroup.GetKeys("Key2").Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0301 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFile // ############################################################################################################################ #region StructuredFile StructuredFile testStructuredFile = null; StructuredFile testStructuredFile2 = null; // Test 0401 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0401 - Constructeurs : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testStructuredFile = new StructuredFile(); if (null != testStructuredFile) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur avec paramètre :"); testStructuredFile = new StructuredFile("CheminInvalid"); if (null != testStructuredFile) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction GetAllGroupID vide :"); testStructuredFile = new StructuredFile(); if (testStructuredFile.GetAllGroup() == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction d'ajout :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(null); testStructuredFile2.AddGroup(new StructuredFileGroup(1, new StructuredFileKey("Key1", 1))); testStructuredFile2.AddGroup(new StructuredFileGroup(1, new StructuredFileKey("Key2", 2))); testStructuredFile2.AddGroup(new StructuredFileGroup(2, new StructuredFileKey("Key3", 3))); if ((testStructuredFile.GetAllGroup().Count() == 1) && (testStructuredFile.GetAllGroup().Count() == 1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de suppression totale :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); testStructuredFile.RemoveAllGroup(); testStructuredFile2.RemoveAllGroup(); if ((testStructuredFile.GetAllGroup() == null) && (testStructuredFile2.GetAllGroup() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de suppression à partir de l'ID :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); testStructuredFile.RemoveGroupByID(2); testStructuredFile.RemoveGroupByID(5); testStructuredFile2.RemoveGroupByID(5); if (testStructuredFile.GetAllGroup().Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de recherche à partir de l'ID :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); if ((testStructuredFile2.GetGroupByID(5) == null) && (testStructuredFile.GetGroupByID(5) == null) && (testStructuredFile.GetGroupByID(2).ID == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ecriture du fichier via SaveTo (format par défaut) :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); StructuredFileGroup newGroup = new StructuredFileGroup(2, new StructuredFileKey("Key1", 1)); newGroup.AddKey(new StructuredFileKey("Key2", 2)); newGroup.AddKey(new StructuredFileKey("Key3", 3)); testStructuredFile.AddGroup(newGroup); testStructuredFile.AddGroup(new StructuredFileGroup(3, new StructuredFileKey("Key1", 10))); if ((testStructuredFile.SaveTo("TestFiles/StructuredFile.sfile") > 0) && (testStructuredFile2.SaveTo("TestFiles/StructuredFileErr.sfile") == -1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Ecriture du fichier via Save (format par défaut) :"); if ((testStructuredFile.Save() > 0) && (testStructuredFile2.Save() == -1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'un fichier :"); newTextFile = new TextFile(); newTextFile.AddLine("key1 = A"); newTextFile.AddLine("key2 = B"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("key3 = C"); newTextFile.AddLine("key4 = D"); newTextFile.AddLine("key5 E"); newTextFile.AddLine("key6 = F"); newTextFile.AddLine("key7 = G"); newTextFile.AddLine("key8 = H"); newTextFile.AddLine("key9 = I"); newTextFile.AddLine(" "); newTextFile.AddLine("key10 = J"); newTextFile.AddLine("[Groupe A]"); newTextFile.AddLine("key11 = K"); newTextFile.AddLine("key12 = L"); newTextFile.AddLine("[ Groupe 5]"); newTextFile.AddLine("[Groupe 7]"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("key13 = M"); testStructuredFile = new StructuredFile(); if ((testStructuredFile.Load(newTextFile) > 0) && (testStructuredFile.SaveTo("TestFiles/StructuredFile2.sfile") > 0)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Export d'un fichier :"); newTextFile = new TextFile(); newTextFile.AddLine("[Groupe 0]"); newTextFile.AddLine("Key1 = (0,1)"); newTextFile.AddLine("Key2 = (0,2)"); newTextFile.AddLine("[Groupe 2]"); newTextFile.AddLine("Key1 = (2,1)"); newTextFile.AddLine("Key2 = (2,2)"); newTextFile.AddLine("[Groupe 3]"); newTextFile.AddLine("Key1 = (3,1)"); newTextFile.AddLine("Key2 = (3,2)"); newTextFile.AddLine("[Groupe 1]"); newTextFile.AddLine("Var1 = Var1-1"); newTextFile.AddLine("Var2 = Var2-1"); newTextFile.AddLine("Var3 = Var3-1"); newTextFile.AddLine("Var4 = Var4-1"); newTextFile.AddLine("Var5 = Var5-1"); newTextFile.AddLine("[Groupe 2]"); newTextFile.AddLine("Var1 = Var1-2"); newTextFile.AddLine("Var2 = Var2-2"); newTextFile.AddLine("Var3 = Var3-2"); newTextFile.AddLine("Var4 = Var4-2"); newTextFile.AddLine("Var5 = Var5-2"); newTextFile.AddLine("[Groupe 3]"); newTextFile.AddLine("Var1 = Var1-3"); newTextFile.AddLine("Var2 = Var2-3"); newTextFile.AddLine("Var3 = Var3-3"); newTextFile.AddLine("Var4 = Var4-3"); newTextFile.AddLine("Var5 = Var5-3"); newTextFile.AddLine("[Groupe 4]"); newTextFile.AddLine("Var1 = Var1-4"); newTextFile.AddLine("Var2 = Var2-4"); newTextFile.AddLine("Var3 = Var3-4"); newTextFile.AddLine("Var4 = Var4-4"); newTextFile.AddLine("Var5 = Var5-4"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("Var1 = Var1-5"); newTextFile.AddLine("Var2 = Var2-5"); newTextFile.AddLine("Var3 = Var3-5"); newTextFile.AddLine("Var4 = Var4-5"); newTextFile.AddLine("Var5 = Var5-5"); testStructuredFile = new StructuredFile(); testStructuredFile.Load(newTextFile); testStructuredFile.SetPatternFile("TestFiles/ExportPatternFile.pattern"); if (testStructuredFile.Export("TestFiles/ExportPatternFile.output") == 6) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Import d'un fichier :"); testStructuredFile = new StructuredFile(); testStructuredFile.SetPatternFile("TestFiles/ImportPatternFile.pattern"); if ((testStructuredFile.Import("TestFiles/ImportFile.txt") > 0) && (testStructuredFile.SaveTo("TestFiles/ImportFile.sfile") > 0)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0401 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // Fin du programme ----------------------------------------------------------------------------- DisplaySeparator(); Console.Write("\nTest terminé. Etat du module : "); if (Validated == true) { Console.Write("Validé ! \n(Sous réserve que les fichiers de sortie soit valides)\n"); } else { Console.Write("Invalide !\n"); } Console.Read(); }
/// <summary> /// Charge les informations de la substrategy à partir du fichier spécifié en paramètre /// Le chargement d'un fichier détruit toutes les données précédemment sauvegardée /// </summary> /// <param name="filename">Nom du fichier pour charger le fichier</param> /// <param name="forcedID">ID à utiliser à la place de l'ID du fichier</param> /// <returns>Retourne le nombre d'action chargée, -1 en cas d'erreur</returns> public int Load(String filename, int forcedID) { int Ret = -1; StructuredFile inputFile = new StructuredFile(); StructuredFileGroup globalGroup = null; List <StructuredFileGroup> actionsGroup = null; StructuredFileKey currentKey = null; RobotAction currentAction = null; if (filename != null) { // Ouverture du fichier inputFile.Load(filename); // Destruction des données actuelles _subStrategyName = "Not Set"; _actions = null; // Chargement des données génériques globalGroup = inputFile.GetGroupByID(0); if (globalGroup != null) { currentKey = globalGroup.GetFirstKey("SubStrategyName"); if (currentKey != null) { _subStrategyName = currentKey.valueString; } if (forcedID > 0) { // Un ID a été imposé, nous l'utilisons _subStrategyID = forcedID; } else { // Nous utilisons l'ID du fichier currentKey = globalGroup.GetFirstKey("SubStrategyID"); if (currentKey != null) { _subStrategyID = currentKey.valueInt; } } } // Chargement des données liées aux actions actionsGroup = inputFile.GetAllGroup(); if (actionsGroup != null) { Ret = 0; // Lecture de tous les groupes pour extraire les données liées aux actions foreach (StructuredFileGroup currentGroup in actionsGroup) { // Nous ne devons extraire que les données des groupes > à 0 if (currentGroup.ID > 0) { currentAction = new RobotAction(); currentAction.Import(currentGroup); // On ajoute l'objet que l'on vient d'importer s'il est valide if (currentAction.cmd != EnumCmd.NotSet) { if (_actions == null) { _actions = new List <RobotAction>(); } // Verification des ID currentAction.ID = CheckID(currentAction.ID); currentAction.nextID = CheckLinkID(currentAction.nextID); currentAction.timeoutID = CheckLinkID(currentAction.timeoutID); _actions.Add(currentAction); Ret = Ret + 1; } } } } } SortRobotActions(); return(Ret); }