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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/* Copyright (c) 2015-2017, 2019 The Khronos Group Inc.
* Copyright (c) 2015-2017, 2019 Valve Corporation
* Copyright (c) 2015-2017, 2019 LunarG, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Author: Mark Lobodzinski <mark@lunarg.com>
* Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
* Author: Dave Houlton <daveh@lunarg.com>
*/
#pragma once
#include <cassert>
#include <cstddef>
#include <functional>
#include <stdbool.h>
#include <string>
#include <vector>
#include <set>
#include "cast_utils.h"
#include "vk_format_utils.h"
#include "vk_layer_logging.h"
#ifndef WIN32
#include <strings.h> // For ffs()
#else
#include <intrin.h> // For __lzcnt()
#endif
#ifdef __cplusplus
// Traits objects to allow string_join to operate on collections of const char *
template <typename String>
struct StringJoinSizeTrait {
static size_t size(const String &str) { return str.size(); }
};
template <>
struct StringJoinSizeTrait<const char *> {
static size_t size(const char *str) {
if (!str) return 0;
return strlen(str);
}
};
// Similar to perl/python join
// * String must support size, reserve, append, and be default constructable
// * StringCollection must support size, const forward iteration, and store
// strings compatible with String::append
// * Accessor trait can be set if default accessors (compatible with string
// and const char *) don't support size(StringCollection::value_type &)
//
// Return type based on sep type
template <typename String = std::string, typename StringCollection = std::vector<String>,
typename Accessor = StringJoinSizeTrait<typename StringCollection::value_type>>
static inline String string_join(const String &sep, const StringCollection &strings) {
String joined;
const size_t count = strings.size();
if (!count) return joined;
// Prereserved storage, s.t. we will execute in linear time (avoids reallocation copies)
size_t reserve = (count - 1) * sep.size();
for (const auto &str : strings) {
reserve += Accessor::size(str); // abstracted to allow const char * type in StringCollection
}
joined.reserve(reserve + 1);
// Seps only occur *between* strings entries, so first is special
auto current = strings.cbegin();
joined.append(*current);
++current;
for (; current != strings.cend(); ++current) {
joined.append(sep);
joined.append(*current);
}
return joined;
}
// Requires StringCollection::value_type has a const char * constructor and is compatible the string_join::String above
template <typename StringCollection = std::vector<std::string>, typename SepString = std::string>
static inline SepString string_join(const char *sep, const StringCollection &strings) {
return string_join<SepString, StringCollection>(SepString(sep), strings);
}
// Perl/Python style join operation for general types using stream semantics
// Note: won't be as fast as string_join above, but simpler to use (and code)
// Note: Modifiable reference doesn't match the google style but does match std style for stream handling and algorithms
template <typename Stream, typename String, typename ForwardIt>
Stream &stream_join(Stream &stream, const String &sep, ForwardIt first, ForwardIt last) {
if (first != last) {
stream << *first;
++first;
while (first != last) {
stream << sep << *first;
++first;
}
}
return stream;
}
// stream_join For whole collections with forward iterators
template <typename Stream, typename String, typename Collection>
Stream &stream_join(Stream &stream, const String &sep, const Collection &values) {
return stream_join(stream, sep, values.cbegin(), values.cend());
}
typedef void *dispatch_key;
static inline dispatch_key get_dispatch_key(const void *object) { return (dispatch_key) * (VkLayerDispatchTable **)object; }
VK_LAYER_EXPORT VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func);
VK_LAYER_EXPORT VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func);
static inline bool IsPowerOfTwo(unsigned x) { return x && !(x & (x - 1)); }
extern "C" {
#endif
#define VK_LAYER_API_VERSION VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION)
typedef enum VkStringErrorFlagBits {
VK_STRING_ERROR_NONE = 0x00000000,
VK_STRING_ERROR_LENGTH = 0x00000001,
VK_STRING_ERROR_BAD_DATA = 0x00000002,
} VkStringErrorFlagBits;
typedef VkFlags VkStringErrorFlags;
VK_LAYER_EXPORT void layer_debug_report_actions(debug_report_data *report_data,
std::vector<VkDebugReportCallbackEXT> &logging_callback,
const VkAllocationCallbacks *pAllocator, const char *layer_identifier);
VK_LAYER_EXPORT void layer_debug_messenger_actions(debug_report_data *report_data,
std::vector<VkDebugUtilsMessengerEXT> &logging_messenger,
const VkAllocationCallbacks *pAllocator, const char *layer_identifier);
VK_LAYER_EXPORT VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array);
VK_LAYER_EXPORT bool white_list(const char *item, const std::set<std::string> &whitelist);
static inline int u_ffs(int val) {
#ifdef WIN32
unsigned long bit_pos = 0;
if (_BitScanForward(&bit_pos, val) != 0) {
bit_pos += 1;
}
return bit_pos;
#else
return ffs(val);
#endif
}
#ifdef __cplusplus
}
#endif
|
