Archivero.cpp

Ir a la documentación de este archivo.

/*
   MUnDoCAAD MUD Engine
   Copyright (C) 2002-2005 José Manuel Ferrer Ortiz

   *****************************************************************************
   *                                                                           *
   *  This program is free software; you can redistribute it and/or modify it  *
   *  under the terms of the GNU General Public License version 2, as          *
   *  published by the Free Software Foundation.                               *
   *                                                                           *
   *  This program is distributed in the hope that it will be useful, but      *
   *  WITHOUT ANY WARRANTY; without even the implied warranty of               *
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU         *
   *  General Public License version 2 for more details.                       *
   *                                                                           *
   *  You should have received a copy of the GNU General Public License        *
   *  version 2 along with this program; if not, write to the Free Software    *
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  *
   *                                                                           *
   *****************************************************************************
*/


#include <QDir>

#include "Archivero.hpp"


extern QDir dir_datos;


Archivero::Archivero () : ccache (TAM_CCACHE * 1024), rcache (TAM_RCACHE * 1024)
{
}

Archivero::~Archivero ()
{
  qDebug ("Destructor de Archivero");
}

QString Archivero::BuscaPropiedad (const QString &nom_ent,
                                   const QString &nom_prop)
{
  QStringList lista_ents;  // Lista de entidades en las que buscar

  QDomDocument documento ("entidad");
  QDomNode     nodo;
  QDomElement  elemento;
  QDomAttr     atributo;

  // Añadimos a la lista la entidad a la que pertenece la propiedad
  lista_ents += nom_ent;

  for (QStringList::Iterator iter = lista_ents.begin();
       iter != lista_ents.end(); ++iter)
  {
    if (!CargaDocumento (documento, *iter))
      return (QString::null);

    // Recorremos el árbol DOM para añadir las herencias a la lista y mirar
    // si la propiedad está en esta entidad
    elemento = documento.documentElement();
    nodo     = elemento.firstChild();
    while (!nodo.isNull())
    {
      elemento = nodo.toElement();
      if (!elemento.isNull())
      {
        if (elemento.tagName() != "herencia")  // El elemento es una propiedad
        {
          atributo = elemento.attributeNode ("nombre");
          // Comparamos el nombre sin distinguir mayúsculas de minúsculas
          if ((atributo.value().length() == nom_prop.length()) &&
              (atributo.value().startsWith (nom_prop, Qt::CaseInsensitive)))
          {
            // Hemos encontrado la propiedad
            return (*iter);
          }
        }
        else  // El elemento es una herencia
        {
          atributo = elemento.attributeNode ("entidad");

          // Comprobamos si ya estaba en la lista, sin distinguir mayúsculas de
          // minúsculas
          if (!lista_ents.contains (atributo.value(),
                                    Qt::CaseInsensitive))  // No estaba ya
            lista_ents += atributo.value();  // Pues la añadimos
        }
      }
      nodo = nodo.nextSibling();
    }
  }

  // No hemos encontrado la propiedad
  qWarning ("La entidad \"%s\" no dispone de la propiedad \"%s\"",
            nom_ent.toLatin1().constData(), nom_prop.toLatin1().constData());

  return (QString::null);
}


bool Archivero::CargaDocumento (QDomDocument &documento, const QString &nom_ent)
{
  // Buscamos, sin distinguir mayúsculas/minúsculas, el nombre de fichero de la
  // entidad
  QStringList lista (dir_datos.entryList (QDir::Files).filter (nom_ent + ".xml",
                     Qt::CaseInsensitive));

  QStringList::iterator iter (lista.begin());

  for ( ; iter != lista.end(); ++iter)
    if ((*iter).length() == (nom_ent.length() + 4))  // 4 es la longitud de la
                                                     // extensión ".xml"
      break;  // Hemos encontrado el nombre de fichero de la entidad

  if (iter == lista.end())  // No encontrado
  {
    qWarning ("No se ha encontrado el fichero \"%s\"", dir_datos.filePath
              (nom_ent + ".xml").toLatin1().constData());
    return (false);
  }

  QFile fichero (dir_datos.filePath (*iter));

  if (!fichero.open (QIODevice::ReadOnly | QIODevice::Text))
  {
    // No se ha podido abrir el archivo
    qWarning ("\"%s\": %s", fichero.fileName().toLatin1().constData(),
              fichero.errorString().toLatin1().constData());
    return (false);
  }

  QString dsc_error;  // Descripción del error
  int     lin_error, col_error;  // Línea y columna del error, respectivamente

  if (!documento.setContent (&fichero, &dsc_error, &lin_error, &col_error))
  {
    fichero.close();

    qWarning ("\"%s\" (%d, %d): %s", fichero.fileName().toLatin1().constData(),
              lin_error, col_error, dsc_error.toLatin1().constData());

    return (false);
  }

  fichero.close();
  return (true);
}


