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

Referencia de la Clase Archivero

Clase que gestiona los accesos a las propiedades de las entidades del MUD. Más...

#include <Archivero.hpp>

Lista de todos los miembros.

Métodos públicos

 Archivero ()
 Constructor.
 ~Archivero ()
 Destructor.
unsigned char DaModoPropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve el modo de una propiedad.
QString DaPropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve el contenido de una propiedad.
unsigned char DaTipoPropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve el tipo de una propiedad.

Métodos privados

QString BuscaPropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve la entidad en la que está almacenada físicamente una propiedad.
bool CargaDocumento (QDomDocument &documento, const QString &nom_ent)
 Carga el documento XML de una entidad desde un fichero.
Propiedad * LeePropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve una propiedad almacenada en disco.
const Propiedad * ObtenPropiedad (const QString &nom_ent, const QString &nom_prop)
 Devuelve una propiedad.

Atributos privados

QCache< QString, Propiedad > ccache
 Caché de contenidos.
QCache< QString, QString > rcache
 Caché de referencias.

Clases

struct  Propiedad
 Clase para almacenar cada propiedad. Más...

Descripción detallada

Clase que gestiona los accesos a las propiedades de las entidades del MUD.

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

Documentación del constructor y destructor

Archivero::Archivero (   ) 
 

Constructor.

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

00038                       : ccache (TAM_CCACHE * 1024), rcache (TAM_RCACHE * 1024)
00039 {
00040 }

Archivero::~Archivero (   ) 
 

Destructor.

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

00044 {
00045   qDebug ("Destructor de Archivero");
00046 }

Documentación de las funciones miembro

QString Archivero::BuscaPropiedad (  const QString &  nom_ent,
const QString &  nom_prop
)  [private]
 

Devuelve la entidad en la que está almacenada físicamente una propiedad.

Busca en qué entidad está almacenada físicamente una propiedad, recorriendo las herencias como una búsqueda primero en anchura.

Parámetros:
nom_ent Nombre de la entidad a la que pertenece la propiedad (puede estar allí físicamente o no).
nom_prop Nombre de la propiedad.
Devuelve:
Una cadena que contiene el nombre de la entidad en la que está almacenada físicamente nom_prop, o bien una cadena nula si ha ocurrido algún error.

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

Hace referencia a CargaDocumento().

Referenciado por ObtenPropiedad().

00066 {
00067   QStringList lista_ents;  // Lista de entidades en las que buscar
00068 
00069   QDomDocument documento ("entidad");
00070   QDomNode     nodo;
00071   QDomElement  elemento;
00072   QDomAttr     atributo;
00073 
00074   // Añadimos a la lista la entidad a la que pertenece la propiedad
00075   lista_ents += nom_ent;
00076 
00077   for (QStringList::Iterator iter = lista_ents.begin();
00078        iter != lista_ents.end(); ++iter)
00079   {
00080     if (!CargaDocumento (documento, *iter))
00081       return (QString::null);
00082 
00083     // Recorremos el árbol DOM para añadir las herencias a la lista y mirar
00084     // si la propiedad está en esta entidad
00085     elemento = documento.documentElement();
00086     nodo     = elemento.firstChild();
00087     while (!nodo.isNull())
00088     {
00089       elemento = nodo.toElement();
00090       if (!elemento.isNull())
00091       {
00092         if (elemento.tagName() != "herencia")  // El elemento es una propiedad
00093         {
00094           atributo = elemento.attributeNode ("nombre");
00095           // Comparamos el nombre sin distinguir mayúsculas de minúsculas
00096           if ((atributo.value().length() == nom_prop.length()) &&
00097               (atributo.value().startsWith (nom_prop, Qt::CaseInsensitive)))
00098           {
00099             // Hemos encontrado la propiedad
00100             return (*iter);
00101           }
00102         }
00103         else  // El elemento es una herencia
00104         {
00105           atributo = elemento.attributeNode ("entidad");
00106 
00107           // Comprobamos si ya estaba en la lista, sin distinguir mayúsculas de
00108           // minúsculas
00109           if (!lista_ents.contains (atributo.value(),
00110                                     Qt::CaseInsensitive))  // No estaba ya
00111             lista_ents += atributo.value();  // Pues la añadimos
00112         }
00113       }
00114       nodo = nodo.nextSibling();
00115     }
00116   }
00117 
00118   // No hemos encontrado la propiedad
00119   qWarning ("La entidad \"%s\" no dispone de la propiedad \"%s\"",
00120             nom_ent.toLatin1().constData(), nom_prop.toLatin1().constData());
00121 
00122   return (QString::null);
00123 }

