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
19namespace 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//----------------------------------------------------------------------
31class DataBufferHeap : public DataBuffer
32{
33public:
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
127private:
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