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     /// @return
 123     ///     The index of the file that matches \a file if it is found,
 124     ///     else UINT32_MAX is returned.
 125     //------------------------------------------------------------------
 126     size_t
 127     FindFileIndex (size_t idx, const FileSpec &file, bool full) const;
 128
 129     //------------------------------------------------------------------
 130     /// Get file at index.
 131     ///
 132     /// Gets a file from the file list. If \a idx is not a valid index,
 133     /// an empty FileSpec object will be returned. The file objects
 134     /// that are returned can be tested using
 135     /// FileSpec::operator void*().
 136     ///
 137     /// @param[in] idx
 138     ///     An index into the file list.
 139     ///
 140     /// @return
 141     ///     A copy of the FileSpec object at index \a idx. If \a idx
 142     ///     is out of range, then an empty FileSpec object will be
 143     ///     returned.
 144     //------------------------------------------------------------------
 145     const FileSpec &
 146     GetFileSpecAtIndex (size_t idx) const;
 147
 148     //------------------------------------------------------------------
 149     /// Get file specification pointer at index.
 150     ///
 151     /// Gets a file from the file list. The file objects that are
 152     /// returned can be tested using FileSpec::operator void*().
 153     ///
 154     /// @param[in] idx
 155     ///     An index into the file list.
 156     ///
 157     /// @return
 158     ///     A pointer to a contained FileSpec object at index \a idx.
 159     ///     If \a idx is out of range, then an NULL is returned.
 160     //------------------------------------------------------------------
 161     const FileSpec *
 162     GetFileSpecPointerAtIndex (size_t idx) const;
 163
 164     //------------------------------------------------------------------
 165     /// Get the memory cost of this object.
 166     ///
 167     /// Return the size in bytes that this object takes in memory. This
 168     /// returns the size in bytes of this object, not any shared string
 169     /// values it may refer to.
 170     ///
 171     /// @return
 172     ///     The number of bytes that this object occupies in memory.
 173     ///
 174     /// @see ConstString::StaticMemorySize ()
 175     //------------------------------------------------------------------
 176     size_t
 177     MemorySize () const;
 178
 179     bool
 180     IsEmpty() const
 181     {
 182         return m_files.empty();
 183     }
 184
 185     //------------------------------------------------------------------
 186     /// Get the number of files in the file list.
 187     ///
 188     /// @return
 189     ///     The number of files in the file spec list.
 190     //------------------------------------------------------------------
 191     size_t
 192     GetSize () const;
 193
 194     bool
 195     Insert (size_t idx, const FileSpec &file)
 196     {
 197         if (idx < m_files.size())
 198         {
 199             m_files.insert(m_files.begin() + idx, file);
 200             return true;
 201         }
 202         else if (idx == m_files.size())
 203         {
 204             m_files.push_back(file);
 205             return true;
 206         }
 207         return false;
 208     }
 209
 210     bool
 211     Replace (size_t idx, const FileSpec &file)
 212     {
 213         if (idx < m_files.size())
 214         {
 215             m_files[idx] = file;
 216             return true;
 217         }
 218         return false;
 219     }
 220
 221     bool
 222     Remove (size_t idx)
 223     {
 224         if (idx < m_files.size())
 225         {
 226             m_files.erase(m_files.begin() + idx);
 227             return true;
 228         }
 229         return false;
 230     }
 231
 232     static size_t GetFilesMatchingPartialPath (const char *path, bool dir_okay, FileSpecList &matches);
 233
 234 protected:
 235     typedef std::vector<FileSpec> collection;   ///< The collection type for the file list.
 236     collection m_files; ///< A collection of FileSpec objects.
 237 };
 238
 239 } // namespace lldb_private
 240
 241
 242 #endif  // #if defined(__cplusplus)
 243 #endif  // liblldb_FileSpecList_h_