/*
* SERVICES
*/
/// <summary>
/// Réalise le post traitement d'une commande AeroCalcCommand, pour implémenter les messages à l'utilisateur
/// </summary>
/// <param name="Cmd">AeroCalcCommand à traiter</param>
/// <remarks>
// TODO L'implémentation d'une bibliothèque minimale de messages d'erreur doit être envisagée
// TODO A faire au niveau du constructeur de EventMessages
/// </remarks>
public void postProcess(AeroCalcCommand Cmd)
{
if (Cmd.eventCode == AeroCalcCommand.ECODE_INITIAL_VALUE)
{
// Command totally unprocessed, not a normal situation
string msg = "[" + Cmd.eventCode + "]" + " POSTPROC:UNPROCESSED COMMAND";
Cmd.setResultText(msg);
// TODO Faut-il autoriser la demande EXIT par PostProcessor ?
Cmd.isExit();
}
if (Cmd.eventCode > 0)
{
// Successfull operations
if (!double.IsNaN(Cmd.numericResult))
{
// A numeric value has been produced
Cmd.setResultText(Cmd.rawTxtCommand + " = " + Cmd.numericResult);
}
else
{
// No numeric value to expose
string msg = swapFields(EMsgLib.getMessageWith(Cmd.eventCode), Cmd.info);
if (!string.IsNullOrEmpty(Cmd.txtResult))
{
// A message has been prepared, message from library is added, if it exists
if (!string.IsNullOrEmpty(msg))
{
// A msg from library is found
Cmd.setResultText(Cmd.txtResult + Environment.NewLine + msg);
}
}
else
{
// No message prepared by the command
if (string.IsNullOrEmpty(msg))
{
// No msg from library
msg = "[" + Cmd.eventCode + "]" + " POSTPROC:RESULT MSG NOT IMPLEMENTED";
}
Cmd.setResultText(msg);
}
}
}
if (Cmd.eventCode < 0)
{
// Error
string msg = swapFields(EMsgLib.getMessageWith(Cmd.eventCode), Cmd.info);
if (string.IsNullOrEmpty(msg))
{
// Nothing returned
msg = "[" + Cmd.eventCode + "]" + " POSTPROC:ERROR MSG NOT IMPLEMENTED";
}
Cmd.setResultText(msg);
}
// Verbose
if (Cmd.verbosed)
{
verboseCommand(Cmd);
}
}
/// <summary>
/// Traite la commande d'initialisation de l'interpreteur
/// Première (et unique) commande à pouvoir être lançée
/// </summary>
/// <param name="Cmd">Commande active</param>
/// <returns>Etat de réussite de la commande</returns>
private bool initProcessor(AeroCalcCommand Cmd)
{
int loadStatus;
UnitsXMLFile unitsFile = new UnitsXMLFile("");
if (!initialized)
{
loadStatus = EnvContext.loadConfigFile(Cmd.subs[1]);
switch (loadStatus)
{
case FileIO.FILEOP_SUCCESSFUL:
// Chargement du dictionnaire des unités
if (EnvContext.unitsEnabled)
{
UnitsLib = unitsFile.getUnitsFromXML(EnvContext.unitsFileName);
ModelsLib.setUnitsLibrary(UnitsLib);
}
ModelsLib.setDataModelsDirectory(EnvContext.modelsDirPath);
// TODO Traiter le false de setDataModelsDirectory
// Construction de PostProcessor et de la librairie des messages
PostProc = new PostProcessor(EnvContext);
// TODO Il faut retourner un EventCode si un problème est survenu pendant la construction du
// TODO PostProcessor (langue...)
// TODO Ne faut-il pas préparer la librairie des messages ici et la transmettre à la construction
// TODO du PostProcessor, plutôt ??? (et donc rapatrier tout le traitement dans setLanguage() )
Cmd.setEventCode(AeroCalcCommand.ECODE_INIT_SUCCESSFULL);
break;
case FileIO.FILEOP_INVALID_PATH:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_INIT_CONFIGFILE_PATH);
Cmd.setExit();
break;
case FileIO.FILEOP_IO_ERROR:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_INIT_IO_ERROR);
Cmd.setExit();
break;
case FileIO.FILEOP_UNKNOWN_ERROR:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_INIT_UKN_FILE_ERROR);
Cmd.setExit();
break;
default:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_INIT_UKN_ERROR);
Cmd.setExit();
break;
}
// Fin du processus d'initialisation
initialized = true;
return(true);
}
else
{
// Already initialized
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_REINIT_NOT_ALLOWED);
}
return(false);
}
/*
* METHODES
*/
/// <summary>
/// Traitement de la commande de lecture et d'exécution d'un fichier de script
/// Les instructions exclusives d'AeroCalcCommandProcessor ne peuvent pas être executées
/// SCRIPTFILE, HELP, EXIT, INIT
/// </summary>
/// <param name="Cmd">Commande active</param>
/// <returns>
/// True, si la commande a été traitée sans erreur
/// </returns>
private bool readScriptFile(AeroCalcCommand Cmd)
{
if (Cmd.subs.Length >= 2)
{
ScriptFile SF = new ScriptFile();
// Constitution du path
SF.setWorkDirectory(EnvContext.scriptsDirPath);
SF.setInputFileWithRelPath(Cmd.subs[1]);
switch (SF.readFile())
{
case FileIO.FILEOP_SUCCESSFUL:
// Le fichier de script a été lu avec succès
if (SF.Count > 0)
{
string outputLn = "";
for (int index = 0; index < SF.Count; index++)
{
string ln = SF.readNextLine();
outputLn += ln + Environment.NewLine;
AeroCalcCommand ScriptCmd = process(ln);
outputLn += ScriptCmd.txtResult + Environment.NewLine;
}
Cmd.setResultText(outputLn);
Cmd.setEventCode(AeroCalcCommand.ECODE_SCRIPTFILE_SUCCESSFULL);
}
else
{
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPTFILE_VOID);
}
break;
case FileIO.FILEOP_FILE_DOES_NOT_EXIST:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPTFILE_DOES_NOT_EXIST);
break;
case FileIO.FILEOP_INVALID_PATH:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPT_PATH);
break;
case FileIO.FILEOP_IO_ERROR:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPT_IO_ERROR);
break;
case FileIO.FILEOP_UNKNOWN_ERROR:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPT_UKN_ERROR);
break;
case FileIO.FILEOP_INPUT_FILE_IS_LOCKED:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPT_SECURITY);
break;
default:
Cmd.setEventCode(AeroCalcCommand.ECODE_ERR_SCRIPT_GENERIC);
break;
}
}
return(true);
}
/// <summary>
/// Active un pack de langue demandé par l'utilisateur
/// </summary>
/// <param name="Cmd">AeroCalcCommand qui a demandé le traitement</param>
/// <returns></returns>
private bool setLanguage(AeroCalcCommand Cmd)
{
Cmd.setEventCode(PostProc.changeLanguage(EnvContext.Langs.Library[Cmd.index]));
if (Cmd.eventCode == AeroCalcCommand.ECODE_LANG_CHANGED_SUCCESSFULL)
{
EnvContext.setActiveLanguage(Cmd.index);
}
return(true);
}
/*
* METHODES
*/
private void verboseCommand(AeroCalcCommand Cmd)
{
string msg = "";
msg += "raw command { " + Cmd.rawTxtCommand;
msg += " } action code { " + Cmd.action;
msg += " } event code { " + Cmd.eventCode;
msg += " } result { " + Cmd.numericResult;
msg += " } duration { " + Cmd.durationMilliSecond + " ms }" + Environment.NewLine;
Cmd.setResultText(Cmd.txtResult + msg);
}
/*
* SERVICES
*/
/// <summary>
/// Fonction principale de traitement
///
/// </summary>
/// <param name="txtCommand">Ligne de commande fournie par l'utilisateur, ou tirée d'un fichier
/// de script</param>
/// <returns>retourne une commande traitée, sous forme d'un objet AeroCalcCommand</returns>
/// <remarks>
/// Seules quelques commandes sont traitées ici, l'essentiel est fait via le constructeur AeroCalcCommand
/// </remarks>
public AeroCalcCommand process(string txtCommand)
{
AeroCalcCommand Cmd = new AeroCalcCommand(txtCommand, ModelsLib, EnvContext, MemStack);
// Certaines commandes sont traitées ici, dans le processeur et non à la construction de la commande
switch (Cmd.action)
{
case AeroCalcCommand.ACTION_INIT_INTERPRETER:
// Initialisation
initProcessor(Cmd);
break;
case AeroCalcCommand.ACTION_EXIT:
// Exit
Cmd.setEventCode(AeroCalcCommand.ECODE_EXIT_REQUESTED);
break;
case AeroCalcCommand.ACTION_SCRIPTFILE:
// Lecture de fichier de script
readScriptFile(Cmd);
break;
case AeroCalcCommand.ACTION_HELP:
// Aide
Cmd.setEventCode(AeroCalcCommand.ECODE_HELP_REQUESTED);
break;
case AeroCalcCommand.ACTION_LANG_CHANGE:
// Changement de pack de langue
if (Cmd.eventCode == AeroCalcCommand.ECODE_CMD_HANDOVER)
{
setLanguage(Cmd);
}
break;
}
// Post process: Génération de tous les messages vers l'utilisateur
PostProc.postProcess(Cmd);
return(Cmd);
}
