public StructuredFile(String patternFileName)
{
_debugTool = new DebugTool(DebugTool.EDebugToolType.Disabled);
_group = null;
_patternFile = new TextFile();
if (_patternFile.Load(patternFileName) <= 0)
{
_debugTool.WriteLine("StructuredFile = Invalid patternFile");
_patternFile = null;
}
}
// Properties -----------------------------------------------------------------------------
// Public ---------------------------------------------------------------------------------
/// <summary>
/// Fonction pour charger un fichier pattern pour l'import ou l'export des données
/// </summary>
/// <param name="patternFileName">Nom du fichier modèle</param>
/// <returns>Le nombre de lignes lues (-1 en cas d'erreur)</returns>
public int SetPatternFile(String patternFileName)
{
int Ret = -1;
TextFile fileToLoad = null;
// Desallocation des données déjà chargées
if (_patternFile != null)
{
_patternFile.RemoveAllLine();
_patternFile = null;
}
if (patternFileName != null)
{
// Lecture du fichier pattern
fileToLoad = new TextFile();
fileToLoad.Load(patternFileName);
Ret = SetPatternFile(fileToLoad);
}
return(Ret);
}
/// <summary>
/// Exporte tous les groupes définis dans le fichier en suivant le pattern file précédemment défini
/// </summary>
/// <param name="fileName">Nom du fichier pour l'export</param>
/// <returns>Nombre de groupe ecrit (-1 en cas d'erreur)</returns>
public int Export(String fileName)
{
int Ret = -1;
TextFile outputFile = new TextFile();
List <String> outputBuffer = new List <string>();
int currentGroupIndex = -1; // Index du groupe pour le remplacement des gID
int indexInLine = -1; // Index pour parser les différentes lignes
String flagToCheck = null; // Permet l'analyse du tag
// Verification des params d'entrée
if (fileName != null)
{
// Verification des paramètres internes
if ((_patternFile != null) && (_group != null))
{
// Récupération du fichier pattern
for (int i = 0; i < _patternFile.Count(); i++)
{
outputBuffer.Add(_patternFile.GetLine(i));
}
// Lecture de tout le fichier pour remplacer les Tags 'gID' par l'identifiant du groupe
for (int i = 0; i < outputBuffer.Count(); i++)
{
// Permet d'initialiser la position de l'index pour la recherche par ligne
indexInLine = 0;
// Recherche sur la ligne de tous les Tags 'gID'
do
{
// Recherche de l'index dans la portion de la ligne (à chaque passage on se décale sur la ligne)
indexInLine = outputBuffer[i].IndexOf("gID", indexInLine);
if (indexInLine > 1) // Il y a dans tous les cas un caractère avant le Tag gID
{
// Analyse du tag pour connaitre le type ('gID ou @gID)
flagToCheck = outputBuffer[i].Substring(indexInLine - 1, 4);
if (flagToCheck == "'gID") // Il s'agit d'un flag de groupe, il faut changer de groupe
{
currentGroupIndex = GetNextGroupIndex(currentGroupIndex); // On change de groupe
if (currentGroupIndex >= 0) // On verifie que le groupe est valide
{
outputBuffer[i] = outputBuffer[i].Substring(0, indexInLine - 1) + _group[currentGroupIndex].ID.ToString() + outputBuffer[i].Substring(indexInLine + 4);
}
}
if ((flagToCheck == "@gID") && (currentGroupIndex >= 0)) // Il s'agit d'un flag à remplacer et le groupe est valide
{
// On remplace ce gID avec la valeur du groupe actuel
outputBuffer[i] = outputBuffer[i].Substring(0, indexInLine) + _group[currentGroupIndex].ID.ToString() + outputBuffer[i].Substring(indexInLine + 3);
}
}
} while ((indexInLine >= 0) && (currentGroupIndex > 0));
}
// Export des données du groupe pour toutes les lignes du fichier
for (int i = 0; i < outputBuffer.Count(); i++)
{
// On verifie si la ligne doit être traitée (présence du caractère @)
if (outputBuffer[i].Contains("@") == true)
{
// On parcourt toute la liste des groupes
foreach (StructuredFileGroup currentGroup in _group)
{
// On verifie si la ligne contient des données du groupe
if (outputBuffer[i].Contains("@" + currentGroup.ID.ToString()) == true)
{
// On parcourt toutes les clées
foreach (StructuredFileKey currentKey in currentGroup.GetAllKeys())
{
outputBuffer[i] = outputBuffer[i].Replace("'" + currentKey.keyName + "@" + currentGroup.ID.ToString() + "'", currentKey.valueString);
}
}
}
}
// Ecriture de la ligne dans le fichier de sortie
outputFile.AddLine(outputBuffer[i]);
}
// Ecriture du fichier final
outputFile.SaveTo(fileName);
Ret = _group.Count();
}
}
return(Ret);
}
/// <summary>
/// Charge un fichier structuré à partir d'un fichier texte
/// </summary>
/// <param name="fileName">Fichier à charger</param>
/// <returns>Le nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Load(TextFile fileToLoad)
{
int Ret = -1;
int currentIndex = 0;
String currentLine = null;
String parsedLine = null;
String currentKeyName = null;
String currentKeyValue = null;
uint currentGroupID = 0;
StructuredFileGroup currentGroup = null;
List <StructuredFileGroup> groupToAdd = null;
// Verification des params d'entrée
if (fileToLoad != null)
{
// Lecture du fichier ligne à ligne
for (int i = 0; i < fileToLoad.Count(); i++)
{
currentLine = fileToLoad.GetLine(i);
if (currentLine != null)
{
// Analyse de la ligne lue
// Est-ce une ligne d'entête
if (currentLine.Contains(DefaultPatternTag.HeaderBegin) == true)
{
// Si jamais il y a déjà un groupe en cours de traitement, on l'ajoute à la liste
if (currentGroup != null)
{
if (groupToAdd == null)
{
groupToAdd = new List <StructuredFileGroup>();
}
groupToAdd.Add(currentGroup);
currentGroup = null;
}
// C'est une ligne d'entête, il faut la parser pour récupérer le numéro de groupe
// Suppression de la balise d'entête
parsedLine = currentLine;
if (DefaultPatternTag.HeaderBegin.Length > 0)
{
parsedLine = parsedLine.Replace(DefaultPatternTag.HeaderBegin, "");
}
if (DefaultPatternTag.HeaderEnd.Length > 0)
{
parsedLine = parsedLine.Replace(DefaultPatternTag.HeaderEnd, "");
}
// On essaye de lire le numéro du groupe
try
{
currentGroupID = Convert.ToUInt32(parsedLine);
}
catch (Exception)
{
currentGroupID = 0;
}
currentGroup = new StructuredFileGroup(currentGroupID);
}
else
{
// C'est une ligne à analyser
// Verification si la ligne est valable (si elle est non valable, elle est non traitée)
if (currentLine.Contains(DefaultPatternTag.LineBegin) && currentLine.Contains(DefaultPatternTag.LineSeparator) && currentLine.Contains(DefaultPatternTag.LineEnd))
{
// La ligne est valide, on la traite
// On supprime les entete et les fin de ligne
parsedLine = currentLine;
if (DefaultPatternTag.LineBegin.Length > 0)
{
parsedLine = currentLine.Replace(DefaultPatternTag.LineBegin, "");
}
if (DefaultPatternTag.LineEnd.Length > 0)
{
parsedLine = parsedLine.Replace(DefaultPatternTag.LineEnd, "");
}
// Récupération des noms de chaines et valeurs
currentIndex = parsedLine.IndexOf(DefaultPatternTag.LineSeparator);
currentKeyName = parsedLine.Substring(0, currentIndex);
currentKeyValue = parsedLine.Substring(currentIndex + DefaultPatternTag.LineSeparator.Length);
// Ajout de la clé considérée
if (currentGroup == null)
{
currentGroup = new StructuredFileGroup(0);
}
currentGroup.AddKey(new StructuredFileKey(currentKeyName, currentKeyValue));
}
}
}
}
// On ajoute le tout dernier groupe
if (currentGroup != null)
{
if (groupToAdd == null)
{
groupToAdd = new List <StructuredFileGroup>();
}
groupToAdd.Add(currentGroup);
currentGroup = null;
}
if (groupToAdd != null)
{
// On ajoute tous les groupes que l'on vient de charger dans le fichier final
foreach (StructuredFileGroup tmpGroup in groupToAdd)
{
this.AddGroup(tmpGroup);
}
Ret = groupToAdd.Count();
}
}
return(Ret);
}
/// <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>
/// Fonction pour charger un fichier pattern pour l'import ou l'export des données
/// </summary>
/// <param name="newPatternFile">FIchier pattern à charger</param>
/// <returns>Le nombre de lignes lues (-1 en cas d'erreur)</returns>
public int SetPatternFile(TextFile newPatternFile)
{
int Ret = -1;
// Desallocation des données déjà chargées
if (_patternFile != null)
{
_patternFile.RemoveAllLine();
_patternFile = null;
}
if (newPatternFile != null)
{
_patternFile = newPatternFile;
Ret = _patternFile.Count();
}
return Ret;
}
/// <summary>
/// Charge les données à partir d'un fichier de type 'TextFile'
/// ATTENTION, le pattern de fichier pour la lecture doit être définie avant d'appeler cette fonction
/// </summary>
/// <param name="inputFile">Fichier à importer</param>
/// <returns>Nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Import(TextFile inputFile)
{
int Ret = -1;
int iCurrentIndex = -1;
List<String> inputBuffer = new List<string>();
List<String> patternBuffer = new List<string>();
string[] splitLinePattern = null;
string[] patternSeparator = new string[1];
String currentFullKey = null;
String currentValueKey = null;
String currentGroupID = "0";
// Verification des params d'entrée
if (inputFile != null)
{
// Verification des paramètres internes
if (_patternFile != null)
{
// Comparaison des tailles de fichier
if (inputFile.Count() == _patternFile.Count())
{
// Comparaison des fichiers lignes à lignes, les lignes identiques sont supprimées, les lignes différentes sont stockées
for (int i = 0; i < inputFile.Count(); i++)
{
if (inputFile.GetLine(i) != _patternFile.GetLine(i)) // Les lignes sont différentes, on les ajoute pour traitement
{
inputBuffer.Add(inputFile.GetLine(i));
patternBuffer.Add(_patternFile.GetLine(i));
}
}
// Si des lignes doivent être traitées
if (inputBuffer.Count() > 0)
{
// Initialisation du séparateur
patternSeparator[0] = "'";
// analyse des lignes pour extraire les données
for (int iLine = 0; iLine < inputBuffer.Count(); iLine++)
{
// On découpe la ligne avec les caractères '
splitLinePattern = patternBuffer[iLine].Split(patternSeparator, StringSplitOptions.RemoveEmptyEntries);
foreach (string splitPattern in splitLinePattern)
{
// Verification s'il s'agit d'une clé ou pas
if ((splitPattern.Contains("@") == true) || (splitPattern.Contains(PatternTag.gID)))
{
// S'il s'agit d'un gID, il aut stocker la valeur pour les lectures successives
if (splitPattern == PatternTag.gID)
{
// Il s'agit d'une déclaration de gID
currentFullKey = PatternTag.gID;
}
else
{
// Il s'agit d'une clé
currentFullKey = splitPattern.ToString();
}
}
else
{
// Il ne s'agit pas d'une clé
// Verification du positionnement de la chaine actuelle
iCurrentIndex = inputBuffer[iLine].IndexOf(splitPattern.ToString());
if (iCurrentIndex >= 0) // La chaine a été trouvée
{
if (iCurrentIndex == 0) // La chaine actuelle est la première de la ligne
{
// Suppression de la section sans clé
inputBuffer[iLine] = inputBuffer[iLine].Substring(splitPattern.Length);
}
else
{
// Il y a une clé avant la chaine recherchée
// On récupère la clé
currentValueKey = inputBuffer[iLine].Substring(0, iCurrentIndex);
// On supprime la section sans clé
inputBuffer[iLine] = inputBuffer[iLine].Substring(iCurrentIndex + splitPattern.Length);
// Verification des données avant l'ajout des clés
if (currentFullKey == PatternTag.gID)
{
// Il s'agit d'une clé générique 'groupID'
currentGroupID = currentValueKey;
}
else
{
// Avant d'ajouter la clé, on remplace les données 'gID' par la valeur du groupe
if (currentFullKey.Contains("@" + PatternTag.gID) == true)
{
currentFullKey = currentFullKey.Replace("@" + PatternTag.gID, "@" + currentGroupID);
}
// Il faut ajouter la clé
AddKeyAndValue(currentFullKey, currentValueKey);
}
// Réinitialisation de la valeur de clé
currentFullKey = null;
currentValueKey = null;
}
}
else
{
// La chaine n'a pas été trouvée
}
}
}
// Si le buffer de lecture n'est pas vide et une clé est en attente de lecture, on la traite
if (inputBuffer[iLine].Length > 0 && currentFullKey != null)
{
currentValueKey = inputBuffer[iLine];
inputBuffer[iLine] = "";
// Verification des données avant l'ajout des clés
if (currentFullKey == PatternTag.gID)
{
// Il s'agit d'une clé générique 'groupID'
currentGroupID = currentValueKey;
}
else
{
// Avant d'ajouter la clé, on remplace les données 'gID' par la valeur du groupe
if (currentFullKey.Contains("@" + PatternTag.gID) == true)
{
currentFullKey = currentFullKey.Replace("@" + PatternTag.gID, "@" + currentGroupID);
}
// Il faut ajouter la clé
AddKeyAndValue(currentFullKey, currentValueKey);
}
// Réinitialisation de la valeur de clé
currentFullKey = null;
currentValueKey = null;
}
}
}
Ret = _group.Count();
}
else
{
_debugTool.WriteLine("StructuredFile (Import) : Impossible d'importer les données, les tailles de fichier sont différentes");
}
}
}
return Ret;
}
/// <summary>
/// Ecriture du fichier suivant le format :
/// [Groupe N] <-- Avec N l'identifiant du groupe
/// keyName = keyValue <-- Couple (key, value) pour le groupe considéré
/// etc...
/// </summary>
/// <param name="newFileName">Chemin d'accès au fichier</param>
/// <returns>Nombre de groupe écrit (-1 en cas d'erreur)</returns>
public int SaveTo(String newFileName)
{
int Ret = -1;
TextFile outputFile = null;
// Verification des paramètres d'entrée
if ((newFileName == null) || (newFileName == ""))
{
_debugTool.WriteLine("StructuredFile (SaveTo) : Nom de fichier invalide");
return Ret;
}
if ((_group == null) || (_group.Count == 0))
{
_debugTool.WriteLine("StructuredFile (SaveTo) : Pas de données à sauvegarder");
return Ret;
}
// Creation du fichier de sortie
outputFile = new TextFile();
// Lecture des groupes
foreach (StructuredFileGroup tmpGroup in _group)
{
// Creation de l'entête du groupe
outputFile.AddLine(DefaultPatternTag.HeaderBegin + tmpGroup.ID.ToString() + DefaultPatternTag.HeaderEnd);
if(tmpGroup.GetAllKeys() != null)
{
foreach (StructuredFileKey tmpKey in tmpGroup.GetAllKeys())
{
outputFile.AddLine(DefaultPatternTag.LineBegin + tmpKey.keyName + DefaultPatternTag.LineSeparator + tmpKey.valueString + DefaultPatternTag.LineEnd);
}
}
// Saut de ligne
outputFile.AddLine("");
}
// Ecriture du fichier de sortie
if (outputFile.SaveTo(newFileName) > 0)
{
// On garde le dernier fichier ecrit
_currentFileName = newFileName;
// On indique le nombre de groupe ecrit
Ret = _group.Count();
}
return Ret;
}
/// <summary>
/// Charge un fichier structuré à partir d'un fichier texte
/// </summary>
/// <param name="fileName">Fichier à charger</param>
/// <returns>Le nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Load(TextFile fileToLoad)
{
int Ret = -1;
int currentIndex = 0;
String currentLine = null;
String parsedLine = null;
String currentKeyName = null;
String currentKeyValue = null;
uint currentGroupID = 0;
StructuredFileGroup currentGroup = null;
List<StructuredFileGroup> groupToAdd = null;
// Verification des params d'entrée
if (fileToLoad != null)
{
// Lecture du fichier ligne à ligne
for (int i = 0; i < fileToLoad.Count(); i++)
{
currentLine = fileToLoad.GetLine(i);
if (currentLine != null)
{
// Analyse de la ligne lue
// Est-ce une ligne d'entête
if (currentLine.Contains(DefaultPatternTag.HeaderBegin) == true)
{
// Si jamais il y a déjà un groupe en cours de traitement, on l'ajoute à la liste
if (currentGroup != null)
{
if (groupToAdd == null)
groupToAdd = new List<StructuredFileGroup>();
groupToAdd.Add(currentGroup);
currentGroup = null;
}
// C'est une ligne d'entête, il faut la parser pour récupérer le numéro de groupe
// Suppression de la balise d'entête
parsedLine = currentLine;
if (DefaultPatternTag.HeaderBegin.Length > 0)
parsedLine = parsedLine.Replace(DefaultPatternTag.HeaderBegin, "");
if (DefaultPatternTag.HeaderEnd.Length > 0)
parsedLine = parsedLine.Replace(DefaultPatternTag.HeaderEnd, "");
// On essaye de lire le numéro du groupe
try
{
currentGroupID = Convert.ToUInt32(parsedLine);
}
catch (Exception)
{
currentGroupID = 0;
}
currentGroup = new StructuredFileGroup(currentGroupID);
}
else
{
// C'est une ligne à analyser
// Verification si la ligne est valable (si elle est non valable, elle est non traitée)
if (currentLine.Contains(DefaultPatternTag.LineBegin) && currentLine.Contains(DefaultPatternTag.LineSeparator) && currentLine.Contains(DefaultPatternTag.LineEnd))
{
// La ligne est valide, on la traite
// On supprime les entete et les fin de ligne
parsedLine = currentLine;
if (DefaultPatternTag.LineBegin.Length > 0)
parsedLine = currentLine.Replace(DefaultPatternTag.LineBegin, "");
if (DefaultPatternTag.LineEnd.Length > 0)
parsedLine = parsedLine.Replace(DefaultPatternTag.LineEnd, "");
// Récupération des noms de chaines et valeurs
currentIndex = parsedLine.IndexOf(DefaultPatternTag.LineSeparator);
currentKeyName = parsedLine.Substring(0, currentIndex);
currentKeyValue = parsedLine.Substring(currentIndex + DefaultPatternTag.LineSeparator.Length);
// Ajout de la clé considérée
if (currentGroup == null)
currentGroup = new StructuredFileGroup(0);
currentGroup.AddKey(new StructuredFileKey(currentKeyName, currentKeyValue));
}
}
}
}
// On ajoute le tout dernier groupe
if (currentGroup != null)
{
if (groupToAdd == null)
groupToAdd = new List<StructuredFileGroup>();
groupToAdd.Add(currentGroup);
currentGroup = null;
}
if (groupToAdd != null)
{
// On ajoute tous les groupes que l'on vient de charger dans le fichier final
foreach (StructuredFileGroup tmpGroup in groupToAdd)
{
this.AddGroup(tmpGroup);
}
Ret = groupToAdd.Count();
}
}
return Ret;
}
/// <summary>
/// Charge un fichier structuré à partir d'un nom de fichier
/// </summary>
/// <param name="fileName">Nom du fichier à charger</param>
/// <returns>Le nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Load(String fileName)
{
int Ret = -1;
TextFile inputFile = null;
// Verification des paramètres d'entrée
if (fileName != null)
{
// Ouverture du fichier selectionné
inputFile = new TextFile();
if (inputFile.Load(fileName) > 0)
Load(inputFile);
}
return Ret;
}
/// <summary>
/// Charge les données à partir d'un nom de fichier
/// ATTENTION, le pattern de fichier pour la lecture doit être définie avant d'appeler cette fonction
/// </summary>
/// <param name="inputFileName">Nom du fichier à importer</param>
/// <returns>Nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Import(String inputFileName)
{
int Ret = -1;
TextFile inputFile = null;
// Verification des paramètres
if (inputFileName != null)
{
// Lecture du fichier
inputFile = new TextFile();
inputFile.Load(inputFileName);
if (inputFile.Count() > 0)
{
Ret = Import(inputFile);
}
}
return Ret;
}
private TextFile _patternFile = null; // Fichier texte contenant le pattern du fichier utilisé
#endregion Fields
#region Constructors
// Constructor ----------------------------------------------------------------------------
public StructuredFile()
{
_patternFile = null;
_group = null;
_debugTool = new DebugTool(DebugTool.EDebugToolType.Disabled);
}
/// <summary>
/// Charge les données à partir d'un fichier de type 'TextFile'
/// ATTENTION, le pattern de fichier pour la lecture doit être définie avant d'appeler cette fonction
/// </summary>
/// <param name="inputFile">Fichier à importer</param>
/// <returns>Nombre de groupe chargé (-1 en cas d'erreur)</returns>
public int Import(TextFile inputFile)
{
int Ret = -1;
int iCurrentIndex = -1;
List <String> inputBuffer = new List <string>();
List <String> patternBuffer = new List <string>();
string[] splitLinePattern = null;
string[] patternSeparator = new string[1];
String currentFullKey = null;
String currentValueKey = null;
String currentGroupID = "0";
// Verification des params d'entrée
if (inputFile != null)
{
// Verification des paramètres internes
if (_patternFile != null)
{
// Comparaison des tailles de fichier
if (inputFile.Count() == _patternFile.Count())
{
// Comparaison des fichiers lignes à lignes, les lignes identiques sont supprimées, les lignes différentes sont stockées
for (int i = 0; i < inputFile.Count(); i++)
{
if (inputFile.GetLine(i) != _patternFile.GetLine(i)) // Les lignes sont différentes, on les ajoute pour traitement
{
inputBuffer.Add(inputFile.GetLine(i));
patternBuffer.Add(_patternFile.GetLine(i));
}
}
// Si des lignes doivent être traitées
if (inputBuffer.Count() > 0)
{
// Initialisation du séparateur
patternSeparator[0] = "'";
// analyse des lignes pour extraire les données
for (int iLine = 0; iLine < inputBuffer.Count(); iLine++)
{
// On découpe la ligne avec les caractères '
splitLinePattern = patternBuffer[iLine].Split(patternSeparator, StringSplitOptions.RemoveEmptyEntries);
foreach (string splitPattern in splitLinePattern)
{
// Verification s'il s'agit d'une clé ou pas
if ((splitPattern.Contains("@") == true) || (splitPattern.Contains(PatternTag.gID)))
{
// S'il s'agit d'un gID, il aut stocker la valeur pour les lectures successives
if (splitPattern == PatternTag.gID)
{
// Il s'agit d'une déclaration de gID
currentFullKey = PatternTag.gID;
}
else
{
// Il s'agit d'une clé
currentFullKey = splitPattern.ToString();
}
}
else
{
// Il ne s'agit pas d'une clé
// Verification du positionnement de la chaine actuelle
iCurrentIndex = inputBuffer[iLine].IndexOf(splitPattern.ToString());
if (iCurrentIndex >= 0) // La chaine a été trouvée
{
if (iCurrentIndex == 0) // La chaine actuelle est la première de la ligne
{
// Suppression de la section sans clé
inputBuffer[iLine] = inputBuffer[iLine].Substring(splitPattern.Length);
}
else
{
// Il y a une clé avant la chaine recherchée
// On récupère la clé
currentValueKey = inputBuffer[iLine].Substring(0, iCurrentIndex);
// On supprime la section sans clé
inputBuffer[iLine] = inputBuffer[iLine].Substring(iCurrentIndex + splitPattern.Length);
// Verification des données avant l'ajout des clés
if (currentFullKey == PatternTag.gID)
{
// Il s'agit d'une clé générique 'groupID'
currentGroupID = currentValueKey;
}
else
{
// Avant d'ajouter la clé, on remplace les données 'gID' par la valeur du groupe
if (currentFullKey.Contains("@" + PatternTag.gID) == true)
{
currentFullKey = currentFullKey.Replace("@" + PatternTag.gID, "@" + currentGroupID);
}
// Il faut ajouter la clé
AddKeyAndValue(currentFullKey, currentValueKey);
}
// Réinitialisation de la valeur de clé
currentFullKey = null;
currentValueKey = null;
}
}
else
{
// La chaine n'a pas été trouvée
}
}
}
// Si le buffer de lecture n'est pas vide et une clé est en attente de lecture, on la traite
if (inputBuffer[iLine].Length > 0 && currentFullKey != null)
{
currentValueKey = inputBuffer[iLine];
inputBuffer[iLine] = "";
// Verification des données avant l'ajout des clés
if (currentFullKey == PatternTag.gID)
{
// Il s'agit d'une clé générique 'groupID'
currentGroupID = currentValueKey;
}
else
{
// Avant d'ajouter la clé, on remplace les données 'gID' par la valeur du groupe
if (currentFullKey.Contains("@" + PatternTag.gID) == true)
{
currentFullKey = currentFullKey.Replace("@" + PatternTag.gID, "@" + currentGroupID);
}
// Il faut ajouter la clé
AddKeyAndValue(currentFullKey, currentValueKey);
}
// Réinitialisation de la valeur de clé
currentFullKey = null;
currentValueKey = null;
}
}
}
Ret = _group.Count();
}
else
{
_debugTool.WriteLine("StructuredFile (Import) : Impossible d'importer les données, les tailles de fichier sont différentes");
}
}
}
return(Ret);
}
// Properties -----------------------------------------------------------------------------
// Public ---------------------------------------------------------------------------------
/// <summary>
/// Fonction pour charger un fichier pattern pour l'import ou l'export des données
/// </summary>
/// <param name="patternFileName">Nom du fichier modèle</param>
/// <returns>Le nombre de lignes lues (-1 en cas d'erreur)</returns>
public int SetPatternFile(String patternFileName)
{
int Ret = -1;
TextFile fileToLoad = null;
// Desallocation des données déjà chargées
if (_patternFile != null)
{
_patternFile.RemoveAllLine();
_patternFile = null;
}
if (patternFileName != null)
{
// Lecture du fichier pattern
fileToLoad = new TextFile();
fileToLoad.Load(patternFileName);
Ret = SetPatternFile(fileToLoad);
}
return Ret;
}
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>
/// Exporte tous les groupes définis dans le fichier en suivant le pattern file précédemment défini
/// </summary>
/// <param name="fileName">Nom du fichier pour l'export</param>
/// <returns>Nombre de groupe ecrit (-1 en cas d'erreur)</returns>
public int Export(String fileName)
{
int Ret = -1;
TextFile outputFile = new TextFile();
List<String> outputBuffer = new List<string>();
int currentGroupIndex = -1; // Index du groupe pour le remplacement des gID
int indexInLine = -1; // Index pour parser les différentes lignes
String flagToCheck = null; // Permet l'analyse du tag
// Verification des params d'entrée
if (fileName != null)
{
// Verification des paramètres internes
if ((_patternFile != null) && (_group != null))
{
// Récupération du fichier pattern
for(int i=0; i<_patternFile.Count(); i++)
{
outputBuffer.Add(_patternFile.GetLine(i));
}
// Lecture de tout le fichier pour remplacer les Tags 'gID' par l'identifiant du groupe
for(int i=0; i<outputBuffer.Count(); i++)
{
// Permet d'initialiser la position de l'index pour la recherche par ligne
indexInLine = 0;
// Recherche sur la ligne de tous les Tags 'gID'
do
{
// Recherche de l'index dans la portion de la ligne (à chaque passage on se décale sur la ligne)
indexInLine = outputBuffer[i].IndexOf("gID", indexInLine);
if (indexInLine > 1) // Il y a dans tous les cas un caractère avant le Tag gID
{
// Analyse du tag pour connaitre le type ('gID ou @gID)
flagToCheck = outputBuffer[i].Substring(indexInLine - 1, 4);
if (flagToCheck == "'gID") // Il s'agit d'un flag de groupe, il faut changer de groupe
{
currentGroupIndex = GetNextGroupIndex(currentGroupIndex); // On change de groupe
if (currentGroupIndex >= 0) // On verifie que le groupe est valide
{
outputBuffer[i] = outputBuffer[i].Substring(0, indexInLine - 1) + _group[currentGroupIndex].ID.ToString() + outputBuffer[i].Substring(indexInLine + 4);
}
}
if ((flagToCheck == "@gID") && (currentGroupIndex >= 0)) // Il s'agit d'un flag à remplacer et le groupe est valide
{
// On remplace ce gID avec la valeur du groupe actuel
outputBuffer[i] = outputBuffer[i].Substring(0, indexInLine) + _group[currentGroupIndex].ID.ToString() + outputBuffer[i].Substring(indexInLine + 3);
}
}
} while ((indexInLine >= 0) && (currentGroupIndex > 0));
}
// Export des données du groupe pour toutes les lignes du fichier
for (int i = 0; i < outputBuffer.Count(); i++)
{
// On verifie si la ligne doit être traitée (présence du caractère @)
if (outputBuffer[i].Contains("@") == true)
{
// On parcourt toute la liste des groupes
foreach (StructuredFileGroup currentGroup in _group)
{
// On verifie si la ligne contient des données du groupe
if (outputBuffer[i].Contains("@" + currentGroup.ID.ToString()) == true)
{
// On parcourt toutes les clées
foreach (StructuredFileKey currentKey in currentGroup.GetAllKeys())
{
outputBuffer[i] = outputBuffer[i].Replace("'" + currentKey.keyName + "@" + currentGroup.ID.ToString() + "'", currentKey.valueString);
}
}
}
}
// Ecriture de la ligne dans le fichier de sortie
outputFile.AddLine(outputBuffer[i]);
}
// Ecriture du fichier final
outputFile.SaveTo(fileName);
Ret = _group.Count();
}
}
return Ret;
}