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
|
#pragma once
#include "StarImageProcessing.hpp"
#include "StarHash.hpp"
#include "StarDataStream.hpp"
#include "StarStringView.hpp"
#include "StarThread.hpp"
namespace Star {
STAR_CLASS(Directives);
STAR_CLASS(DirectivesGroup);
STAR_EXCEPTION(DirectivesException, StarException);
// Kae: My attempt at reducing memory allocation and per-frame string parsing for extremely long directives
class Directives {
public:
struct Shared;
struct Entry {
mutable ImageOperation operation;
size_t begin;
size_t length;
ImageOperation const& loadOperation(Shared const& parent) const;
StringView string(Shared const& parent) const;
Entry(ImageOperation&& newOperation, size_t begin, size_t end);
Entry(ImageOperation const& newOperation, size_t begin, size_t end);
Entry(Entry const& other);
};
struct Shared {
List<Entry> entries;
String string;
size_t hash = 0;
mutable Mutex mutex;
bool empty() const;
Shared();
Shared(List<Entry>&& givenEntries, String&& givenString);
};
Directives();
Directives(String const& directives);
Directives(String&& directives);
Directives(const char* directives);
Directives(Directives const& directives);
Directives(Directives&& directives) noexcept;
~Directives();
Directives& operator=(String const& s);
Directives& operator=(String&& s);
Directives& operator=(const char* s);
Directives& operator=(Directives&& other) noexcept;
Directives& operator=(Directives const& other);
void loadOperations() const;
void parse(String&& directives);
StringView prefix() const;
String string() const;
String const* stringPtr() const;
String buildString() const;
String& addToString(String& out) const;
size_t hash() const;
size_t size() const;
bool empty() const;
operator bool() const;
Shared const& operator*() const;
Shared const* operator->() const;
bool equals(Directives const& other) const;
bool equals(String const& string) const;
bool operator==(Directives const& other) const;
bool operator==(String const& string) const;
friend DataStream& operator>>(DataStream& ds, Directives& directives);
friend DataStream& operator<<(DataStream& ds, Directives const& directives);
//friend bool operator==(Directives const& d1, String const& d2);
//friend bool operator==(Directives const& directives, String const& string);
//friend bool operator==(String const& string, Directives const& directives);
std::shared_ptr<Shared const> m_shared;
};
class DirectivesGroup {
public:
DirectivesGroup();
DirectivesGroup(String const& directives);
DirectivesGroup(String&& directives);
bool empty() const;
operator bool() const;
bool compare(DirectivesGroup const& other) const;
void append(Directives const& other);
void clear();
DirectivesGroup& operator+=(Directives const& other);
String toString() const;
void addToString(String& string) const;
typedef function<void(Directives::Entry const&, Directives const&)> DirectivesCallback;
typedef function<bool(Directives::Entry const&, Directives const&)> AbortableDirectivesCallback;
void forEach(DirectivesCallback callback) const;
bool forEachAbortable(AbortableDirectivesCallback callback) const;
Image applyNewImage(const Image& image) const;
void applyExistingImage(Image& image) const;
size_t hash() const;
const List<Directives>& list() const;
friend bool operator==(DirectivesGroup const& a, DirectivesGroup const& b);
friend bool operator!=(DirectivesGroup const& a, DirectivesGroup const& b);
friend DataStream& operator>>(DataStream& ds, DirectivesGroup& directives);
friend DataStream& operator<<(DataStream& ds, DirectivesGroup const& directives);
private:
void buildString(String& string, const DirectivesGroup& directives) const;
List<Directives> m_directives;
size_t m_count = 0;
};
template <>
struct hash<DirectivesGroup> {
size_t operator()(DirectivesGroup const& s) const;
};
typedef DirectivesGroup ImageDirectives;
inline Directives::Shared const& Directives::operator*() const {
return *m_shared;
}
inline Directives::Shared const* Directives::operator->() const {
if (!m_shared)
throw DirectivesException("Directives::operator-> nullptr");
return m_shared.get();
}
}
|