Halide 16.0.0
Halide compiler and libraries
Loading...
Searching...
No Matches
string_table.h
Go to the documentation of this file.
1#ifndef HALIDE_RUNTIME_STRING_TABLE_H
2#define HALIDE_RUNTIME_STRING_TABLE_H
3
4#include "../HalideRuntime.h"
5#include "block_storage.h"
6#include "pointer_table.h"
7#include "string_storage.h"
8
9namespace Halide {
10namespace Runtime {
11namespace Internal {
12
13// Storage class for an array of strings (based on block storage)
14// -- Intended for building and maintaining tables of strings
16public:
17 // Disable copy constructors
18 StringTable(const StringTable &) = delete;
19 StringTable &operator=(const StringTable &) = delete;
20
22 StringTable(void *user_context, size_t capacity, const SystemMemoryAllocatorFns &allocator = StringStorage::default_allocator());
23 StringTable(void *user_context, const char **array, size_t count, const SystemMemoryAllocatorFns &allocator = StringStorage::default_allocator());
25
26 void resize(void *user_context, size_t capacity);
27 void destroy(void *user_context);
28 void clear(void *user_context);
29
30 // fills the contents of the table (copies strings from given array)
31 void fill(void *user_context, const char **array, size_t coun);
32
33 // assign the entry at given index the given string
34 void assign(void *user_context, size_t index, const char *str, size_t length = 0); // if length is zero, strlen is used
35
36 // appends the given string to the end of the table
37 void append(void *user_context, const char *str, size_t length = 0); // if length is zero, strlen is used
38
39 // prepend the given string to the end of the table
40 void prepend(void *user_context, const char *str, size_t length = 0); // if length is zero, strlen is used
41
42 // parses the given c-string based on given delimiter, stores each substring in the resulting table
43 size_t parse(void *user_context, const char *str, const char *delim);
44
45 // index-based access operator
46 const char *operator[](size_t index) const;
47
48 // returns the raw string table pointer
49 const char **data() const;
50
51 // scans the table for existance of the given string within any entry (linear scan w/string compare!)
52 bool contains(const char *str) const;
53
54 size_t size() const {
55 return contents.size();
56 }
57
58private:
59 PointerTable contents; //< owns string data
60 PointerTable pointers; //< pointers to raw string data
61};
62
63// --
64
66 : contents(nullptr, 0, sma),
67 pointers(nullptr, 0, sma) {
68 // EMPTY!
69}
70
71StringTable::StringTable(void *user_context, size_t capacity, const SystemMemoryAllocatorFns &sma)
72 : contents(user_context, capacity, sma),
73 pointers(user_context, capacity, sma) {
74 if (capacity) {
75 resize(user_context, capacity);
76 }
77}
78
79StringTable::StringTable(void *user_context, const char **array, size_t count, const SystemMemoryAllocatorFns &sma)
80 : contents(user_context, count, sma),
81 pointers(user_context, count, sma) {
82 fill(user_context, array, count);
83}
84
88
89void StringTable::resize(void *user_context, size_t capacity) {
90 pointers.resize(user_context, capacity);
91 while (contents.size() < capacity) {
93 contents.append(user_context, storage_ptr);
94 }
95}
96
97void StringTable::clear(void *user_context) {
98 for (size_t n = 0; n < contents.size(); ++n) {
99 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[n]);
100 StringStorage::destroy(user_context, storage_ptr);
101 contents.assign(user_context, n, nullptr);
102 }
103 contents.clear(user_context);
104 pointers.clear(user_context);
105}
106
107void StringTable::destroy(void *user_context) {
108 for (size_t n = 0; n < contents.size(); ++n) {
109 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[n]);
110 StringStorage::destroy(user_context, storage_ptr);
111 contents.assign(user_context, n, nullptr);
112 }
113 contents.destroy(user_context);
114 pointers.destroy(user_context);
115}
116
117const char *StringTable::operator[](size_t index) const {
118 if (index < pointers.size()) {
119 return static_cast<const char *>(pointers[index]);
120 }
121 return nullptr;
122}
123
124void StringTable::fill(void *user_context, const char **array, size_t count) {
125 resize(user_context, count);
126 for (size_t n = 0; n < count && n < contents.size(); ++n) {
127 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[n]);
128 storage_ptr->assign(user_context, array[n]);
129 pointers.assign(user_context, n, storage_ptr->data());
130 }
131}
132
133void StringTable::assign(void *user_context, size_t index, const char *str, size_t length) {
134 if (length == 0) {
135 length = strlen(str);
136 }
137 if (index < contents.size()) {
138 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[index]);
139 storage_ptr->assign(user_context, str, length);
140 pointers.assign(user_context, index, storage_ptr->data());
141 }
142}
143
144void StringTable::append(void *user_context, const char *str, size_t length) {
146 storage_ptr->assign(user_context, str, length);
147 contents.append(user_context, storage_ptr);
148 pointers.append(user_context, storage_ptr->data());
149}
150
151void StringTable::prepend(void *user_context, const char *str, size_t length) {
153 storage_ptr->assign(user_context, str, length);
154 contents.prepend(user_context, storage_ptr);
155 pointers.prepend(user_context, storage_ptr->data());
156}
157
158size_t StringTable::parse(void *user_context, const char *str, const char *delim) {
159 if (StringUtils::is_empty(str)) {
160 return 0;
161 }
162
163 size_t delim_length = strlen(delim);
164 size_t total_length = strlen(str);
165 size_t entry_count = StringUtils::count_tokens(str, delim);
166 if (entry_count < 1) {
167 return 0;
168 }
169
170 resize(user_context, entry_count);
171
172 // save each entry into the table
173 size_t index = 0;
174 const char *ptr = str;
175 while (!StringUtils::is_empty(ptr) && (index < entry_count)) {
176 size_t ptr_offset = ptr - str;
177 const char *next_delim = strstr(ptr, delim);
178 size_t token_length = (next_delim == nullptr) ? (total_length - ptr_offset) : (next_delim - ptr);
179 if (token_length > 0 && index < contents.size()) {
180 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[index]);
181 storage_ptr->assign(user_context, ptr, token_length);
182 pointers.assign(user_context, index, storage_ptr->data());
183 ++index;
184 }
185 ptr = (next_delim != nullptr) ? (next_delim + delim_length) : nullptr;
186 }
187 return entry_count;
188}
189
190bool StringTable::contains(const char *str) const {
191 if (StringUtils::is_empty(str)) {
192 return false;
193 }
194 for (size_t n = 0; n < contents.size(); ++n) {
195 StringStorage *storage_ptr = static_cast<StringStorage *>(contents[n]);
196 if (storage_ptr->contains(str)) {
197 return true;
198 }
199 }
200
201 return false;
202}
203
204const char **StringTable::data() const {
205 return reinterpret_cast<const char **>(pointers.data());
206}
207
208// --
209
210} // namespace Internal
211} // namespace Runtime
212} // namespace Halide
213
214#endif // HALIDE_RUNTIME_STRING_STORAGE_H
const SystemMemoryAllocatorFns & current_allocator() const
void prepend(void *user_context, const void *entry_ptr)
void resize(void *user_context, size_t entry_count, bool realloc=true)
void append(void *user_context, const void *entry_ptr)
void assign(void *user_context, size_t index, const void *entry_ptr)
static const SystemMemoryAllocatorFns & default_allocator()
static StringStorage * create(void *user_context, const SystemMemoryAllocatorFns &ma)
static void destroy(void *user_context, StringStorage *string_storage)
void append(void *user_context, const char *str, size_t length=0)
StringTable(const StringTable &)=delete
void fill(void *user_context, const char **array, size_t coun)
size_t parse(void *user_context, const char *str, const char *delim)
void assign(void *user_context, size_t index, const char *str, size_t length=0)
const char * operator[](size_t index) const
void resize(void *user_context, size_t capacity)
StringTable & operator=(const StringTable &)=delete
void prepend(void *user_context, const char *str, size_t length=0)
bool contains(const char *str) const
size_t strlen(const char *string)
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
@ Internal
Not visible externally, similar to 'static' linkage in C.
Expr cast(Expr a)
Cast an expression to the halide type corresponding to the C++ type T.
Definition IROperator.h:358
const char * strstr(const char *, const char *)
static size_t count_tokens(const char *str, const char *delim)
static bool is_empty(const char *str)