---

ZtringListList.h

Go to the documentation of this file.

// ZenLib::ZtringListList - vector<vector<std::string>> is better
// Copyright (C) 2002-2003 Jérôme Martinez, Zen@MediaArea.net
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ZtringListList
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Version 0.0.1
// -------------
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//---------------------------------------------------------------------------
#ifndef CChaine_Tableau2H
#define CChaine_Tableau2H
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#include <ZenLib/ZtringList.h>
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#define CCHAINE_TABLEAU2_CASSE  1   //Active la sensibilite a la casse (min/maj)
#define CCHAINE_TABLEAU2_DESC   2   //Tri descendant au lieu d'ascendant
//---------------------------------------------------------------------------

//***************************************************************************
// Classe ZtringListList
//***************************************************************************

namespace ZenLib
{

class ZtringListList : public std::vector<ZtringList>
{
public :
    //Gestion de la classe
    void CChaine_Tableau2_Commun (int Taille_Max2=0, int Taille_Max1=0, const Ztring &Separateur1="\r\n", const Ztring &Separateur2=";", const char *Source="");
    ZtringListList (int Taille_Max2=0, int Taille_Max1=0, const Ztring &Separateur1="\r\n", const Ztring &Separateur2=";", const Ztring &Source="");
    ZtringListList (const ZtringListList &Source);
    ZtringListList (const Ztring &Source);
    ZtringListList (const char* Source);
    ~ZtringListList ();

    //Operateurs
    ZtringListList &operator = (const ZtringListList &Source);
    ZtringListList &operator += (const ZtringListList &Source);
    ZtringListList operator + (const ZtringListList &Source) const;
    bool operator == (const ZtringListList &Source) const;
    bool operator != (const ZtringListList &Source) const;
/*
    CChaine_Tableau1 &operator [] (int Pos0); //Lecture ecriture
    CChaine_Tableau1 &operator [] (int Pos0) const; //Lecture seulement
*/
    ZtringList &operator () (size_t Pos0); //Lecture ecriture
//    CChaine_Tableau1 &operator () (int Pos0) const; //Lecture seulement

    Ztring &operator () (size_t Pos0, size_t Pos1); //Lecture ecriture
    Ztring &operator () (const Ztring &Pos0, size_t Pos1=1); //Lecture ecriture
    Ztring &operator () (const Ztring &Pos0, size_t Pos0_1, size_t Pos1); //Lecture ecriture
//    CChaine &operator () (int Pos0, int Pos1) const; //Lecture seulement

    //Edition
    Ztring Lire () const; //Lecture de tout
    Ztring Lire (size_t Pos0) const; //Lecture d'une ligne
    Ztring Lire (size_t Pos0, size_t Pos1) const; //Lecture d'un champs
    Ztring Lire (const Ztring &Pos0, size_t Pos1=1) const; //Lecture d'un champs en position 0
    Ztring Lire (const Ztring &Pos0, Ztring Default, size_t Pos1=1) const; //Lecture d'un champs en position 0 avec une option par defaut
//    CChaine Lire (const CChaine &Pos0, int Pos0_1, int Pos1) const; //Lecture d'un champs en position Pos0_1

    Ztring Lire1 (size_t Pos1) const; //Lecture d'une colonne
    int Ecrire (const Ztring &AEcrire); //Ecriture de tout
    int Ecrire (const char *AEcrire, size_t Pos0); //Ecriture d'une ligne
    int Ecrire (const Ztring &AEcrire, size_t Pos0); //Ecriture d'une ligne
    int Ecrire (const ZtringList &AEcrire, size_t Pos0); //Ecriture d'une ligne
    int Ecrire (const Ztring &AEcrire, size_t Pos0, size_t Pos1); //Ecriture d'un champs
    void push_back (char* ToAdd);
    void push_back (const ZtringList &ToAdd);

/*    int Ecrire (const CChaine &AEcrire, const CChaine &Pos0, int Pos1=1); //Ecriture d'un champs en recherchant Pos0T en position 0
    int Ecrire (const CChaine &AEcrire, const CChaine &Pos0, int Pos0_1, int Pos1); //Ecriture d'un champs en recherchant Pos0T en position Pos0_1
/*
    int EcrireEx (const CChaine &AEcrire, int Pos0, int Pos1); //Remplir un champ avec options (Espace = Ne pas ecrire)
    int Ajouter (const CChaine_Tableau1 &AAjouter); //Ajout d'une ligne a la fin
    int Ajouter1 (const CChaine &AAjouter); //Ajout d'une nouvelle colonne
    int Inserer (const CChaine_Tableau1 &AInserer, int Pos0); // Insertion d'un champs et decalage des champs suivants
    int Inserer1 (const CChaine &AInserer, int Pos1); // Insertion d'une colonne
    int Permuter (int Pos0_A, int Pos0_B); // Permutation de deux ligne
    int Permuter1 (int Pos1_A, int Pos1_B); // Permutation de deux colonnes
    int Supprimer (); //Suppression de tout
    int Supprimer (int Pos0); //Suppression d'une ligne et decalage des champs suivants
    int Supprimer (const CChaine &ARechercher, int Pos1=0, const CChaine &Comparaison="=="); //Suppression de plusieurs lignes avec un selecteur au niveau d'une colonne
    int Supprimer1 (int Pos1); //Suppression d'une colonne
    int Trier (int Pos1=0, int Options=0); //Tri en fonction d'une colonne
*/
    int Rechercher (const Ztring &ARechercher, size_t Pos1=0, size_t Pos0Debut=0, const Ztring &Comparaison="==", int Options=0) const; //recherche une ligne contenant ARechercher dans une colonne
    Ztring RechercherValeur (const Ztring &ARechercher, size_t Pos1Valeur=1, size_t Pos1=0, size_t Pos0Debut=0, const Ztring &Comparaison="==", int Options=0) const; //retourne le champs Pos1Valeur correspondant a la ligne trouvee
/*
    int Remplacer (const CChaine &ARechercher, const CChaine &ARemplacer, int Pos1=-1, const CChaine &Comparaison="==", int Options=0); //Remplace toutes les occurences

    //Informations
    int Taille_Get (int Rang=0) const; //Nombre de champs
    int Taille_Max_Set (int Taille_Max_Nouveau0, int Taille_Max_Nouveau1=-1);
*/
    int Separateur_Set (const Ztring &Separateur_Nouveau0, const Ztring &Separateur_Nouveau1=";");
    //size_t size() const;

    //Divers
    ZtringListList SousTableau (const Ztring &ARechercher, int Pos1=0, int Pos0Debut=0, const Ztring &Comparaison="==", int Options=0) const; //retourne tout

protected :
   //CChaine_Tableau1** Chaine;
   //int Taille[2];
   //int Taille_Max[2];
   Ztring Separateur[2];
   int Nettoyer(); //Rendu necessaire par operateur () et []
   //size_t size_;

};

} //namespace
#endif

---