Skip to content

Commit 80994e5

Browse files
ItchyTrackItchyTrack
authored
Merge pull request #209 from Martian-Technologies/New-Eval
New eval (I think its better now)
2 parents 924d4d7 + 98bebe5 commit 80994e5

162 files changed

Lines changed: 190168 additions & 6986 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎CircuitLib/WindowManager.cir‎

Lines changed: 183277 additions & 0 deletions
Large diffs are not rendered by default.

‎cmake/dependencies.cmake‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,9 @@ function(add_main_dependencies)
4343
GITHUB_REPOSITORY google/brotli
4444
GIT_TAG v1.2.0
4545
EXCLUDE_FROM_ALL YES
46+
OPTIONS
47+
"BUILD_SHARED_LIBS OFF"
48+
"BROTLI_BUILD_TOOLS OFF"
4649
SOURCE_DIR "${EXTERNAL_DIR}/brotli"
4750
)
4851
if (brotli_ADDED)

‎fuzzing/failingCaseFinder.cpp‎

Lines changed: 40 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
#include "failingCaseFinder.h"
22
#include "environment/environment.h"
33
#include "backend/evaluator/evaluator.h"
4+
#include "backend/evaluator/simulator/evalLogicSimulator.h"
45
#include "backend/container/block/blockDefs.h"
56

