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
|
#ifndef UPB_HPP_
#define UPB_HPP_
#include <memory>
#include "upb/upb.h"
namespace upb {
class Status {
public:
Status() { upb_status_clear(&status_); }
upb_status* ptr() { return &status_; }
// Returns true if there is no error.
bool ok() const { return upb_ok(&status_); }
// Guaranteed to be NULL-terminated.
const char *error_message() const { return upb_status_errmsg(&status_); }
// The error message will be truncated if it is longer than
// UPB_STATUS_MAX_MESSAGE-4.
void SetErrorMessage(const char *msg) { upb_status_seterrmsg(&status_, msg); }
void SetFormattedErrorMessage(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
upb_status_vseterrf(&status_, fmt, args);
va_end(args);
}
// Resets the status to a successful state with no message.
void Clear() { upb_status_clear(&status_); }
private:
upb_status status_;
};
class Arena {
public:
// A simple arena with no initial memory block and the default allocator.
Arena() : ptr_(upb_arena_new(), upb_arena_free) {}
Arena(char *initial_block, size_t size)
: ptr_(upb_arena_init(initial_block, size, &upb_alloc_global),
upb_arena_free) {}
upb_arena* ptr() { return ptr_.get(); }
// Allows this arena to be used as a generic allocator.
//
// The arena does not need free() calls so when using Arena as an allocator
// it is safe to skip them. However they are no-ops so there is no harm in
// calling free() either.
upb_alloc *allocator() { return upb_arena_alloc(ptr_.get()); }
// Add a cleanup function to run when the arena is destroyed.
// Returns false on out-of-memory.
template <class T>
bool Own(T *obj) {
return upb_arena_addcleanup(ptr_.get(), obj, [](void* obj) {
delete static_cast<T*>(obj);
});
}
void Fuse(Arena& other) { upb_arena_fuse(ptr(), other.ptr()); }
private:
std::unique_ptr<upb_arena, decltype(&upb_arena_free)> ptr_;
};
// InlinedArena seeds the arenas with a predefined amount of memory. No
// heap memory will be allocated until the initial block is exceeded.
template <int N>
class InlinedArena : public Arena {
public:
InlinedArena() : Arena(initial_block_, N) {}
private:
InlinedArena(const InlinedArena*) = delete;
InlinedArena& operator=(const InlinedArena*) = delete;
char initial_block_[N];
};
} // namespace upb
#endif // UPB_HPP_
|