unsigned char Archivero::DaModoPropiedad (const QString &nom_ent,
                                          const QString &nom_prop)
{
  const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);

  if (prop != NULL)
    return (prop->modo);
  else
    return ((unsigned char) -1);
}


unsigned char Archivero::DaTipoPropiedad (const QString &nom_ent,
                                          const QString &nom_prop)
{
  const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);

  if (prop != NULL)
    return (prop->tipo);
  else
    return ((unsigned char) -1);
}


QString Archivero::DaPropiedad (const QString &nom_ent,
                                const QString &nom_prop)
{
  const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);

  if (prop != NULL)
    return (*(prop->contenido));
  else
    return (QString::null);
}


Archivero::Propiedad *Archivero::LeePropiedad (const QString &nom_ent,
                                               const QString &nom_prop)
{
  Propiedad *propiedad = NULL;

  QDomDocument documento ("entidad");
  QDomNode     nodo;
  QDomElement  elemento;
  QDomAttr     atributo;
  QDomText     texto;

  if (!CargaDocumento (documento, nom_ent))
    return (NULL);

  elemento = documento.documentElement();
  nodo     = elemento.firstChild();
  while (!nodo.isNull())
  {
    elemento = nodo.toElement();
    if ((!elemento.isNull()) && (elemento.tagName() != "herencia"))
    {
      atributo = elemento.attributeNode ("nombre");
      // Comparamos el nombre sin distinguir mayúsculas de minúsculas
      if ((atributo.value().length() == nom_prop.length()) &&
          (atributo.value().startsWith (nom_prop, Qt::CaseInsensitive)))
      {
        // Hemos encontrado la propiedad
        propiedad = new Propiedad (nom_ent, nom_prop);

        if (elemento.tagName() == "rutina")
          propiedad->modo = MODO_RUTINA;
        else
          propiedad->modo = MODO_VARIABLE;

        atributo = elemento.attributeNode ("tipo");
        if (atributo.value() == "booleano")
          propiedad->tipo = TIPO_BOOLEANO;
        else if (atributo.value() == "entero")
          propiedad->tipo = TIPO_ENTERO;
        else if (atributo.value() == "cadena")
          propiedad->tipo = TIPO_CADENA;
        else
          propiedad->tipo = TIPO_NADA;

        propiedad->contenido = new QString;

        nodo  = nodo.firstChild();
        while (!nodo.isNull())
        {
          texto = nodo.toText();
          if (!texto.isNull())
            propiedad->contenido->append (texto.data());

          nodo = nodo.nextSibling();
        }
        break;  // Ya hemos concluido la búsqueda
      }
    }
    nodo = nodo.nextSibling();
  }

  if (propiedad == NULL)  // No hemos encontrado la propiedad
    return (NULL);

  // Filtramos el contenido de la propiedad
  if (propiedad->modo == MODO_RUTINA)
  {
    *(propiedad->contenido) = FiltroLecturaRutina (*(propiedad->contenido));
  }
  else if (propiedad->tipo == TIPO_CADENA)
  {
    bool error;

    *(propiedad->contenido) = FiltroLecturaCadena (*(propiedad->contenido),
                                                   error);

    if (error)
      qWarning ("\"%s\": Uso incorrecto de \"\\\" en la cadena \"%s\"",
                nom_ent.toLatin1().constData(),
                nom_prop.toLatin1().constData());
  }
  else if (propiedad->tipo == TIPO_ENTERO)
  {
    bool error;

    *(propiedad->contenido) = FiltroLecturaEntero (*(propiedad->contenido),
                                                   error);

    if (error)
      qWarning ("\"%s\": Formato incorrecto del entero \"%s\"",
                nom_ent.toLatin1().constData(),
                nom_prop.toLatin1().constData());
  }
  else  // propiedad->tipo = TIPO_BOOLEANO
  {
    bool error;

    *(propiedad->contenido) = FiltroLecturaBooleano (*(propiedad->contenido),
                                                     error);

    if (error)
      qWarning ("\"%s\": Formato incorrecto del booleano \"%s\"",
                nom_ent.toLatin1().constData(),
                nom_prop.toLatin1().constData());
  }

  propiedad->contenido->squeeze();

  return (propiedad);
}


