Página principal | Lista alfabética | Lista de componentes | Lista de archivos | Miembros de las clases | Archivos de los miembros | Páginas relacionadas

Referencia del Archivo Archivero.hpp

Declaración de las clases Archivero y Archivero::Propiedad. Más...

#include <QCache>
#include <QDomDocument>

Ir al código fuente de este archivo.

Clases

class  Archivero
 Clase que gestiona los accesos a las propiedades de las entidades del MUD. Más...
struct  Archivero::Propiedad
 Clase para almacenar cada propiedad. Más...

Definiciones

#define TAM_CCACHE   64
 Tamaño máximo posible en KiB de la caché de contenidos.
#define TAM_RCACHE   16
 Tamaño máximo posible en KiB de la caché de referencias.
#define MODO_RUTINA   0
 La propiedad es una rutina.
#define MODO_VARIABLE   1
 La propiedad es una variable.
#define TIPO_NADA   0
 La rutina no tiene ningún valor de retorno.
#define TIPO_BOOLEANO   1
 La variable es de tipo booleano o la rutina devuelve un booleano.
#define TIPO_ENTERO   2
 La variable es de tipo entero o la rutina devuelve un entero.
#define TIPO_CADENA   3
 La variable es de tipo cadena o la rutina devuelve una cadena.

Funciones

QString FiltroLecturaBooleano (const QString &original, bool &error)
 Filtra un booleano almacenado en disco.
QString FiltroLecturaCadena (const QString &original, bool &error)
 Filtra una cadena almacenada en disco.
QString FiltroLecturaEntero (const QString &original, bool &error)
 Filtra un entero almacenado en disco.
QString FiltroLecturaRutina (const QString &original)
 Filtra una rutina almacenada en disco.
QString FiltroEscrituraBooleano (const QString &original)
 Filtra un booleano para ser almacenado en disco.
QString FiltroEscrituraCadena (const QString &original)
 Filtra una cadena para ser almacenada en disco.
QString FiltroEscrituraEntero (const QString &original)
 Filtra un entero para ser almacenado en disco.
QString FiltroEscrituraRutina (const QString &original)
 Filtra una rutina para ser almacenada en disco.

Descripción detallada

Declaración de las clases Archivero y Archivero::Propiedad.

Definición en el archivo Archivero.hpp.

Documentación de las definiciones

#define MODO_RUTINA   0
 

La propiedad es una rutina.

Definición en la línea 44 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

#define MODO_VARIABLE   1
 

La propiedad es una variable.

Definición en la línea 46 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

#define TAM_CCACHE   64
 

Tamaño máximo posible en KiB de la caché de contenidos.

Definición en la línea 37 del archivo Archivero.hpp.

#define TAM_RCACHE   16
 

Tamaño máximo posible en KiB de la caché de referencias.

Definición en la línea 39 del archivo Archivero.hpp.

#define TIPO_BOOLEANO   1
 

La variable es de tipo booleano o la rutina devuelve un booleano.

Definición en la línea 52 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

#define TIPO_CADENA   3
 

La variable es de tipo cadena o la rutina devuelve una cadena.

Definición en la línea 56 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

#define TIPO_ENTERO   2
 

La variable es de tipo entero o la rutina devuelve un entero.

Definición en la línea 54 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

#define TIPO_NADA   0
 

La rutina no tiene ningún valor de retorno.

Definición en la línea 50 del archivo Archivero.hpp.

Referenciado por Archivero::LeePropiedad().

Documentación de las funciones

QString FiltroEscrituraBooleano (  const QString &  original  ) 
 

Filtra un booleano para ser almacenado en disco.

Definición en la línea 733 del archivo Archivero.cpp.

00734 {
00735   QString filtrado;  // Texto que retornaremos
00736 
00737   return (filtrado);
00738 }

QString FiltroEscrituraCadena (  const QString &  original  ) 
 

Filtra una cadena para ser almacenada en disco.

Definición en la línea 741 del archivo Archivero.cpp.

00742 {
00743   QString filtrado;  // Texto que retornaremos
00744 
00745   return (filtrado);
00746 }

QString FiltroEscrituraEntero (  const QString &  original  ) 
 

Filtra un entero para ser almacenado en disco.

Definición en la línea 749 del archivo Archivero.cpp.

00750 {
00751   QString filtrado;  // Texto que retornaremos
00752 
00753   return (filtrado);
00754 }

QString FiltroEscrituraRutina (  const QString &  original  ) 
 

Filtra una rutina para ser almacenada en disco.

Definición en la línea 757 del archivo Archivero.cpp.

00758 {
00759   QString filtrado;  // Texto que retornaremos
00760 
00761   return (filtrado);
00762 }

QString FiltroLecturaBooleano (  const QString &  original,
bool &  error
) 
 

Filtra un booleano almacenado en disco.

