1 //===-- DataBufferHeap.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_DataBufferHeap_h_ 11 #define liblldb_DataBufferHeap_h_ 12 #if defined(__cplusplus) 13 14 #include <vector> 15 16 #include "lldb/lldb-private.h" 17 #include "lldb/Core/DataBuffer.h" 18 19 namespace lldb_private { 20 21 //---------------------------------------------------------------------- 22 /// @class DataBufferHeap DataBufferHeap.h "lldb/Core/DataBufferHeap.h" 23 /// @brief A subclass of DataBuffer that stores a data buffer on the heap. 24 /// 25 /// This class keeps its data in a heap based buffer that is owned by 26 /// the object. This class is best used to store chunks of data that 27 /// are created or read from sources that can't intelligently and lazily 28 /// fault new data pages in. Large amounts of data that comes from files 29 /// should probably use the DataBufferMemoryMap class. 30 //---------------------------------------------------------------------- 31 class DataBufferHeap : public DataBuffer 32 { 33 public: 34 //------------------------------------------------------------------ 35 /// Default constructor 36 /// 37 /// Initializes the heap based buffer with no bytes. 38 //------------------------------------------------------------------ 39 DataBufferHeap (); 40 41 //------------------------------------------------------------------ 42 /// Construct with size \a n and fill with \a ch. 43 /// 44 /// Initialize this class with \a n bytes and fills the buffer with 45 /// \a ch. 46 /// 47 /// @param[in] n 48 /// The number of bytes that heap based buffer should contain. 49 /// 50 /// @param[in] ch 51 /// The character to use when filling the buffer initially. 52 //------------------------------------------------------------------ 53 DataBufferHeap (lldb::offset_t n, uint8_t ch); 54 55 //------------------------------------------------------------------ 56 /// Construct by making a copy of \a src_len bytes from \a src. 57 /// 58 /// @param[in] src 59 /// A pointer to the data to copy. 60 /// 61 /// @param[in] src_len 62 /// The number of bytes in \a src to copy. 63 //------------------------------------------------------------------ 64 DataBufferHeap (const void *src, lldb::offset_t src_len); 65 66 //------------------------------------------------------------------ 67 /// Destructor. 68 /// 69 /// Virtual destructor since this class inherits from a pure virtual 70 /// base class #DataBuffer. 71 //------------------------------------------------------------------ 72 virtual 73 ~DataBufferHeap(); 74 75 //------------------------------------------------------------------ 76 /// @copydoc DataBuffer::GetBytes() 77 //------------------------------------------------------------------ 78 virtual uint8_t * 79 GetBytes (); 80 81 //------------------------------------------------------------------ 82 /// @copydoc DataBuffer::GetBytes() const 83 //------------------------------------------------------------------ 84 virtual const uint8_t * 85 GetBytes () const; 86 87 //------------------------------------------------------------------ 88 /// @copydoc DataBuffer::GetByteSize() const 89 //------------------------------------------------------------------ 90 virtual lldb::offset_t 91 GetByteSize () const; 92 93 //------------------------------------------------------------------ 94 /// Set the number of bytes in the data buffer. 95 /// 96 /// Sets the number of bytes that this object should be able to 97 /// contain. This can be used prior to copying data into the buffer. 98 /// 99 /// @param[in] byte_size 100 /// The new size in bytes that this data buffer should attempt 101 /// to resize itself to. 102 /// 103 /// @return 104 /// The size in bytes after that this heap buffer was 105 /// successfully resized to. 106 //------------------------------------------------------------------ 107 lldb::offset_t 108 SetByteSize (lldb::offset_t byte_size); 109 110 //------------------------------------------------------------------ 111 /// Makes a copy of the \a src_len bytes in \a src. 112 /// 113 /// Copies the data in \a src into an internal buffer. 114 /// 115 /// @param[in] src 116 /// A pointer to the data to copy. 117 /// 118 /// @param[in] src_len 119 /// The number of bytes in \a src to copy. 120 //------------------------------------------------------------------ 121 void 122 CopyData (const void *src, lldb::offset_t src_len); 123 124 void 125 Clear(); 126 127 private: 128 //------------------------------------------------------------------ 129 // This object uses a std::vector<uint8_t> to store its data. This 130 // takes care of free the data when the object is deleted. 131 //------------------------------------------------------------------ 132 typedef std::vector<uint8_t> buffer_t; ///< Buffer type 133 buffer_t m_data; ///< The heap based buffer where data is stored 134 }; 135 136 } // namespace lldb_private 137 138 #endif // #if defined(__cplusplus) 139 #endif // liblldb_DataBufferHeap_h_ 140