src/vapiOptions.c

Ir para a documentação deste ficheiro.

#include "vapiTypes.h"
#include "vapiOptions.h"
#include "vapiMemory.h"
#include "vapiAux.h"

vOptions *
vapiOptionsInit (vOptionsSettings * OptionsSettings)
{
        int i;
        vOptions *Options = malloc (sizeof (vOptions));

        /*
         * Definir o numero de cada tipo mesmo na estrtura de opções, 
         * Por forma a ajudar a robustez.
         */
        Options->floatsNumber = OptionsSettings->floatsNumber;
        Options->intsNumber = OptionsSettings->intsNumber;
        Options->charsNumber = OptionsSettings->charsNumber;
        Options->booleansNumber = OptionsSettings->booleansNumber;
        Options->choicesNumber = OptionsSettings->chooseNumber;


        /*
         * Definição e alocação de espaço de acordo com as necessidades da operação.
         */
        if (OptionsSettings->floatsNumber)
        {
                Options->floats =
                        malloc (OptionsSettings->floatsNumber *
                                sizeof (double));
                for (i = 0; i < OptionsSettings->floatsNumber; i++)
                {
                        Options->floats[i] =
                                OptionsSettings->floats[i].defaultValue;
                }
        }
        if (OptionsSettings->intsNumber)
        {
                Options->ints =
                        malloc (OptionsSettings->intsNumber * sizeof (int));
                for (i = 0; i < OptionsSettings->intsNumber; i++)
                {
                        Options->ints[i] =
                                OptionsSettings->ints[i].defaultValue;
                }
        }

        if (OptionsSettings->charsNumber)
        {
                Options->chars =
                        malloc (OptionsSettings->charsNumber *
                                sizeof (vChar));
                for (i = 0; i < OptionsSettings->charsNumber; i++)
                {
                        Options->chars[i].ch = "";
                }
        }
        if (OptionsSettings->chooseNumber)
        {
                Options->choices =
                        malloc (OptionsSettings->chooseNumber * sizeof (int));
                for (i = 0; i < OptionsSettings->chooseNumber; i++)
                {
                        Options->choices[i] =
                                OptionsSettings->choose[i].defaultOption;
                }
        }
        if (OptionsSettings->booleansNumber)
        {
                Options->booleans =
                        malloc (OptionsSettings->booleansNumber *
                                sizeof (vBoolean));
                for (i = 0; i < OptionsSettings->booleansNumber; i++)
                {
                        Options->booleans[i] =
                                OptionsSettings->booleans[i].defaultValue;
                }
        }
        return Options;
}
int
vapiOptionsGetInts (vOptions * Options, int position)
{
        if (Options->intsNumber > 0 && position < Options->intsNumber)
        {
                return Options->ints[position];
        }
        else
        {
                return 0;
        }
}
double
vapiOptionsGetFloats (vOptions * Options, int position)
{
        if (Options->floatsNumber > 0 && position < Options->floatsNumber)
        {
                return Options->floats[position];
        }
        else
        {
                return 0;
        }
}
char *
vapiOptionsGetChars (vOptions * Options, int position)
{
        if (Options->charsNumber > 0 && position < Options->charsNumber)
        {
                return Options->chars[position].ch;
        }
        else
        {
                return " ";
        }
}
vBoolean
vapiOptionsGetBooleans (vOptions * Options, int position)
{
        if (Options->booleansNumber > 0 && position < Options->booleansNumber)
        {
                return Options->booleans[position];
        }
        else
        {
                return vFALSE;
        }
}
int
vapiOptionsGetChoices (vOptions * Options, int position)
{
        if (Options->choicesNumber > 0 && position < Options->choicesNumber)
        {
                return Options->choices[position];
        }
        else
        {
                return 0;
        }
}
int
vapiOptionsGetTimes (vOptions * Options)
{
        vEffectOptions *CustomOptions = Options->CustomOptions;
        return CustomOptions->times;
}
void
vOptionsFree (vOptions * Options, vOptionsSettings * OptionsSettings,
              vOptionsFreeCustom FreeCustom)
{
        int i;

        if (OptionsSettings->floatsNumber)
        {
                free (Options->floats);
        }
        if (OptionsSettings->intsNumber)
        {
                free (Options->ints);
        }
        if (OptionsSettings->charsNumber)
        {
                for (i = 0; i < OptionsSettings->charsNumber; i++)
                {
                        if (strlen (Options->chars[i].ch) > 0)
                        {
                                vCharFreeChar (&Options->chars[i]);
                        }
                }
                free (Options->chars);
        }
        if (OptionsSettings->chooseNumber)
        {
                free (Options->choices);
        }
        if (OptionsSettings->booleansNumber)
        {
                free (Options->booleans);
        }
        if (FreeCustom != NULL)
        {
                FreeCustom (Options, OptionsSettings);
        }
        free (Options);
}

vBoolean
vapiOptionsCheck (vOptionsSettings * OptionsSettings, vOptions * Options)
{

        int i;
        if (OptionsSettings->intsNumber)
        {
                for (i = 0; i < OptionsSettings->intsNumber; i++)
                {

                        if (Options->ints[i] <
                            OptionsSettings->ints[i].min
                            || Options->ints[i] >
                            OptionsSettings->ints[i].max)
                        {
                                Options->ints[i] =
                                        OptionsSettings->ints[i].defaultValue;

                        }
                }
        }
        if (OptionsSettings->floatsNumber)
        {
                for (i = 0; i < OptionsSettings->floatsNumber; i++)
                {

                        if (Options->floats[i] <
                            OptionsSettings->floats[i].min
                            || Options->floats[i] >
                            OptionsSettings->floats[i].max)
                        {
                                Options->floats[i] =
                                        OptionsSettings->floats[i].
                                        defaultValue;

                        }
                }
        }
        if (OptionsSettings->charsNumber)
        {
                for (i = 0; i < OptionsSettings->charsNumber; i++)
                {

                        if (strlen (Options->chars[i].ch) == 0)
                        {
                                return vTRUE;

                        }
                }
        }
        return vFALSE;
}
void
vOptionsSettingsFree (vOptionsSettings * OptionsSettings,
                      vOptionsSettingsFreeCustom FreeCustom)
{
        if (FreeCustom != NULL)
        {
                FreeCustom (OptionsSettings);
        }
        free (OptionsSettings);

}
vOptionsSettings *
vapiOptionsSettingsInit ()
{
        vOptionsSettings *OptionsSettings =
                malloc (sizeof (vOptionsSettings));
        OptionsSettings->floatsNumber = 0;
        OptionsSettings->intsNumber = 0;
        OptionsSettings->charsNumber = 0;
        OptionsSettings->chooseNumber = 0;
        OptionsSettings->booleansNumber = 0;
        return OptionsSettings;
}

---