bool Archivero::CargaDocumento (  QDomDocument &  documento,
const QString &  nom_ent
)  [private]
 

Carga el documento XML de una entidad desde un fichero.

Parámetros:
documento QDomDocument donde se almacenará el documento (sustituyendo lo que allí hubiera).
nom_ent Nombre de la entidad.
Devuelve:
true si todo ha ido bien, false si ha ocurrido algún error.

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

Hace referencia a dir_datos.

Referenciado por BuscaPropiedad(), y LeePropiedad().

00135 {
00136   // Buscamos, sin distinguir mayúsculas/minúsculas, el nombre de fichero de la
00137   // entidad
00138   QStringList lista (dir_datos.entryList (QDir::Files).filter (nom_ent + ".xml",
00139                      Qt::CaseInsensitive));
00140 
00141   QStringList::iterator iter (lista.begin());
00142 
00143   for ( ; iter != lista.end(); ++iter)
00144     if ((*iter).length() == (nom_ent.length() + 4))  // 4 es la longitud de la
00145                                                      // extensión ".xml"
00146       break;  // Hemos encontrado el nombre de fichero de la entidad
00147 
00148   if (iter == lista.end())  // No encontrado
00149   {
00150     qWarning ("No se ha encontrado el fichero \"%s\"", dir_datos.filePath
00151               (nom_ent + ".xml").toLatin1().constData());
00152     return (false);
00153   }
00154 
00155   QFile fichero (dir_datos.filePath (*iter));
00156 
00157   if (!fichero.open (QIODevice::ReadOnly | QIODevice::Text))
00158   {
00159     // No se ha podido abrir el archivo
00160     qWarning ("\"%s\": %s", fichero.fileName().toLatin1().constData(),
00161               fichero.errorString().toLatin1().constData());
00162     return (false);
00163   }
00164 
00165   QString dsc_error;  // Descripción del error
00166   int     lin_error, col_error;  // Línea y columna del error, respectivamente
00167 
00168   if (!documento.setContent (&fichero, &dsc_error, &lin_error, &col_error))
00169   {
00170     fichero.close();
00171 
00172     qWarning ("\"%s\" (%d, %d): %s", fichero.fileName().toLatin1().constData(),
00173               lin_error, col_error, dsc_error.toLatin1().constData());
00174 
00175     return (false);
00176   }
00177 
00178   fichero.close();
00179   return (true);
00180 }

unsigned char Archivero::DaModoPropiedad (  const QString &  nom_ent,
const QString &  nom_prop
) 
 

Devuelve el modo de una propiedad.

Parámetros:
nom_ent Nombre de la entidad a la que pertenece la propiedad (puede estar allí físicamente o no).
nom_prop Nombre de la propiedad.
Devuelve:
El modo de la propiedad, o bien (unsigned char) -1 si ha ocurrido algún error.

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

Hace referencia a Archivero::Propiedad::modo, y ObtenPropiedad().

00194 {
00195   const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);
00196 
00197   if (prop != NULL)
00198     return (prop->modo);
00199   else
00200     return ((unsigned char) -1);
00201 }

QString Archivero::DaPropiedad (  const QString &  nom_ent,
const QString &  nom_prop
) 
 

Devuelve el contenido de una propiedad.

Parámetros:
nom_ent Nombre de la entidad a la que pertenece la propiedad (puede estar allí físicamente o no).
nom_prop Nombre de la propiedad.
Devuelve:
Una cadena con el contenido de la propiedad, o bien una cadena nula si ha ocurrido algún error.

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

Hace referencia a Archivero::Propiedad::contenido, y ObtenPropiedad().

Referenciado por Librero::DaPropiedad().

00236 {
00237   const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);
00238 
00239   if (prop != NULL)
00240     return (*(prop->contenido));
00241   else
00242     return (QString::null);
00243 }

unsigned char Archivero::DaTipoPropiedad (  const QString &  nom_ent,
const QString &  nom_prop
) 
 