67
std::unique_ptr<FuzzTestcase> FailingCaseFinder::findFailingCases(unsigned int maxAttempts, const std::vector<FuzzBlockType>& blockTypesUsed) {
@@ -55,9 +56,8 @@ std::unique_ptr<FuzzTestcase> FailingCaseFinder::tryMakeFailingCase(const std::v
5556
Environment environment { false };
5657
circuit_id_t circuitId = environment.getBackend().getCircuitManager().createNewCircuit(false);
5758
SharedCircuit circuit = environment.getBackend().getCircuit(circuitId);
58-
evaluator_id_t evalId = environment.getBackend().createEvaluator(circuitId).value();
59-
SharedEvaluator tEval = environment.getBackend().getEvaluator(evalId); // test evaluator
60-
SharedEvaluator rEval = nullptr; // reference evaluator
59+
simulator_id_t simulatorId = environment.getBackend().createSimulator(circuitId).value();
60+
EvalLogicSimulator* tSimulator = environment.getBackend().getSimulator(simulatorId); // test evaluator
6161

6262
std::vector<BlockType> blockTypesUsable = makeBlockTypesUsableVector(blockTypesUsed, environment);
6363

@@ -149,15 +149,18 @@ std::unique_ptr<FuzzTestcase> FailingCaseFinder::tryMakeFailingCase(const std::v
149149
}
150150
}
151151

152-
evaluator_id_t refEvalId = environment.getBackend().createEvaluator(circuitId).value();
153-
rEval = environment.getBackend().getEvaluator(refEvalId);
154-
tEval->setRealistic(runRealistic);
155-
rEval->setRealistic(runRealistic);
152+
153+
Evaluator rEvaluator(environment.getBackend().getCircuitManager(), *circuit, environment.getBackend().getDataUpdateEventManager());
154+
simulator_id_t refSimulatorId = simulator_id_t(1000000 + simulatorId.get());
155+
EvalLogicSimulator rSimulator(refSimulatorId, environment.getBackend().getCircuitManager(), circuitId, environment.getBackend().getDataUpdateEventManager());
156+
157+
tSimulator->setRealistic(runRealistic);
158+
rSimulator.setRealistic(runRealistic);
156159
testcase->setRealistic(runRealistic);
157-
tEval->resetStates();
158-
rEval->resetStates();
159-
std::vector<simulator_id_t> simulatorIdsTest;
160-
std::vector<simulator_id_t> simulatorIdsRef;
160+
tSimulator->resetStates();
161+
rSimulator.resetStates();
162+
std::vector<simulator_gate_id_t> simulatorIdsTest;
163+
std::vector<simulator_gate_id_t> simulatorIdsRef;
161164
std::unordered_map<block_id_t, Position> blockIdToPosition;
162165

163166
logInfo("Mapping block IDs to positions...", "FailingCaseFinder::tryMakeFailingCase");
@@ -167,19 +170,19 @@ std::unique_ptr<FuzzTestcase> FailingCaseFinder::tryMakeFailingCase(const std::v
167170
if (block == nullptr) continue;
168171
Position pos = block->getPosition();
169172
blockIdToPosition[blockId] = pos;
170-
simulatorIdsTest.push_back(tEval->getBlockSimulatorId(pos));
171-
simulatorIdsRef.push_back(rEval->getBlockSimulatorId(pos));
173+
simulatorIdsTest.push_back(std::get<simulator_gate_id_t>(tSimulator->getVirtualConnectionSimulatorId(Address(pos), 0)));
174+
simulatorIdsRef.push_back(std::get<simulator_gate_id_t>(tSimulator->getVirtualConnectionSimulatorId(Address(pos), 0)));
172175
const BlockData* blockData = blockDataManager.getBlockData(block->type());
173176
if (blockData == nullptr) continue;
174177
if (blockData->isDefaultData()) {
175-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdTest = tEval->getPinSimulatorId(pos);
176-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdRef = rEval->getPinSimulatorId(pos);
177-
if (std::holds_alternative<simulator_id_t>(simIdTest) && std::holds_alternative<simulator_id_t>(simIdRef)) {
178-
simulatorIdsTest.push_back(std::get<simulator_id_t>(simIdTest));
179-
simulatorIdsRef.push_back(std::get<simulator_id_t>(simIdRef));
180-
} else if (std::holds_alternative<std::vector<simulator_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_id_t>>(simIdRef)) {
181-
std::vector<simulator_id_t>& vecTest = std::get<std::vector<simulator_id_t>>(simIdTest);
182-
std::vector<simulator_id_t>& vecRef = std::get<std::vector<simulator_id_t>>(simIdRef);
178+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdTest = tSimulator->getPinSimulatorId(pos);
179+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdRef = rSimulator.getPinSimulatorId(pos);
180+
if (std::holds_alternative<simulator_gate_id_t>(simIdTest) && std::holds_alternative<simulator_gate_id_t>(simIdRef)) {
181+
simulatorIdsTest.push_back(std::get<simulator_gate_id_t>(simIdTest));
182+
simulatorIdsRef.push_back(std::get<simulator_gate_id_t>(simIdRef));
183+
} else if (std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdRef)) {
184+
std::vector<simulator_gate_id_t>& vecTest = std::get<std::vector<simulator_gate_id_t>>(simIdTest);
185+
std::vector<simulator_gate_id_t>& vecRef = std::get<std::vector<simulator_gate_id_t>>(simIdRef);
183186
simulatorIdsTest.insert(simulatorIdsTest.end(), vecTest.begin(), vecTest.end());
184187
simulatorIdsRef.insert(simulatorIdsRef.end(), vecRef.begin(), vecRef.end());
185188
} else {
@@ -193,14 +196,14 @@ std::unique_ptr<FuzzTestcase> FailingCaseFinder::tryMakeFailingCase(const std::v
193196
}
194197
std::optional<Position> portPositionOpt = block->getConnectionPosition(connectionId);
195198
Position portPosition = portPositionOpt.value();
196-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdTest = tEval->getPinSimulatorId(portPosition);
197-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdRef = rEval->getPinSimulatorId(portPosition);
198-
if (std::holds_alternative<simulator_id_t>(simIdTest) && std::holds_alternative<simulator_id_t>(simIdRef)) {
199-
simulatorIdsTest.push_back(std::get<simulator_id_t>(simIdTest));
200-
simulatorIdsRef.push_back(std::get<simulator_id_t>(simIdRef));
201-
} else if (std::holds_alternative<std::vector<simulator_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_id_t>>(simIdRef)) {
202-
std::vector<simulator_id_t>& vecTest = std::get<std::vector<simulator_id_t>>(simIdTest);
203-
std::vector<simulator_id_t>& vecRef = std::get<std::vector<simulator_id_t>>(simIdRef);
199+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdTest = tSimulator->getPinSimulatorId(portPosition);
200+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdRef = rSimulator.getPinSimulatorId(portPosition);
201+
if (std::holds_alternative<simulator_gate_id_t>(simIdTest) && std::holds_alternative<simulator_gate_id_t>(simIdRef)) {
202+
simulatorIdsTest.push_back(std::get<simulator_gate_id_t>(simIdTest));
203+
simulatorIdsRef.push_back(std::get<simulator_gate_id_t>(simIdRef));
204+
} else if (std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdRef)) {
205+
std::vector<simulator_gate_id_t>& vecTest = std::get<std::vector<simulator_gate_id_t>>(simIdTest);
206+
std::vector<simulator_gate_id_t>& vecRef = std::get<std::vector<simulator_gate_id_t>>(simIdRef);
204207
if (vecTest.size() != vecRef.size()){
205208
return testcase;
206209
}
@@ -222,23 +225,23 @@ std::unique_ptr<FuzzTestcase> FailingCaseFinder::tryMakeFailingCase(const std::v
222225
block_id_t blockId = blockIds[gen() % blockIds.size()];
223226
Position pos = blockIdToPosition.at(blockId);
224227
logic_state_t state = logic_state_t(gen() % 4);
225-
rEval->setState(pos, state);
226-
tEval->setState(pos, state);
228+
rSimulator.setState(pos, state);
229+
tSimulator->setState(pos, state);
227230
testcase->addTestAction(SetBlockStateAction { pos, state });
228231
}
229232

230-
std::vector<logic_state_t> statesTest = tEval->getStatesFromSimulatorIds(simulatorIdsTest);
231-
std::vector<logic_state_t> statesRef = rEval->getStatesFromSimulatorIds(simulatorIdsRef);
233+
std::vector<logic_state_t> statesTest = tSimulator->getStates(simulatorIdsTest);
234+
std::vector<logic_state_t> statesRef = rSimulator.getStates(simulatorIdsRef);
232235
for (size_t k = 0; k < statesTest.size(); ++k) {
233236
if (statesTest[k] != statesRef[k]) {
234237
return testcase;
235238
}
236239
}
237-
tEval->tickStep(numTicksBetweenTests);
238-
rEval->tickStep(numTicksBetweenTests);
240+
tSimulator->tickStep(numTicksBetweenTests);
241+
rSimulator.tickStep(numTicksBetweenTests);
239242
testcase->addTestAction(TickEvalAction { static_cast<unsigned int>(numTicksBetweenTests) });
240-
statesTest = tEval->getStatesFromSimulatorIds(simulatorIdsTest);
241-
statesRef = rEval->getStatesFromSimulatorIds(simulatorIdsRef);
243+
statesTest = tSimulator->getStates(simulatorIdsTest);
244+
statesRef = rSimulator.getStates(simulatorIdsRef);
242245
for (size_t k = 0; k < statesTest.size(); ++k) {
243246
if (statesTest[k] != statesRef[k]) {
244247
return testcase;

‎fuzzing/main.cpp‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,11 @@
44

55
#include "computerAPI/directoryManager.h"
66

7+
std::thread::id mainThreadId = std::this_thread::get_id();
8+
79
int main(int argc, char** argv) {
810
DirectoryManager::findDirectories();
11+
std::filesystem::create_directories(DirectoryManager::getConfigDirectory() / "fuzzing");
912
std::string failingTestcasePath = (DirectoryManager::getConfigDirectory() / "fuzzing" / "failing_testcase.json").string();
1013
FailingCaseFinder finder;
1114
std::vector<FuzzBlockType> blockTypesUsed = {
@@ -49,10 +52,10 @@ int main(int argc, char** argv) {
4952
FuzzPrimitiveType { BlockType::LIGHT },
5053

5154

52-
// FuzzPrimitiveType { BlockType::CONSTANT_OFF },
53-
// FuzzPrimitiveType { BlockType::CONSTANT_ON },
54-
// FuzzPrimitiveType { BlockType::CONSTANT_Z },
55-
// FuzzPrimitiveType { BlockType::CONSTANT_X },
55+
FuzzPrimitiveType { BlockType::CONSTANT_OFF },
56+
FuzzPrimitiveType { BlockType::CONSTANT_ON },
57+
FuzzPrimitiveType { BlockType::CONSTANT_Z },
58+
FuzzPrimitiveType { BlockType::CONSTANT_X },
5659
FuzzBusType { 2, 1, 1, 2 },
5760
FuzzBusType { 4, 1, 1, 4 },
5861
FuzzBusType { 2, 1, 2, 4 },

‎fuzzing/testcaseMinifier.cpp‎

Lines changed: 29 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
#include "testcaseMinifier.h"
33
#include "environment/environment.h"
44
#include "backend/evaluator/evaluator.h"
5+
#include "backend/evaluator/simulator/evalLogicSimulator.h"
56
#include "backend/container/block/blockDefs.h"
67

78
FuzzTestcase TestcaseMinifier::minifyTestcase(const FuzzTestcase& originalTestcase) {
@@ -45,9 +46,8 @@ std::unique_ptr<FuzzTestcase> TestcaseMinifier::tryRemoveEditActions(const FuzzT
4546
Environment environment { false };
4647
circuit_id_t circuitId = environment.getBackend().getCircuitManager().createNewCircuit(false);
4748
SharedCircuit circuit = environment.getBackend().getCircuit(circuitId);
48-
evaluator_id_t evalId = environment.getBackend().createEvaluator(circuitId).value();
49-
SharedEvaluator tEval = environment.getBackend().getEvaluator(evalId); // test evaluator
50-
SharedEvaluator rEval = nullptr; // reference evaluator
49+
simulator_id_t simulatorId = environment.getBackend().createSimulator(circuitId).value();
50+
EvalLogicSimulator* tSimulator = environment.getBackend().getSimulator(simulatorId); // test evaluator
5151

5252
std::vector<BlockType> blockTypesUsed = makeBlockTypesUsableVector(testcase.getBlockTypesUsed(), environment);
5353

@@ -119,18 +119,19 @@ std::unique_ptr<FuzzTestcase> TestcaseMinifier::tryRemoveEditActions(const FuzzT
119119
}, action);
120120
}
121121

122-
evaluator_id_t refEvalId = environment.getBackend().createEvaluator(circuitId).value();
123-
rEval = environment.getBackend().getEvaluator(refEvalId);
122+
Evaluator rEvaluator(environment.getBackend().getCircuitManager(), *circuit, environment.getBackend().getDataUpdateEventManager());
123+
simulator_id_t refSimulatorId = simulator_id_t(1000000 + simulatorId.get());
124+
EvalLogicSimulator rSimulator(refSimulatorId, environment.getBackend().getCircuitManager(), circuitId, environment.getBackend().getDataUpdateEventManager());
124125

125-
tEval->setRealistic(testcase.getRunRealistic());
126-
rEval->setRealistic(testcase.getRunRealistic());
126+
tSimulator->setRealistic(testcase.getRunRealistic());
127+
rSimulator.setRealistic(testcase.getRunRealistic());
127128
outputTestcase->setRealistic(testcase.getRunRealistic());
128129

129-
tEval->resetStates();
130-
rEval->resetStates();
130+
tSimulator->resetStates();
131+
rSimulator.resetStates();
131132

132-
std::vector<simulator_id_t> simulatorIdsTest;
133-
std::vector<simulator_id_t> simulatorIdsRef;
133+
std::vector<simulator_gate_id_t> simulatorIdsTest;
134+
std::vector<simulator_gate_id_t> simulatorIdsRef;
134135
std::unordered_map<block_id_t, Position> blockIdToPosition;
135136

136137
BlockDataManager& blockDataManager = environment.getBackend().getBlockDataManager();
@@ -140,40 +141,26 @@ std::unique_ptr<FuzzTestcase> TestcaseMinifier::tryRemoveEditActions(const FuzzT
140141
if (block == nullptr) continue;
141142
Position pos = block->getPosition();
142143
blockIdToPosition[blockId] = pos;
143-
simulatorIdsTest.push_back(tEval->getBlockSimulatorId(pos));
144-
simulatorIdsRef.push_back(rEval->getBlockSimulatorId(pos));
144+
simulatorIdsTest.push_back(std::get<simulator_gate_id_t>(tSimulator->getVirtualConnectionSimulatorId(Address(pos), 0)));
145+
simulatorIdsRef.push_back(std::get<simulator_gate_id_t>(tSimulator->getVirtualConnectionSimulatorId(Address(pos), 0)));
145146
const BlockData* blockData = blockDataManager.getBlockData(block->type());
146147
if (blockData == nullptr) continue;
147148
if (blockData->isDefaultData()) {
148-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdTest = tEval->getPinSimulatorId(pos);
149-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdRef = rEval->getPinSimulatorId(pos);
150-
if (std::holds_alternative<simulator_id_t>(simIdTest) && std::holds_alternative<simulator_id_t>(simIdRef)) {
151-
simulatorIdsTest.push_back(std::get<simulator_id_t>(simIdTest));
152-
simulatorIdsRef.push_back(std::get<simulator_id_t>(simIdRef));
153-
} else if (std::holds_alternative<std::vector<simulator_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_id_t>>(simIdRef)) {
154-
std::vector<simulator_id_t>& vecTest = std::get<std::vector<simulator_id_t>>(simIdTest);
155-
std::vector<simulator_id_t>& vecRef = std::get<std::vector<simulator_id_t>>(simIdRef);
156-
simulatorIdsTest.insert(simulatorIdsTest.end(), vecTest.begin(), vecTest.end());
157-
simulatorIdsRef.insert(simulatorIdsRef.end(), vecRef.begin(), vecRef.end());
158-
} else {
159-
return outputTestcase;
160-
}
161-
} else {
162-
const std::unordered_map<connection_end_id_t, BlockData::ConnectionData>& connections = blockData->getConnections();
149+
std::unordered_map<connection_end_id_t, BlockData::ConnectionData> connections = blockData->getConnectionsSafe();
163150
for (const auto& [connectionId, connectionData] : connections) {
164151
if (connectionData.portType == BlockData::ConnectionData::PortType::INPUT) {
165152
continue;
166153
}
167154
std::optional<Position> portPositionOpt = block->getConnectionPosition(connectionId);
168155
Position portPosition = portPositionOpt.value();
169-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdTest = tEval->getPinSimulatorId(portPosition);
170-
std::variant<simulator_id_t, std::vector<simulator_id_t>> simIdRef = rEval->getPinSimulatorId(portPosition);
171-
if (std::holds_alternative<simulator_id_t>(simIdTest) && std::holds_alternative<simulator_id_t>(simIdRef)) {
172-
simulatorIdsTest.push_back(std::get<simulator_id_t>(simIdTest));
173-
simulatorIdsRef.push_back(std::get<simulator_id_t>(simIdRef));
174-
} else if (std::holds_alternative<std::vector<simulator_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_id_t>>(simIdRef)) {
175-
std::vector<simulator_id_t>& vecTest = std::get<std::vector<simulator_id_t>>(simIdTest);
176-
std::vector<simulator_id_t>& vecRef = std::get<std::vector<simulator_id_t>>(simIdRef);
156+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdTest = tSimulator->getPinSimulatorId(portPosition);
157+
std::variant<simulator_gate_id_t, std::vector<simulator_gate_id_t>> simIdRef = rSimulator.getPinSimulatorId(portPosition);
158+
if (std::holds_alternative<simulator_gate_id_t>(simIdTest) && std::holds_alternative<simulator_gate_id_t>(simIdRef)) {
159+
simulatorIdsTest.push_back(std::get<simulator_gate_id_t>(simIdTest));
160+
simulatorIdsRef.push_back(std::get<simulator_gate_id_t>(simIdRef));
161+
} else if (std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdTest) && std::holds_alternative<std::vector<simulator_gate_id_t>>(simIdRef)) {
162+
std::vector<simulator_gate_id_t>& vecTest = std::get<std::vector<simulator_gate_id_t>>(simIdTest);
163+
std::vector<simulator_gate_id_t>& vecRef = std::get<std::vector<simulator_gate_id_t>>(simIdRef);
177164
if (vecTest.size() != vecRef.size()) {
178165
return outputTestcase;
179166
}
@@ -193,19 +180,19 @@ std::unique_ptr<FuzzTestcase> TestcaseMinifier::tryRemoveEditActions(const FuzzT
193180
std::visit([&](auto&& arg) {
194181
using T = std::decay_t<decltype(arg)>;
195182
if constexpr (std::is_same_v<T, SetBlockStateAction>) {
196-
tEval->setState(arg.position, arg.state);
197-
rEval->setState(arg.position, arg.state);
183+
tSimulator->setState(arg.position, arg.state);
184+
rSimulator.setState(arg.position, arg.state);
198185
outputTestcase->addTestAction(arg);
199186
} else if constexpr (std::is_same_v<T, TickEvalAction>) {
200-
tEval->tickStep(arg.numTicks);
201-
rEval->tickStep(arg.numTicks);
187+
tSimulator->tickStep(arg.numTicks);
188+
rSimulator.tickStep(arg.numTicks);
202189
outputTestcase->addTestAction(arg);
203190
}
204191
}, action);
205192
}
206193

207-
std::vector<logic_state_t> statesTest = tEval->getStatesFromSimulatorIds(simulatorIdsTest);
208-
std::vector<logic_state_t> statesRef = rEval->getStatesFromSimulatorIds(simulatorIdsRef);
194+
std::vector<logic_state_t> statesTest = tSimulator->getStates(simulatorIdsTest);
195+
std::vector<logic_state_t> statesRef = rSimulator.getStates(simulatorIdsRef);
209196
for (size_t k = 0; k < statesTest.size(); ++k) {
210197
if (statesTest[k] != statesRef[k]) {
211198
return outputTestcase;

‎src/app.cpp‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ App& App::get() {
2020
logInfo("Creating App", "App");
2121
appSingleton.emplace();
2222
appSingleton->newMainWindow();
23-
appSingleton->windows.back()->getActiveCircuitViewWidget()->newCircuit();
23+
if (appSingleton->windows.back()->getActiveCircuitViewWidget()) appSingleton->windows.back()->getActiveCircuitViewWidget()->newCircuit();
2424
}
2525
return *appSingleton;
2626
}
@@ -97,6 +97,11 @@ const char* const addLoopTracyName = "appLoop";
9797

9898
void App::runLoop() {
9999
logInfo("Starting App loop", "App");
100+
if (windows.empty()) {
101+
logError("Killing App loop. No windows Found!", "App");
102+
App::kill();
103+
return;
104+
}
100105
Network::get().checkForUpdates(get().windows[0]->getPopUpManager());
101106
running = true;
102107
while (running) {

‎src/backend/address.h‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,15 @@ class Address {
1010
inline int size() const { return addresses.size(); }
1111
inline Position getPosition(int index) const { return addresses[index]; }
1212

13-
inline void addBlockId(Position position) { addresses.push_back(position); }
13+
inline void appendPosition(Position position) { addresses.push_back(position); }
14+
inline void prependPosition(Position position) { addresses.insert(addresses.begin(), position); }
1415

15-
inline void nestPosition(Position position) {
16-
addresses.insert(addresses.begin(), position);
16+
Address popTopPosition() const {
17+
Address newAddress;
18+
newAddress.addresses = std::vector<Position>(addresses.begin() + 1, addresses.end());
19+
return newAddress;
1720
}
21+
1822
std::string toString() const {
1923
std::string result;
2024
for (const auto& pos : addresses) {
@@ -28,7 +32,6 @@ class Address {
2832

2933
private:
3034
std::vector<Position> addresses;
31-
3235
};
3336

3437
#endif /* address_h */

0 commit comments

Comments
 (0)