Parámetros:
original Texto de la cadena a filtrar.
error Booleano en el que se almacenará si ha habido error o no.
Devuelve:
El texto del booleano filtrado.

Definición en la línea 454 del archivo Archivero.cpp.

Referenciado por Archivero::LeePropiedad().

00455 {
00456   QString filtrado ("F");  // Texto que retornaremos (por defecto FALSO)
00457 
00458   bool hay_booleano = false;  // Si ya se ha encontrado en la cadena un valor
00459                               // booleano ("VERDADERO" o "FALSO")
00460   error             = false;  // Se pondrá a true si se encuentra algún error
00461 
00462   const unsigned long longitud = original.length();
00463 
00464   for (unsigned long i = 0; i < longitud; i++)
00465   {
00466     switch (original.at (i).toLatin1())
00467     {
00468       case ' ' :
00469       case '\n':
00470       case '\r':
00471       case '\t':
00472         break;
00473 
00474       case 'V':
00475         if (hay_booleano || ((i + 8) > longitud) ||
00476             (original.at (i + 1) != 'E') ||
00477             (original.at (i + 2) != 'R') ||
00478             (original.at (i + 3) != 'D') ||
00479             (original.at (i + 4) != 'A') ||
00480             (original.at (i + 5) != 'D') ||
00481             (original.at (i + 6) != 'E') ||
00482             (original.at (i + 7) != 'R') ||
00483             (original.at (i + 8) != 'O'))
00484           error = true;
00485         else
00486         {
00487           hay_booleano = true;
00488           filtrado = "V";
00489         }
00490         break;
00491 
00492       case 'F':
00493         if (hay_booleano || ((i + 5) > longitud) ||
00494             (original.at (i + 1) != 'A') ||
00495             (original.at (i + 2) != 'L') ||
00496             (original.at (i + 3) != 'S') ||
00497             (original.at (i + 4) != 'O'))
00498           error = true;
00499         else
00500           hay_booleano = true;
00501         break;
00502 
00503       default:
00504         error = true;
00505     }
00506     if (error)
00507       break;  // Dejamos de recorrer la cadena original
00508   }
00509 
00510   return (filtrado);
00511 }

QString FiltroLecturaCadena (  const QString &  original,
bool &  error
) 
 

Filtra una cadena almacenada en disco.

Parámetros:
original Texto de la cadena a filtrar.
error Booleano en el que se almacenará si ha habido error o no.
Devuelve:
El texto de la cadena filtrado.

Definición en la línea 521 del archivo Archivero.cpp.

Referenciado por Archivero::LeePropiedad().

00522 {
00523   QString filtrado;  // Texto que retornaremos
00524 
00525   bool hay_espacio    = false;  // Lo último encontrado es espacio en blanco
00526   bool omitir_espacio = true;   // Omitimos hay_espacio, esto lo haremos al
00527                                 // principio de una nueva línea o tras haber
00528                                 // encontrado espacio explícito
00529   error               = false;  // Se pondrá a true si se encuentra algún error
00530 
00531   const unsigned long longitud = original.length();
00532   const char *cadena = original.toLatin1().constData();
00533 
00534   for (unsigned long i = 0; i < longitud; i++)
00535   {
00536     switch (cadena[i])
00537     {
00538       case ' ' :
00539       case '\n':
00540       case '\r':
00541       case '\t':
00542         hay_espacio = true;
00543         break;
00544 
00545       case '\\':
00546         switch (cadena[i + 1])
00547         {
00548           case 'n':  // Nueva línea explícita
00549             filtrado       += '\n';
00550             omitir_espacio  = true;
00551             break;
00552 
00553           case 't':  // Tabulador explícito
00554             filtrado       += '\t';
00555             omitir_espacio  = true;
00556             break;
00557 
00558           case ' ':  // Espacio explícito
00559             filtrado       += ' ';
00560             omitir_espacio  = true;
00561             break;
00562 
00563           case '\\':  // Barra invertida
00564             if ((!omitir_espacio) && (hay_espacio))
00565             {
00566               filtrado += ' ';
00567             }
00568             filtrado       += '\\';
00569             hay_espacio     = false;
00570             omitir_espacio  = false;
00571             break;
00572 
00573           case '0':
00574           case '1':
00575             if ((cadena[i + 2] < '0') || (cadena[i + 2] > '9') ||
00576                 (cadena[i + 3] < '0') || (cadena[i + 3] > '9'))
00577               error = true;
00578             else  // Código de carácter válido
00579             {
00580               filtrado       += ((cadena[i + 1] - '0') * 100) +
00581                                 ((cadena[i + 2] - '0') * 10) +
00582                                 (cadena[i + 3] - '0');
00583               hay_espacio     = false;
00584               omitir_espacio  = false;
00585             }
00586             i += 2;  // Hemos leído dos caracteres de más
00587             break;
00588 
00589           case '2':
00590             if ((cadena[i + 2] < '0') || (cadena[i + 2] > '5') ||
00591                 (cadena[i + 3] < '0') ||
00592                 (cadena[i + 3] > ((cadena[i + 2] == '5') ? '5' : '9')))
00593               error = true;
00594             else  // Código de carácter válido
00595             {
00596               filtrado       += 200 + ((cadena[i + 2] - '0') * 10) +
00597                                 (cadena[i + 3] - '0');
00598               hay_espacio     = false;
00599               omitir_espacio  = false;
00600             }
00601             i += 2;  // Hemos leído dos caracteres de más
00602             break;
00603 
00604           default:  // Uso incorrecto de la barra invertida
00605             error = true;
00606         }
00607         i += 1;  // Nos saltamos el siguiente carácter
00608         break;
00609 
00610       default:
00611         if ((!omitir_espacio) && (hay_espacio))
00612           filtrado += ' ';  // Espacio implícito
00613         filtrado       += cadena[i];
00614         hay_espacio     = false;
00615         omitir_espacio  = false;
00616     }
00617   }
00618 
00619   return (filtrado);
00620 }