Devuelve el tipo de una propiedad.

Parámetros:
nom_ent Nombre de la entidad a la que pertenece la propiedad (puede estar allí físicamente o no).
nom_prop Nombre de la propiedad.
Devuelve:
El tipo de la propiedad, o bien (unsigned char) -1 si ha ocurrido algún error.

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

Hace referencia a ObtenPropiedad(), y Archivero::Propiedad::tipo.

00215 {
00216   const Propiedad *prop = ObtenPropiedad (nom_ent, nom_prop);
00217 
00218   if (prop != NULL)
00219     return (prop->tipo);
00220   else
00221     return ((unsigned char) -1);
00222 }

Archivero::Propiedad * Archivero::LeePropiedad (  const QString &  nom_ent,
const QString &  nom_prop
)  [private]
 

Devuelve una propiedad almacenada en disco.

Parámetros:
nom_ent Nombre de la entidad en la que está almacenada físicamente la propiedad.
nom_prop Nombre de la propiedad.
Devuelve:
Un puntero a la propiedad, o NULL si ha ocurrido algún error.

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

Hace referencia a CargaDocumento(), Archivero::Propiedad::contenido, FiltroLecturaBooleano(), FiltroLecturaCadena(), FiltroLecturaEntero(), FiltroLecturaRutina(), Archivero::Propiedad::modo, MODO_RUTINA, MODO_VARIABLE, Archivero::Propiedad::tipo, TIPO_BOOLEANO, TIPO_CADENA, TIPO_ENTERO, y TIPO_NADA.

Referenciado por ObtenPropiedad().

00256 {
00257   Propiedad *propiedad = NULL;
00258 
00259   QDomDocument documento ("entidad");
00260   QDomNode     nodo;
00261   QDomElement  elemento;
00262   QDomAttr     atributo;
00263   QDomText     texto;
00264 
00265   if (!CargaDocumento (documento, nom_ent))
00266     return (NULL);
00267 
00268   elemento = documento.documentElement();
00269   nodo     = elemento.firstChild();
00270   while (!nodo.isNull())
00271   {
00272     elemento = nodo.toElement();
00273     if ((!elemento.isNull()) && (elemento.tagName() != "herencia"))
00274     {
00275       atributo = elemento.attributeNode ("nombre");
00276       // Comparamos el nombre sin distinguir mayúsculas de minúsculas
00277       if ((atributo.value().length() == nom_prop.length()) &&
00278           (atributo.value().startsWith (nom_prop, Qt::CaseInsensitive)))
00279       {
00280         // Hemos encontrado la propiedad
00281         propiedad = new Propiedad (nom_ent, nom_prop);
00282 
00283         if (elemento.tagName() == "rutina")
00284           propiedad->modo = MODO_RUTINA;
00285         else
00286           propiedad->modo = MODO_VARIABLE;
00287 
00288         atributo = elemento.attributeNode ("tipo");
00289         if (atributo.value() == "booleano")
00290           propiedad->tipo = TIPO_BOOLEANO;
00291         else if (atributo.value() == "entero")
00292           propiedad->tipo = TIPO_ENTERO;
00293         else if (atributo.value() == "cadena")
00294           propiedad->tipo = TIPO_CADENA;
00295         else
00296           propiedad->tipo = TIPO_NADA;
00297 
00298         propiedad->contenido = new QString;
00299 
00300         nodo  = nodo.firstChild();
00301         while (!nodo.isNull())
00302         {
00303           texto = nodo.toText();
00304           if (!texto.isNull())
00305             propiedad->contenido->append (texto.data());
00306 
00307           nodo = nodo.nextSibling();
00308         }
00309         break;  // Ya hemos concluido la búsqueda
00310       }
00311     }
00312     nodo = nodo.nextSibling();
00313   }
00314 
00315   if (propiedad == NULL)  // No hemos encontrado la propiedad
00316     return (NULL);
00317 
00318   // Filtramos el contenido de la propiedad
00319   if (propiedad->modo == MODO_RUTINA)
00320   {
00321     *(propiedad->contenido) = FiltroLecturaRutina (*(propiedad->contenido));
00322   }
00323   else if (propiedad->tipo == TIPO_CADENA)
00324   {
00325     bool error;
00326 
00327     *(propiedad->contenido) = FiltroLecturaCadena (*(propiedad->contenido),
00328                                                    error);
00329 
00330     if (error)
00331       qWarning ("\"%s\": Uso incorrecto de \"\\\" en la cadena \"%s\"",
00332                 nom_ent.toLatin1().constData(),
00333                 nom_prop.toLatin1().constData());
00334   }
00335   else if (propiedad->tipo == TIPO_ENTERO)
00336   {
00337     bool error;
00338 
00339     *(propiedad->contenido) = FiltroLecturaEntero (*(propiedad->contenido),
00340                                                    error);
00341 
00342     if (error)
00343       qWarning ("\"%s\": Formato incorrecto del entero \"%s\"",
00344                 nom_ent.toLatin1().constData(),
00345                 nom_prop.toLatin1().constData());
00346   }
00347   else  // propiedad->tipo = TIPO_BOOLEANO
00348   {
00349     bool error;
00350 
00351     *(propiedad->contenido) = FiltroLecturaBooleano (*(propiedad->contenido),
00352                                                      error);
00353 
00354     if (error)
00355       qWarning ("\"%s\": Formato incorrecto del booleano \"%s\"",
00356                 nom_ent.toLatin1().constData(),
00357                 nom_prop.toLatin1().constData());
00358   }
00359 
00360   propiedad->contenido->squeeze();
00361 
00362   return (propiedad);
00363 }

