libzen-dev 0.4.34-1 / usr / include / ZenLib / ZtringListList.h

This file is indexed.

/usr/include/ZenLib/ZtringListList.h is in libzen-dev 0.4.34-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/*  Copyright (c) MediaArea.net SARL. All Rights Reserved.
 *
 *  Use of this source code is governed by a zlib-style license that can
 *  be found in the License.txt file in the root of the source tree.
 */

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// More methods for std::vector<std::vector<std::(w)string>>
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//---------------------------------------------------------------------------
#ifndef ZenLib_ZtringListListH
#define ZenLib_ZtringListListH
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#include "ZenLib/ZtringList.h"
//---------------------------------------------------------------------------

namespace ZenLib
{

//***************************************************************************
/// @brief Vector of vectors of strings manipulation (based on std::vector<std::vector<std::(w)string>>)
//***************************************************************************

class ZtringListList : public std::vector<ZtringList>
{
public :
    //Constructors/Destructor
    ZtringListList ();
    ZtringListList (const ZtringListList &Source);
    ZtringListList (const Ztring &Source);
    ZtringListList (const Char *Source);
    #ifdef _UNICODE
    ZtringListList (const char *Source); //convert a UTF-8 string into Unicode
    #endif

    //Operateurs
    bool            operator == (const ZtringListList &Source) const;
    bool            operator != (const ZtringListList &Source) const;
    ZtringListList &operator += (const ZtringListList &Source);
    ZtringListList &operator =  (const ZtringListList &Source);

    ZtringList     &operator () (size_type Pos0); ///< Same as [], but write a empty string if Pos doesn't exist yet
    Ztring         &operator () (size_type Pos0, size_type Pos1);
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][0]
    Ztring         &operator () (const Ztring &Pos0, size_type Pos1=1)             {return operator() (Pos0, 0 , Pos1);};
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][Pos0_1]
    Ztring         &operator () (const Ztring &Pos0, size_type Pos0_1, size_type Pos1);

    //In/Out
    /// @brief Read all
    Ztring Read () const;
    /// @brief Read a vector of string
    Ztring Read (size_type Pos0) const;
    /// @brief Read a string
    const Ztring &Read (size_type Pos0, size_type Pos1) const;
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][0]
    const Ztring &Read (const Ztring &Pos0, size_type Pos1=1) const;
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][Pos0_1]
    const Ztring &Read (const Ztring &Pos0, size_type Pos0_1, size_type Pos1) const;
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][0], with default value
    const Ztring &Read (const Ztring &Pos0, const Ztring &Default, size_type Pos1=1) const;
    /// @brief Return [Pos][Pos1], Pos=First occurency of Pos0 in [xxx][Pos0_1], with default value
    const Ztring &Read (const Ztring &Pos0, const Ztring &Default, size_type Pos0_1, size_type Pos1) const;
    /// @brief Read all strings at position Pos1
    Ztring Read1 (size_type Pos1) const;

    /// @brief Write all
    void Write (const Ztring &ToWrite);
    /// @brief Write a vector of string
    void Write (const ZtringList &ToWrite, size_type Pos0);
    /// @brief Write a vector of string
    void Write (const Ztring &ToWrite, size_type Pos0, size_type Pos1);
    /// @brief Add a vector of string
    void push_back (const ZtringList &ToAdd);
    /// @brief Add a vector of string (with separator is ZtringListList Separator)
    void push_back (const Ztring &ToAdd);
    /// @brief Add a vector of string (Char version)
    void push_back (const Char* ToAdd)                                          {push_back(Ztring(ToAdd));};
    /// @brief Insert a vector of string at position Pos0
    void Insert (const ZtringList &ToInsert, size_type Pos0)                       {insert(begin()+Pos0, ToInsert);};
    /// @brief Insert a string at all positions Pos1
    void Insert1 (const Ztring &ToInsert, size_type Pos1);
    /// @brief Delete a vector of string at position Pos0
    void Delete (size_type Pos0)                                                   {erase(begin()+Pos0);};
    /// @brief Delete all vectors of string, with [xxx][Pos1] == ToFind
    void Delete (const Ztring &ToFind, size_type Pos1=0, const Ztring &Comparator=__T("=="), ztring_t Options=Ztring_Nothing);
    /// @brief Delete a string at all positions Pos1
    void Delete1 (size_type Pos1);

    //Edition
    /// @brief Swap 2 positions
    void Swap (size_type Pos0_A, size_type Pos0_B);
    /// @brief Swap 2 columns for each line
    void Swap1 (size_type Pos1_A, size_type Pos1_B);
    /// @brief Sort
    void Sort (size_type Pos1, ztring_t Options=Ztring_Nothing);

    //Information
    /// @brief Find the first position of the string in the vector of vector, in a specific column
    size_type Find (const Ztring &ToFind, size_type Pos1=0, size_type Pos0Begin=0) const;
    /// @brief Find the first position of the string in the vector of vector, in a specific column, which is not empty
    size_type Find_Filled (size_type Pos1=0, size_type Pos0Begin=0) const;
    /// @brief Find the first position of the string in the vector of vector, in a specific column
    size_type Find (const Ztring &ToFind, size_type Pos1, size_type Pos0Begin, const Ztring &Comparator, ztring_t Options=Ztring_Nothing) const;
    /// @brief Return [xxx][Pos1Value] when founded the first position of the string in the vector of vector, in a specific column
    Ztring FindValue (const Ztring &ToFind, size_type Pos1Value=1, size_type Pos1=0, size_type Pos0Begin=0, const Ztring &Comparator=__T("=="), ztring_t Options=Ztring_Nothing) const;
    /// @brief Return a subsheet, with all lines with position of the string in the vector of vector, in a specific column
    ZtringListList SubSheet (const Ztring &ToFind, size_type Pos1=0, size_type Pos0Begin=0, const Ztring &Comparator=__T("=="), ztring_t Options=Ztring_Nothing) const;

    //Configuration
    /// @brief Set the Separator character
    void Separator_Set (size_type Level, const Ztring &NewSeparator);
    /// @brief Set the Quote character
    /// During Read() or Write() method, if Separator is in the sequence, we must quote it
    void Quote_Set (const Ztring &NewQuote);
    /// @brief Set the Maximum number of element to read
    /// During Read() or Write() method, if there is more elements, merge them with the last element
    void Max_Set (size_type Level, size_type Max);

protected :
    Ztring Separator[2];
    Ztring Quote;
    size_type Max[2];
};

} //namespace
#endif

APT Browse - Built by Thomas Orozco.