QString FiltroLecturaEntero (  const QString &  original,
bool &  error
) 
 

Filtra un entero almacenado en disco.

Parámetros:
original Texto de la cadena a filtrar.
error Booleano en el que se almacenará si ha habido error o no.
Devuelve:
El texto del entero filtrado.

Definición en la línea 630 del archivo Archivero.cpp.

Referenciado por Archivero::LeePropiedad().

00631 {
00632   QString filtrado = "0";  // Texto que retornaremos (por defecto 0)
00633 
00634   bool hay_numero = false;  // Si ya se ha encontrado en la cadena un número
00635   bool fin_numero = false;  // Si se encuentra espacio en blanco tras el número
00636   bool negativo   = false;  // El signo del entero es negativo
00637   error           = false;  // Se pondrá a true si se encuentra algún error
00638 
00639   const unsigned long longitud = original.length();
00640 
00641   for (unsigned long i = 0; i < longitud; i++)
00642   {
00643     switch (original.at (i).toLatin1())
00644     {
00645       case ' ' :
00646       case '\n':
00647       case '\r':
00648       case '\t':
00649         if (hay_numero)
00650           fin_numero = true;
00651         break;
00652 
00653       case '+':
00654         if (hay_numero)
00655           error = true;
00656         break;
00657 
00658       case '-':
00659         if (hay_numero)
00660           error = true;
00661         else
00662           negativo = !negativo;
00663         break;
00664 
00665       default:
00666         if (fin_numero || (original.at (i) < '0') || (original.at (i) > '9'))
00667           error = true;
00668         else if (hay_numero)
00669           filtrado += original.at (i);
00670         else if (original.at (i) != '0')  // Omitimos así los ceros iniciales
00671         {
00672           filtrado = original.at (i);
00673           if (negativo)
00674             filtrado.prepend ('-');
00675           hay_numero = true;
00676         }
00677     }
00678     if (error)
00679       break;  // Dejamos de recorrer la cadena original
00680   }
00681 
00682   return (filtrado);
00683 }

QString FiltroLecturaRutina (  const QString &  original  ) 
 

Filtra una rutina almacenada en disco.

Parámetros:
original Texto de la rutina a filtrar.
Devuelve:
El texto de la rutina filtrado.

Definición en la línea 691 del archivo Archivero.cpp.

Referenciado por Archivero::LeePropiedad().

00692 {
00693   QString filtrado;  // Texto que retornaremos
00694 
00695   bool hay_espacio    = false;  // Lo último encontrado es espacio en blanco
00696   bool omitir_espacio = true;   // Omitimos hay_espacio, esto lo haremos al
00697                                 // principio de una nueva línea
00698 
00699   const unsigned long longitud = original.length();
00700 
00701   for (unsigned long i = 0; i < longitud; i++)
00702   {
00703     switch (original.at (i).toLatin1())
00704     {
00705       case ' ' :
00706       case '\t':
00707         hay_espacio = true;
00708         break;
00709 
00710       case '\n':
00711       case '\r':
00712         // Omitimos caracteres de nueva línea consecutivos
00713         if (!omitir_espacio)
00714         {
00715           filtrado       += '\n';
00716           omitir_espacio  = true;
00717         }
00718   break;
00719 
00720       default:
00721         if ((!omitir_espacio) && (hay_espacio))
00722           filtrado += ' ';  // Espacio implícito
00723         filtrado       += original.at (i);
00724         hay_espacio     = false;
00725         omitir_espacio  = false;
00726     }
00727   }
00728 
00729   return (filtrado);
00730 }

Generado el Tue Nov 29 01:04:33 2005 para MUnDoCAAD MUD Engine por  doxygen 1.4.4