const Archivero::Propiedad * Archivero::ObtenPropiedad (  const QString &  nom_ent,
const QString &  nom_prop
)  [private]
 

Devuelve una propiedad.

Parámetros:
nom_ent Nombre de la entidad a la que pertenece la propiedad (puede estar allí físicamente o no).
nom_prop Nombre de la propiedad.
Devuelve:
Un puntero a la propiedad, o NULL si ha ocurrido algún error.

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

Hace referencia a BuscaPropiedad(), ccache, Archivero::Propiedad::contenido, LeePropiedad(), y rcache.

Referenciado por DaModoPropiedad(), DaPropiedad(), y DaTipoPropiedad().

00376 {
00377   // Clave para la búsqueda en las cachés
00378   QString clave (nom_ent + ">" + nom_prop);
00379 
00380   // Nombre de la entidad en la que está almacenada físicamente la propiedad
00381   QString *ent_fisica = rcache.object (clave);
00382 
00383   if (ent_fisica == 0)  // No se ha encontrado en la caché de referencias
00384   {
00385     ent_fisica = new QString (BuscaPropiedad (nom_ent, nom_prop));
00386     if (ent_fisica->isNull())  // No se ha encontrado la entidad o la propiedad
00387     {
00388       delete (ent_fisica);
00389       return (NULL);
00390     }
00391     rcache.insert (clave, ent_fisica, ent_fisica->length());
00392   }
00393 
00394   if (*ent_fisica != nom_ent)
00395     clave = (*ent_fisica + ">" + nom_prop);
00396 
00397   // Propiedad almacenada en la caché de contenidos
00398   Propiedad *propiedad = ccache.object (clave);
00399 
00400   if (propiedad == 0)  // No se ha encontrado en la caché de contenidos
00401   {
00402     propiedad = LeePropiedad (*ent_fisica, nom_prop);
00403     if (propiedad == NULL)
00404     {
00405       // BuscaPropiedad no encuentra las mismas propiedades que LeePropiedad, o
00406       // bien lo que indica rcache es falso
00407       qDebug ("Archivero::ObtenPropiedad(): LeePropiedad() ha devuelto NULL");
00408       return (NULL);
00409     }
00410     ccache.insert (clave, propiedad, propiedad->contenido->length());
00411   }
00412 
00413   return (propiedad);
00414 }

Documentación de los datos miembro

QCache<QString, Propiedad> Archivero::ccache [private]
 

Caché de contenidos.

Caché para almacenar las propiedades más recientemente usadas.

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

Referenciado por ObtenPropiedad().

QCache<QString, QString> Archivero::rcache [private]
 

Caché de referencias.

Caché para almacenar en qué entidad está físicamente cada propiedad.

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

Referenciado por ObtenPropiedad().

La documentación para esta clase fué generada a partir de los siguientes archivos:
Generado el Tue Nov 29 01:04:33 2005 para MUnDoCAAD MUD Engine por  doxygen 1.4.4