const Archivero::Propiedad *Archivero::ObtenPropiedad (const QString &nom_ent,
                                                       const QString &nom_prop)
{
  // Clave para la búsqueda en las cachés
  QString clave (nom_ent + ">" + nom_prop);

  // Nombre de la entidad en la que está almacenada físicamente la propiedad
  QString *ent_fisica = rcache.object (clave);

  if (ent_fisica == 0)  // No se ha encontrado en la caché de referencias
  {
    ent_fisica = new QString (BuscaPropiedad (nom_ent, nom_prop));
    if (ent_fisica->isNull())  // No se ha encontrado la entidad o la propiedad
    {
      delete (ent_fisica);
      return (NULL);
    }
    rcache.insert (clave, ent_fisica, ent_fisica->length());
  }

  if (*ent_fisica != nom_ent)
    clave = (*ent_fisica + ">" + nom_prop);

  // Propiedad almacenada en la caché de contenidos
  Propiedad *propiedad = ccache.object (clave);

  if (propiedad == 0)  // No se ha encontrado en la caché de contenidos
  {
    propiedad = LeePropiedad (*ent_fisica, nom_prop);
    if (propiedad == NULL)
    {
      // BuscaPropiedad no encuentra las mismas propiedades que LeePropiedad, o
      // bien lo que indica rcache es falso
      qDebug ("Archivero::ObtenPropiedad(): LeePropiedad() ha devuelto NULL");
      return (NULL);
    }
    ccache.insert (clave, propiedad, propiedad->contenido->length());
  }

  return (propiedad);
}


// Clase Archivero::Propiedad

Archivero::Propiedad::Propiedad (const QString &nom_ent,
                                 const QString &nom_prop) : entidad (nom_ent),
                                                            nombre  (nom_prop)
{
  modificada = 0;
}

Archivero::Propiedad::~Propiedad ()
{
  qDebug ("Destructor de Archivero::Propiedad");

  if (modificada)
    GuardaPropiedad();

  delete (contenido);
}

void Archivero::Propiedad::GuardaPropiedad ()
{
}


// Funciones fuera de toda clase


QString FiltroLecturaBooleano (const QString &original, bool &error)
{
  QString filtrado ("F");  // Texto que retornaremos (por defecto FALSO)

  bool hay_booleano = false;  // Si ya se ha encontrado en la cadena un valor
                              // booleano ("VERDADERO" o "FALSO")
  error             = false;  // Se pondrá a true si se encuentra algún error

  const unsigned long longitud = original.length();

  for (unsigned long i = 0; i < longitud; i++)
  {
    switch (original.at (i).toLatin1())
    {
      case ' ' :
      case '\n':
      case '\r':
      case '\t':
        break;

      case 'V':
        if (hay_booleano || ((i + 8) > longitud) ||
            (original.at (i + 1) != 'E') ||
            (original.at (i + 2) != 'R') ||
            (original.at (i + 3) != 'D') ||
            (original.at (i + 4) != 'A') ||
            (original.at (i + 5) != 'D') ||
            (original.at (i + 6) != 'E') ||
            (original.at (i + 7) != 'R') ||
            (original.at (i + 8) != 'O'))
          error = true;
        else
        {
          hay_booleano = true;
          filtrado = "V";
        }
        break;

      case 'F':
        if (hay_booleano || ((i + 5) > longitud) ||
            (original.at (i + 1) != 'A') ||
            (original.at (i + 2) != 'L') ||
            (original.at (i + 3) != 'S') ||
            (original.at (i + 4) != 'O'))
          error = true;
        else
          hay_booleano = true;
        break;

      default:
        error = true;
    }
    if (error)
      break;  // Dejamos de recorrer la cadena original
  }

  return (filtrado);
}


