contrib/llvm/tools/lldb/include/lldb/Core/FileSpecList.h

   1 //===-- FileSpecList.h ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_FileSpecList_h_
  11 #define liblldb_FileSpecList_h_
  12 #if defined(__cplusplus)
  13
  14 #include "lldb/lldb-private.h"
  15 #include "lldb/Host/FileSpec.h"
  16 #include <vector>
  17
  18 namespace lldb_private {
  19
  20 //----------------------------------------------------------------------
  21 /// @class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
  22 /// @brief A file collection class.
  23 ///
  24 /// A class that contains a mutable list of FileSpec objects.
  25 //----------------------------------------------------------------------
  26 class FileSpecList
  27 {
  28 public:
  29     //------------------------------------------------------------------
  30     /// Default constructor.
  31     ///
  32     /// Initialize this object with an empty file list.
  33     //------------------------------------------------------------------
  34     FileSpecList ();
  35
  36     //------------------------------------------------------------------
  37     /// Copy constructor.
  38     ///
  39     /// Initialize this object with a copy of the file list from \a rhs.
  40     ///
  41     /// @param[in] rhs
  42     ///     A const reference to another file list object.
  43     //------------------------------------------------------------------
  44     FileSpecList (const FileSpecList &rhs);
  45
  46     //------------------------------------------------------------------
  47     /// Destructor.
  48     //------------------------------------------------------------------
  49     ~FileSpecList ();
  50
  51     //------------------------------------------------------------------
  52     /// Assignment operator.
  53     ///
  54     /// Replace the file list in this object with the file list from
  55     /// \a rhs.
  56     ///
  57     /// @param[in] rhs
  58     ///     A file list object to copy.
  59     ///
  60     /// @return
  61     ///     A const reference to this object.
  62     //------------------------------------------------------------------
  63     const FileSpecList&
  64     operator= (const FileSpecList &rhs);
  65
  66     //------------------------------------------------------------------
  67     /// Append a FileSpec object to the list.
  68     ///
  69     /// Appends \a file to the end of the file list.
  70     ///
  71     /// @param[in] file
  72     ///     A new file to append to this file list.
  73     //------------------------------------------------------------------
  74     void
  75     Append (const FileSpec &file);
  76
  77     //------------------------------------------------------------------
  78     /// Append a FileSpec object if unique.
  79     ///
  80     /// Appends \a file to the end of the file list if it doesn't
  81     /// already exist in the file list.
  82     ///
  83     /// @param[in] file
  84     ///     A new file to append to this file list.
  85     ///
  86     /// @return
  87     ///     \b true if the file was appended, \b false otherwise.
  88     //------------------------------------------------------------------
  89     bool
  90     AppendIfUnique (const FileSpec &file);
  91
  92     //------------------------------------------------------------------
  93     /// Clears the file list.
  94     //------------------------------------------------------------------
  95     void
  96     Clear ();
  97
  98     //------------------------------------------------------------------
  99     /// Dumps the file list to the supplied stream pointer "s".
 100     ///
 101     /// @param[in] s
 102     ///     The stream that will be used to dump the object description.
 103     //------------------------------------------------------------------
 104     void
 105     Dump (Stream *s, const char *separator_cstr = "\n") const;
 106
 107     //------------------------------------------------------------------
 108     /// Find a file index.
 109     ///
 110     /// Find the index of the file in the file spec list that matches
 111     /// \a file starting \a idx entries into the file spec list.
 112     ///
 113     /// @param[in] idx
 114     ///     An index into the file list.
 115     ///
 116     /// @param[in] file
 117     ///     The file specification to search for.
 118     ///
 119     /// @param[in] full
 120     ///     Should FileSpec::Equal be called with "full" true or false.
 121     ///
 122     /// @param[in] remove_backup_dots
 123     ///     Should FileSpec::Equal be called with "remove_backup_dots" true or false.
 124     ///
 125     /// @return
 126     ///     The index of the file that matches \a file if it is found,
 127     ///     else UINT32_MAX is returned.
 128     //------------------------------------------------------------------
 129     size_t
 130     FindFileIndex (size_t idx, const FileSpec &file, bool full, bool remove_backup_dots = false) const;
 131
 132     //------------------------------------------------------------------
 133     /// Get file at index.
 134     ///
 135     /// Gets a file from the file list. If \a idx is not a valid index,
 136     /// an empty FileSpec object will be returned. The file objects
 137     /// that are returned can be tested using
 138     /// FileSpec::operator void*().
 139     ///
 140     /// @param[in] idx
 141     ///     An index into the file list.
 142     ///
 143     /// @return
 144     ///     A copy of the FileSpec object at index \a idx. If \a idx
 145     ///     is out of range, then an empty FileSpec object will be
 146     ///     returned.
 147     //------------------------------------------------------------------
 148     const FileSpec &
 149     GetFileSpecAtIndex (size_t idx) const;
 150
 151     //------------------------------------------------------------------
 152     /// Get file specification pointer at index.
 153     ///
 154     /// Gets a file from the file list. The file objects that are
 155     /// returned can be tested using FileSpec::operator void*().
 156     ///
 157     /// @param[in] idx
 158     ///     An index into the file list.
 159     ///
 160     /// @return
 161     ///     A pointer to a contained FileSpec object at index \a idx.
 162     ///     If \a idx is out of range, then an NULL is returned.
 163     //------------------------------------------------------------------
 164     const FileSpec *
 165     GetFileSpecPointerAtIndex (size_t idx) const;
 166
 167     //------------------------------------------------------------------
 168     /// Get the memory cost of this object.
 169     ///
 170     /// Return the size in bytes that this object takes in memory. This
 171     /// returns the size in bytes of this object, not any shared string
 172     /// values it may refer to.
 173     ///
 174     /// @return
 175     ///     The number of bytes that this object occupies in memory.
 176     ///
 177     /// @see ConstString::StaticMemorySize ()
 178     //------------------------------------------------------------------
 179     size_t
 180     MemorySize () const;
 181
 182     bool
 183     IsEmpty() const
 184     {
 185         return m_files.empty();
 186     }
 187
 188     //------------------------------------------------------------------
 189     /// Get the number of files in the file list.
 190     ///
 191     /// @return
 192     ///     The number of files in the file spec list.
 193     //------------------------------------------------------------------
 194     size_t
 195     GetSize () const;
 196
 197     bool
 198     Insert (size_t idx, const FileSpec &file)
 199     {
 200         if (idx < m_files.size())
 201         {
 202             m_files.insert(m_files.begin() + idx, file);
 203             return true;
 204         }
 205         else if (idx == m_files.size())
 206         {
 207             m_files.push_back(file);
 208             return true;
 209         }
 210         return false;
 211     }
 212
 213     bool
 214     Replace (size_t idx, const FileSpec &file)
 215     {
 216         if (idx < m_files.size())
 217         {
 218             m_files[idx] = file;
 219             return true;
 220         }
 221         return false;
 222     }
 223
 224     bool
 225     Remove (size_t idx)
 226     {
 227         if (idx < m_files.size())
 228         {
 229             m_files.erase(m_files.begin() + idx);
 230             return true;
 231         }
 232         return false;
 233     }
 234
 235     static size_t GetFilesMatchingPartialPath (const char *path, bool dir_okay, FileSpecList &matches);
 236
 237 protected:
 238     typedef std::vector<FileSpec> collection;   ///< The collection type for the file list.
 239     collection m_files; ///< A collection of FileSpec objects.
 240 };
 241
 242 } // namespace lldb_private
 243
 244
 245 #endif  // #if defined(__cplusplus)
 246 #endif  // liblldb_FileSpecList_h_