aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Core/DataBufferHeap.h
blob: dac9a28befb9b7f4827655ebd8c3a046d00167b7 (plain) (blame)
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
133
134
135
136
137
138
139
//===-- DataBufferHeap.h ----------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_DataBufferHeap_h_
#define liblldb_DataBufferHeap_h_
#if defined(__cplusplus)

#include <vector>

#include "lldb/lldb-private.h"
#include "lldb/Core/DataBuffer.h"

namespace lldb_private {

//----------------------------------------------------------------------
/// @class DataBufferHeap DataBufferHeap.h "lldb/Core/DataBufferHeap.h"
/// @brief A subclass of DataBuffer that stores a data buffer on the heap.
///
/// This class keeps its data in a heap based buffer that is owned by
/// the object. This class is best used to store chunks of data that
/// are created or read from sources that can't intelligently and lazily
/// fault new data pages in. Large amounts of data that comes from files
/// should probably use the DataBufferMemoryMap class.
//----------------------------------------------------------------------
class DataBufferHeap : public DataBuffer
{
public:
    //------------------------------------------------------------------
    /// Default constructor
    ///
    /// Initializes the heap based buffer with no bytes.
    //------------------------------------------------------------------
    DataBufferHeap ();

    //------------------------------------------------------------------
    /// Construct with size \a n and fill with \a ch.
    ///
    /// Initialize this class with \a n bytes and fills the buffer with
    /// \a ch.
    ///
    /// @param[in] n
    ///     The number of bytes that heap based buffer should contain.
    ///
    /// @param[in] ch
    ///     The character to use when filling the buffer initially.
    //------------------------------------------------------------------
    DataBufferHeap (lldb::offset_t n, uint8_t ch);

    //------------------------------------------------------------------
    /// Construct by making a copy of \a src_len bytes from \a src.
    ///
    /// @param[in] src
    ///     A pointer to the data to copy.
    ///
    /// @param[in] src_len
    ///     The number of bytes in \a src to copy.
    //------------------------------------------------------------------
    DataBufferHeap (const void *src, lldb::offset_t src_len);

    //------------------------------------------------------------------
    /// Destructor.
    ///
    /// Virtual destructor since this class inherits from a pure virtual
    /// base class #DataBuffer.
    //------------------------------------------------------------------
    virtual
    ~DataBufferHeap();

    //------------------------------------------------------------------
    /// @copydoc DataBuffer::GetBytes()
    //------------------------------------------------------------------
    virtual uint8_t *
    GetBytes ();

    //------------------------------------------------------------------
    /// @copydoc DataBuffer::GetBytes() const
    //------------------------------------------------------------------
    virtual const uint8_t *
    GetBytes () const;

    //------------------------------------------------------------------
    /// @copydoc DataBuffer::GetByteSize() const
    //------------------------------------------------------------------
    virtual lldb::offset_t
    GetByteSize () const;

    //------------------------------------------------------------------
    /// Set the number of bytes in the data buffer.
    ///
    /// Sets the number of bytes that this object should be able to
    /// contain. This can be used prior to copying data into the buffer.
    ///
    /// @param[in] byte_size
    ///     The new size in bytes that this data buffer should attempt
    ///     to resize itself to.
    ///
    /// @return
    ///     The size in bytes after that this heap buffer was
    ///     successfully resized to.
    //------------------------------------------------------------------
    lldb::offset_t
    SetByteSize (lldb::offset_t byte_size);

    //------------------------------------------------------------------
    /// Makes a copy of the \a src_len bytes in \a src.
    ///
    /// Copies the data in \a src into an internal buffer.
    ///
    /// @param[in] src
    ///     A pointer to the data to copy.
    ///
    /// @param[in] src_len
    ///     The number of bytes in \a src to copy.
    //------------------------------------------------------------------
    void
    CopyData (const void *src, lldb::offset_t src_len);

    void
    Clear();

private:
    //------------------------------------------------------------------
    // This object uses a std::vector<uint8_t> to store its data. This
    // takes care of free the data when the object is deleted.
    //------------------------------------------------------------------
    typedef std::vector<uint8_t> buffer_t; ///< Buffer type
    buffer_t m_data; ///< The heap based buffer where data is stored
};

} // namespace lldb_private

#endif  // #if defined(__cplusplus)
#endif  // liblldb_DataBufferHeap_h_