QString FiltroLecturaCadena (const QString &original, bool &error)
{
  QString filtrado;  // Texto que retornaremos

  bool hay_espacio    = false;  // Lo último encontrado es espacio en blanco
  bool omitir_espacio = true;   // Omitimos hay_espacio, esto lo haremos al
                                // principio de una nueva línea o tras haber
                                // encontrado espacio explícito
  error               = false;  // Se pondrá a true si se encuentra algún error

  const unsigned long longitud = original.length();
  const char *cadena = original.toLatin1().constData();

  for (unsigned long i = 0; i < longitud; i++)
  {
    switch (cadena[i])
    {
      case ' ' :
      case '\n':
      case '\r':
      case '\t':
        hay_espacio = true;
        break;

      case '\\':
        switch (cadena[i + 1])
        {
          case 'n':  // Nueva línea explícita
            filtrado       += '\n';
            omitir_espacio  = true;
            break;

          case 't':  // Tabulador explícito
            filtrado       += '\t';
            omitir_espacio  = true;
            break;

          case ' ':  // Espacio explícito
            filtrado       += ' ';
            omitir_espacio  = true;
            break;

          case '\\':  // Barra invertida
            if ((!omitir_espacio) && (hay_espacio))
            {
              filtrado += ' ';
            }
            filtrado       += '\\';
            hay_espacio     = false;
            omitir_espacio  = false;
            break;

          case '0':
          case '1':
            if ((cadena[i + 2] < '0') || (cadena[i + 2] > '9') ||
                (cadena[i + 3] < '0') || (cadena[i + 3] > '9'))
              error = true;
            else  // Código de carácter válido
            {
              filtrado       += ((cadena[i + 1] - '0') * 100) +
                                ((cadena[i + 2] - '0') * 10) +
                                (cadena[i + 3] - '0');
              hay_espacio     = false;
              omitir_espacio  = false;
            }
            i += 2;  // Hemos leído dos caracteres de más
            break;

          case '2':
            if ((cadena[i + 2] < '0') || (cadena[i + 2] > '5') ||
                (cadena[i + 3] < '0') ||
                (cadena[i + 3] > ((cadena[i + 2] == '5') ? '5' : '9')))
              error = true;
            else  // Código de carácter válido
            {
              filtrado       += 200 + ((cadena[i + 2] - '0') * 10) +
                                (cadena[i + 3] - '0');
              hay_espacio     = false;
              omitir_espacio  = false;
            }
            i += 2;  // Hemos leído dos caracteres de más
            break;

          default:  // Uso incorrecto de la barra invertida
            error = true;
        }
        i += 1;  // Nos saltamos el siguiente carácter
        break;

      default:
        if ((!omitir_espacio) && (hay_espacio))
          filtrado += ' ';  // Espacio implícito
        filtrado       += cadena[i];
        hay_espacio     = false;
        omitir_espacio  = false;
    }
  }

  return (filtrado);
}


QString FiltroLecturaEntero (const QString &original, bool &error)
{
  QString filtrado = "0";  // Texto que retornaremos (por defecto 0)

  bool hay_numero = false;  // Si ya se ha encontrado en la cadena un número
  bool fin_numero = false;  // Si se encuentra espacio en blanco tras el número
  bool negativo   = false;  // El signo del entero es negativo
  error           = false;  // Se pondrá a true si se encuentra algún error

  const unsigned long longitud = original.length();

  for (unsigned long i = 0; i < longitud; i++)
  {
    switch (original.at (i).toLatin1())
    {
      case ' ' :
      case '\n':
      case '\r':
      case '\t':
        if (hay_numero)
          fin_numero = true;
        break;

      case '+':
        if (hay_numero)
          error = true;
        break;

      case '-':
        if (hay_numero)
          error = true;
        else
          negativo = !negativo;
        break;

      default:
        if (fin_numero || (original.at (i) < '0') || (original.at (i) > '9'))
          error = true;
        else if (hay_numero)
          filtrado += original.at (i);
        else if (original.at (i) != '0')  // Omitimos así los ceros iniciales
        {
          filtrado = original.at (i);
          if (negativo)
            filtrado.prepend ('-');
          hay_numero = true;
        }
    }
    if (error)
      break;  // Dejamos de recorrer la cadena original
  }

  return (filtrado);
}


QString FiltroLecturaRutina (const QString &original)
{
  QString filtrado;  // Texto que retornaremos

  bool hay_espacio    = false;  // Lo último encontrado es espacio en blanco
  bool omitir_espacio = true;   // Omitimos hay_espacio, esto lo haremos al
                                // principio de una nueva línea

  const unsigned long longitud = original.length();

  for (unsigned long i = 0; i < longitud; i++)
  {
    switch (original.at (i).toLatin1())
    {
      case ' ' :
      case '\t':
        hay_espacio = true;
        break;

      case '\n':
      case '\r':
        // Omitimos caracteres de nueva línea consecutivos
        if (!omitir_espacio)
        {
          filtrado       += '\n';
          omitir_espacio  = true;
        }
  break;

      default:
        if ((!omitir_espacio) && (hay_espacio))
          filtrado += ' ';  // Espacio implícito
        filtrado       += original.at (i);
        hay_espacio     = false;
        omitir_espacio  = false;
    }
  }

  return (filtrado);
}

QString FiltroEscrituraBooleano (const QString &original)
{
  QString filtrado;  // Texto que retornaremos

  return (filtrado);
}

QString FiltroEscrituraCadena (const QString &original)
{
  QString filtrado;  // Texto que retornaremos

  return (filtrado);
}

QString FiltroEscrituraEntero (const QString &original)
{
  QString filtrado;  // Texto que retornaremos

  return (filtrado);
}

QString FiltroEscrituraRutina (const QString &original)
{
  QString filtrado;  // Texto que retornaremos

  return (filtrado);
}

---