jgrogan/stuff-from-scratch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Do bulk replace of stl types.

Browse source
This commit is contained in:
jmsgrogan 2023-12-21 09:18:44 +00:00
parent 521486be62
commit c25a56ee19
531 changed files with 2274 additions and 2181 deletions
Download patch file Download diff file Expand all files Collapse all files

4
plugins/circuits/src/CircuitElement.h
View file

@ -1,7 +1,7 @@
#pragma once
#include <string>
#include <memory>
#include "String.h"
#include "Memory.h"
class CircuitElement

24
plugins/circuits/src/ElectronicCircuit.h
View file

@ -1,13 +1,13 @@
#pragma once
#include <memory>
#include <vector>
#include "Memory.h"
#include "Vector.h"
#include "CircuitElement.h"
#include "LogicGate.h"
#include "Terminal.h"
using LogicGatePtr = std::unique_ptr<LogicGate>;
using LogicGatePtr = Ptr<LogicGate>;
class ElectronicCircuit
{
@ -20,33 +20,33 @@ public:
void addLogicGate(LogicGatePtr gate);
const std::vector<Terminal*>& getInputTerminals() const
const Vector<Terminal*>& getInputTerminals() const
{
return mInputTerminals;
}
const std::vector<Terminal*>& getOutputTerminals() const
const Vector<Terminal*>& getOutputTerminals() const
{
return mOutputTerminals;
}
const std::vector<LogicGate*>& getLogicGates() const
const Vector<LogicGate*>& getLogicGates() const
{
return mLogicGates;
}
const std::vector<Wire*>& getWires() const
const Vector<Wire*>& getWires() const
{
return mWires;
}
private:
std::vector<Terminal*> mInputTerminals;
std::vector<Terminal*> mOutputTerminals;
Vector<Terminal*> mInputTerminals;
Vector<Terminal*> mOutputTerminals;
std::vector<Wire*> mWires;
Vector<Wire*> mWires;
std::vector<LogicGate*> mLogicGates;
Vector<LogicGate*> mLogicGates;
std::vector<std::unique_ptr<CircuitElement> > mElements;
Vector<Ptr<CircuitElement> > mElements;
};

2
plugins/circuits/src/Terminal.cpp
View file

@ -1,6 +1,6 @@
#include "Terminal.h"
Terminal::Terminal(TerminalType type, const std::string& label)
Terminal::Terminal(TerminalType type, const String& label)
: mLabel(label),
mType(type)

8
plugins/circuits/src/Terminal.h
View file

@ -2,7 +2,7 @@
#include "CircuitElement.h"
#include <string>
#include "String.h"
class Wire;
@ -15,7 +15,7 @@ public:
OUTPUT
};
Terminal(TerminalType type, const std::string& label = {});
Terminal(TerminalType type, const String& label = {});
Wire* getConnection() const;
@ -27,8 +27,8 @@ public:
void setConnection(Wire* connection);
private:
std::string mLabel;
String mLabel;
TerminalType mType;
Wire* mConnection{ nullptr };
};
using TerminalPtr = std::unique_ptr<Terminal>;
using TerminalPtr = Ptr<Terminal>;

4
plugins/circuits/src/TruthTable.h
View file

@ -1,12 +1,12 @@
#pragma once
#include <map>
#include <vector>
#include "Vector.h"
class TruthTable
{
public:
using TableData = std::map<std::vector<bool>, std::vector<bool> >;
using TableData = std::map<Vector<bool>, Vector<bool> >;
TruthTable(std::size_t, std::size_t)
//: mNumInputColumns(numInputColumns),

2
plugins/circuits/src/Wire.h
View file

@ -18,7 +18,7 @@ private:
CircuitElement* mInput{ nullptr };
CircuitElement* mOutput{ nullptr };
};
using WirePtr = std::unique_ptr<Wire>;
using WirePtr = Ptr<Wire>;
class Fanout : public CircuitElement
{

6
plugins/circuits/src/gates/LogicGate.cpp
View file

@ -1,6 +1,6 @@
#include "LogicGate.h"
NInMOutLogicGate::NInMOutLogicGate(std::size_t numIn, std::size_t numOut, std::vector<Wire*> inputs, std::vector<Wire*> outputs)
NInMOutLogicGate::NInMOutLogicGate(std::size_t numIn, std::size_t numOut, Vector<Wire*> inputs, Vector<Wire*> outputs)
: LogicGate(),
mNumIn(numIn),
mNumOut(numOut)
@ -11,7 +11,7 @@ NInMOutLogicGate::NInMOutLogicGate(std::size_t numIn, std::size_t numOut, std::v
}
else
{
mInputs = std::vector<Wire*>(numIn, nullptr);
mInputs = Vector<Wire*>(numIn, nullptr);
}
if (outputs.size() == mNumOut)
@ -20,7 +20,7 @@ NInMOutLogicGate::NInMOutLogicGate(std::size_t numIn, std::size_t numOut, std::v
}
else
{
mOutputs = std::vector<Wire*>(numOut, nullptr);
mOutputs = Vector<Wire*>(numOut, nullptr);
}
}

10
plugins/circuits/src/gates/LogicGate.h
View file

@ -4,8 +4,8 @@
#include "TruthTable.h"
#include "Wire.h"
#include <memory>
#include <vector>
#include "Memory.h"
#include "Vector.h"
class LogicGate : public CircuitElement
{
@ -41,7 +41,7 @@ public:
class NInMOutLogicGate : public LogicGate
{
public:
NInMOutLogicGate(std::size_t numIn, std::size_t numOut, std::vector<Wire*> inputs = {}, std::vector<Wire*> outputs = {});
NInMOutLogicGate(std::size_t numIn, std::size_t numOut, Vector<Wire*> inputs = {}, Vector<Wire*> outputs = {});
virtual ~NInMOutLogicGate() = default;
@ -61,8 +61,8 @@ private:
std::size_t mNumIn{ 1 };
std::size_t mNumOut{ 1 };
std::vector<Wire*> mInputs;
std::vector<Wire*> mOutputs;
Vector<Wire*> mInputs;
Vector<Wire*> mOutputs;
};
class TwoInOneOutLogicGate : public NInMOutLogicGate

8
plugins/circuits/src/visuals/ElectronicCircuitNode.h
View file

@ -31,10 +31,10 @@ private:
ElectronicCircuit* mContent{ nullptr };
bool mContentDirty{ true };
std::vector<std::unique_ptr<TerminalNode> > mInputTerminalNodes;
std::vector<std::unique_ptr<TerminalNode> > mOutputTerminalNodes;
std::vector<std::unique_ptr<WireNode> > mWireNodes;
std::vector<std::unique_ptr<LogicGateNode> > mLogicGateNodes;
Vector<Ptr<TerminalNode> > mInputTerminalNodes;
Vector<Ptr<TerminalNode> > mOutputTerminalNodes;
Vector<Ptr<WireNode> > mWireNodes;
Vector<Ptr<LogicGateNode> > mLogicGateNodes;
std::unordered_map<Wire*, CircuitElement*> mWireInputConnections;
std::unordered_map<Wire*, CircuitElement*> mWireOutputConnections;

4
plugins/circuits/src/visuals/LogicGateNode.h
View file

@ -25,6 +25,6 @@ private:
LogicGate* mContent{ nullptr };
bool mContentDirty{ true };
std::unique_ptr<PathNode> mPrimaryPath;
std::unique_ptr<CircleNode> mNegationGlyph;
Ptr<PathNode> mPrimaryPath;
Ptr<CircleNode> mNegationGlyph;
};

4
plugins/circuits/src/visuals/LogicGatePrimitiveShapes.cpp
View file

@ -1,6 +1,6 @@
#include "LogicGatePrimitiveShapes.h"
std::string LogicGatePrimitiveShapes::getAndGateShape()
String LogicGatePrimitiveShapes::getAndGateShape()
{
return "M4 8 h24 a16 16 0 0 1 0 32 h-24Z";
}
@ -24,7 +24,7 @@ Point2 LogicGatePrimitiveShapes::getAndGateConnectionLocation(bool isInput, std:
}
}
std::string LogicGatePrimitiveShapes::getOrGateShape()
String LogicGatePrimitiveShapes::getOrGateShape()
{
return "M4 8 h16 q16 2 24 16 q-12 16 -24 16 h-16 q12 -16 0 -32Z";
}

6
plugins/circuits/src/visuals/LogicGatePrimitiveShapes.h
View file

@ -2,16 +2,16 @@
#include "Point.h"
#include <string>
#include "String.h"
class LogicGatePrimitiveShapes
{
public:
static Point2 getAndGateConnectionLocation(bool isInput, std::size_t idx);
static std::string getAndGateShape();
static String getAndGateShape();
static Point2 getOrGateConnectionLocation(bool isInput, std::size_t idx);
static std::string getOrGateShape();
static String getOrGateShape();
};

2
plugins/circuits/src/visuals/TerminalNode.h
View file

@ -19,7 +19,7 @@ public:
private:
void createOrUpdateGeometry(SceneInfo* sceneInfo);
std::unique_ptr<CircleNode> mMarker;
Ptr<CircleNode> mMarker;
Terminal* mContent{ nullptr };
bool mContentDirty{ true };

2
plugins/circuits/src/visuals/WireNode.cpp
View file

@ -48,7 +48,7 @@ void WireNode::createOrUpdateGeometry(SceneInfo*)
auto loc = mOutputLocation;
loc.moveBy(-mInputLocation.getX(), -mInputLocation.getY(), -mInputLocation.getZ());
std::vector<Point2> points;
Vector<Point2> points;
if (loc.getY() == 0.0)
{

2
plugins/circuits/src/visuals/WireNode.h
View file

@ -26,5 +26,5 @@ private:
Point2 mInputLocation;
Point2 mOutputLocation;
std::unique_ptr<LineNode> mLine;
Ptr<LineNode> mLine;
};

4
plugins/music/src/midi/MetaMidiEvent.cpp
View file

@ -9,7 +9,7 @@ MetaMidiEvent::MetaMidiEvent()
}
std::unique_ptr<MetaMidiEvent> MetaMidiEvent::Create()
Ptr<MetaMidiEvent> MetaMidiEvent::Create()
{
return std::make_unique<MetaMidiEvent>();
}
@ -79,7 +79,7 @@ void MetaMidiEvent::SetValue(int value)
mValue = value;
}
void MetaMidiEvent::SetLabel(const std::string& label)
void MetaMidiEvent::SetLabel(const String& label)
{
mLabel = label;
}

12
plugins/music/src/midi/MetaMidiEvent.h
View file

@ -2,8 +2,8 @@
#include "MidiEvent.h"
#include "MidiElements.h"
#include <memory>
#include <string>
#include "Memory.h"
#include "String.h"
class MetaMidiEvent : public MidiEvent
{
@ -51,13 +51,13 @@ private:
public:
MetaMidiEvent();
static std::unique_ptr<MetaMidiEvent> Create();
static Ptr<MetaMidiEvent> Create();
void SetValue(int value);
void SetType(char c);
Type GetType() const;
void SetLabel(const std::string& label);
void SetLabel(const String& label);
void SetTimeSignature(const MidiTimeSignature& timeSig);
void SetTimeCode(const MidiSmtpeTimecode& timeCode);
void SetKeySignature(const MidiKeySignature& keySig);
@ -65,11 +65,11 @@ public:
private:
Type mType {Type::UNSET};
char mUnKnownMarker{0};
std::string mLabel;
String mLabel;
int mValue { 0 };
MidiTimeSignature mTimeSig;
MidiSmtpeTimecode mTimecode;
MidiKeySignature mKeySig;
};
using MetaMidiEventPtr = std::unique_ptr<MetaMidiEvent>;
using MetaMidiEventPtr = Ptr<MetaMidiEvent>;

2
plugins/music/src/midi/MidiChannelEvent.cpp
View file

@ -9,7 +9,7 @@ MidiChannelEvent::MidiChannelEvent()
}
std::unique_ptr<MidiChannelEvent> MidiChannelEvent::Create()
Ptr<MidiChannelEvent> MidiChannelEvent::Create()
{
return std::make_unique<MidiChannelEvent>();
}

6
plugins/music/src/midi/MidiChannelEvent.h
View file

@ -1,7 +1,7 @@
#pragma once
#include "MidiEvent.h"
#include <string>
#include "String.h"
class MidiChannelEvent : public MidiEvent
{
@ -52,7 +52,7 @@ private:
public:
MidiChannelEvent();
static std::unique_ptr<MidiChannelEvent> Create();
static Ptr<MidiChannelEvent> Create();
void SetTypeAndChannel(char c);
void SetType(Type type);
@ -69,4 +69,4 @@ private:
int mValue1 {1};
};
using MidiChannelEventPtr = std::unique_ptr<MidiChannelEvent>;
using MidiChannelEventPtr = Ptr<MidiChannelEvent>;

6
plugins/music/src/midi/MidiDocument.cpp
View file

@ -7,7 +7,7 @@ MidiDocument::MidiDocument()
}
std::unique_ptr<MidiDocument> MidiDocument::Create()
Ptr<MidiDocument> MidiDocument::Create()
{
return std::make_unique<MidiDocument>();
}
@ -32,9 +32,9 @@ void MidiDocument::SetTimeDivision(const MidiTimeDivision& timeDivision)
mTimeDivision = timeDivision;
}
std::string MidiDocument::Serialize() const
String MidiDocument::Serialize() const
{
std::string output = "MidiDocument\n";
String output = "MidiDocument\n";
output += "Format type: " + std::to_string(mFormatType) + "\n";
output += "Expected Tracks: " + std::to_string(mExpectedTracks) + "\n";
output += "Use fps: " + std::to_string(mTimeDivision.mUseFps) + "\n";

16
plugins/music/src/midi/MidiDocument.h
View file

@ -1,20 +1,20 @@
#pragma once
#include <vector>
#include <memory>
#include <string>
#include "Vector.h"
#include "Memory.h"
#include "String.h"
#include "MidiElements.h"
class MidiTrack;
using MidiTrackPtr = std::unique_ptr<MidiTrack>;
using MidiTrackPtr = Ptr<MidiTrack>;
class MidiDocument
{
public:
MidiDocument();
static std::unique_ptr<MidiDocument> Create();
static Ptr<MidiDocument> Create();
void AddTrack(MidiTrackPtr track);
@ -22,13 +22,13 @@ public:
void SetExpectedTracks(int expected);
void SetTimeDivision(const MidiTimeDivision& timeDivision);
std::string Serialize() const;
String Serialize() const;
private:
int mFormatType = 0;
int mExpectedTracks = 0;
MidiTimeDivision mTimeDivision;
std::vector<MidiTrackPtr> mTracks;
Vector<MidiTrackPtr> mTracks;
};
using MidiDocumentPtr = std::unique_ptr<MidiDocument>;
using MidiDocumentPtr = Ptr<MidiDocument>;

2
plugins/music/src/midi/MidiEvent.cpp
View file

@ -6,7 +6,7 @@ MidiEvent::MidiEvent()
}
std::unique_ptr<MidiEvent> MidiEvent::Create()
Ptr<MidiEvent> MidiEvent::Create()
{
return std::make_unique<MidiEvent>();
}

6
plugins/music/src/midi/MidiEvent.h
View file

@ -1,6 +1,6 @@
#pragma once
#include <memory>
#include "Memory.h"
class MidiEvent
{
@ -13,7 +13,7 @@ public:
MidiEvent();
virtual ~MidiEvent() = default;
static std::unique_ptr<MidiEvent> Create();
static Ptr<MidiEvent> Create();
void SetTimeDelta(int delta);
@ -26,4 +26,4 @@ private:
int mTimeDelta{0};
};
using MidiEventPtr = std::unique_ptr<MidiEvent>;
using MidiEventPtr = Ptr<MidiEvent>;

4
plugins/music/src/midi/MidiTrack.cpp
View file

@ -27,9 +27,9 @@ std::size_t MidiTrack::GetNumEvents()
return mEvents.size();
}
std::string MidiTrack::Serialize() const
String MidiTrack::Serialize() const
{
std::string output = "MidiTrack\n";
String output = "MidiTrack\n";
output += "Num Events: " + std::to_string(mEvents.size()) + "\n";
return output;
}

12
plugins/music/src/midi/MidiTrack.h
View file

@ -1,12 +1,12 @@
#pragma once
#include <vector>
#include <memory>
#include <string>
#include "Vector.h"
#include "Memory.h"
#include "String.h"
#include "MidiEvent.h"
class MidiEvent;
using MidiEventPtr = std::unique_ptr<MidiEvent>;
using MidiEventPtr = Ptr<MidiEvent>;
class MidiTrack
{
@ -22,9 +22,9 @@ public:
std::size_t GetNumEvents();
std::string Serialize() const;
String Serialize() const;
private:
std::vector<MidiEventPtr> mEvents;
Vector<MidiEventPtr> mEvents;
};

6
plugins/music/src/midi/reader/MidiMetaEventAdapter.cpp
View file

@ -83,7 +83,7 @@ int MidiMetaEventAdapter::ReadStringEvent(std::ifstream* file, MetaMidiEvent* ev
int length = *BinaryStream::getNextByteAsInt(file);
byteCount++;
std::string name;
String name;
BinaryStream::getNextString(file, name, length);
byteCount += length;
event->SetLabel(name);
@ -104,7 +104,7 @@ int MidiMetaEventAdapter::ReadIntEvent(std::ifstream* file, MetaMidiEvent* event
byteCount ++;
}
std::string buffer;
String buffer;
BinaryStream::getNextNBytes(file, buffer.data(), length);
byteCount += length;
@ -119,7 +119,7 @@ int MidiMetaEventAdapter::ReadChannelPrefixEvent(std::ifstream* file, MetaMidiEv
int length = *BinaryStream::getNextByteAsInt(file);
byteCount ++;
std::string buffer;
String buffer;
BinaryStream::getNextNBytes(file, buffer.data(), length);
byteCount += length;

4
plugins/music/src/midi/reader/MidiReader.h
View file

@ -7,7 +7,7 @@
#include "File.h"
#include <filesystem>
#include <string>
#include "String.h"
using Path = std::filesystem::path;
@ -29,7 +29,7 @@ private:
int processEvent(MidiTrack* track);
private:
std::unique_ptr<File> mFile;
Ptr<File> mFile;
MidiDocumentPtr mDocument;
int mLastMidiChannel {0};
MidiChannelEvent::Type mLastChannelEventType;

8
plugins/quantum_computing/src/QuantumCircuit.cpp
View file

@ -28,22 +28,22 @@ void QuantumCircuit::addLogicGate(QuantumGatePtr gate)
mElements.push_back(std::move(gate));
}
const std::vector<QuantumTerminal*>& QuantumCircuit::getInputTerminals() const
const Vector<QuantumTerminal*>& QuantumCircuit::getInputTerminals() const
{
return mInputTerminals;
}
const std::vector<QuantumTerminal*>& QuantumCircuit::getOutputTerminals() const
const Vector<QuantumTerminal*>& QuantumCircuit::getOutputTerminals() const
{
return mOutputTerminals;
}
const std::vector<QuantumGate*>& QuantumCircuit::getLogicGates() const
const Vector<QuantumGate*>& QuantumCircuit::getLogicGates() const
{
return mGates;
}
const std::vector<QuantumWire*>& QuantumCircuit::getQuantumWires() const
const Vector<QuantumWire*>& QuantumCircuit::getQuantumWires() const
{
return mWires;
}

20
plugins/quantum_computing/src/QuantumCircuit.h
View file

@ -6,7 +6,7 @@
#include "QuantumWire.h"
#include "QuantumState.h"
#include <vector>
#include "Vector.h"
class QuantumCircuit
{
@ -21,24 +21,24 @@ public:
void buildWireConnections();
const std::vector<QuantumTerminal*>& getInputTerminals() const;
const Vector<QuantumTerminal*>& getInputTerminals() const;
const std::vector<QuantumTerminal*>& getOutputTerminals() const;
const Vector<QuantumTerminal*>& getOutputTerminals() const;
const std::vector<QuantumGate*>& getLogicGates() const;
const Vector<QuantumGate*>& getLogicGates() const;
const std::vector<QuantumWire*>& getQuantumWires() const;
const Vector<QuantumWire*>& getQuantumWires() const;
QuantumState getInputState() const;
private:
bool connectivityIsValid() const;
std::vector<QuantumTerminal*> mInputTerminals;
std::vector<QuantumTerminal*> mOutputTerminals;
Vector<QuantumTerminal*> mInputTerminals;
Vector<QuantumTerminal*> mOutputTerminals;
std::vector<QuantumWire*> mWires;
std::vector<QuantumGate*> mGates;
Vector<QuantumWire*> mWires;
Vector<QuantumGate*> mGates;
std::vector<std::unique_ptr<QuantumCircuitElement> > mElements;
Vector<Ptr<QuantumCircuitElement> > mElements;
};

22
plugins/quantum_computing/src/QuantumCircuitReader.cpp
View file

@ -10,13 +10,13 @@
#include "StringUtils.h"
#include "FileLogger.h"
std::unique_ptr<QuantumCircuit> QuantumCircuitReader::read(const Path& path)
Ptr<QuantumCircuit> QuantumCircuitReader::read(const Path& path)
{
File file(path);
return read(file.readText());
}
std::unique_ptr<QuantumCircuit> QuantumCircuitReader::read(const std::string& content)
Ptr<QuantumCircuit> QuantumCircuitReader::read(const String& content)
{
auto circuit = std::make_unique<QuantumCircuit>();
mWorkingCircuit = circuit.get();
@ -31,7 +31,7 @@ std::unique_ptr<QuantumCircuit> QuantumCircuitReader::read(const std::string& co
return circuit;
}
void QuantumCircuitReader::onLine(const std::string& line, std::size_t jdx)
void QuantumCircuitReader::onLine(const String& line, std::size_t jdx)
{
mWorkingString.clear();
std::size_t cursor = 0;
@ -39,7 +39,7 @@ void QuantumCircuitReader::onLine(const std::string& line, std::size_t jdx)
while (cursor < line.size())
{
const auto c = line[cursor];
MLOG_INFO("Working char: " << std::string(1, c));
MLOG_INFO("Working char: " << String(1, c));
if (c == '|')
{
@ -103,7 +103,7 @@ void QuantumCircuitReader::onLineEnd()
mWorkingElement = nullptr;
}
void QuantumCircuitReader::onGate(Location, const std::string value)
void QuantumCircuitReader::onGate(Location, const String value)
{
MLOG_INFO("Got gate: " << value);
@ -128,9 +128,9 @@ void QuantumCircuitReader::onGate(Location, const std::string value)
}
}
std::string QuantumCircuitReader::checkForGate(const std::string& segment)
String QuantumCircuitReader::checkForGate(const String& segment)
{
std::string working_string;
String working_string;
for (const auto c : segment)
{
if (c == '-')
@ -142,7 +142,7 @@ std::string QuantumCircuitReader::checkForGate(const std::string& segment)
return working_string;
}
void QuantumCircuitReader::onKet(Location, const std::string value)
void QuantumCircuitReader::onKet(Location, const String value)
{
MLOG_INFO("Got input state: " << value);
Qubit qubit;
@ -157,7 +157,7 @@ void QuantumCircuitReader::onKet(Location, const std::string value)
mWorkingCircuit->addInputTerminal(std::move(input_terminal));
}
std::size_t QuantumCircuitReader::getWireEnd(const std::string& segment)
std::size_t QuantumCircuitReader::getWireEnd(const String& segment)
{
std::size_t idx = 0;
for (const auto c : segment)
@ -171,9 +171,9 @@ std::size_t QuantumCircuitReader::getWireEnd(const std::string& segment)
return idx;
}
std::string QuantumCircuitReader::checkForKet(const std::string& segment)
String QuantumCircuitReader::checkForKet(const String& segment)
{
std::string working_string;
String working_string;
bool found{ false };
for (const auto c : segment)

20
plugins/quantum_computing/src/QuantumCircuitReader.h
View file

@ -1,7 +1,7 @@
#pragma once
#include <filesystem>
#include <string>
#include "String.h"
using Path = std::filesystem::path;
@ -11,30 +11,30 @@ class QuantumCircuitElement;
class QuantumCircuitReader
{
public:
std::unique_ptr<QuantumCircuit> read(const Path& path);
Ptr<QuantumCircuit> read(const Path& path);
std::unique_ptr<QuantumCircuit> read(const std::string& content);
Ptr<QuantumCircuit> read(const String& content);
private:
using Location = std::pair<std::size_t, std::size_t>;
void onLine(const std::string& line, std::size_t jdx);
void onLine(const String& line, std::size_t jdx);
std::string checkForKet(const std::string& segment);
String checkForKet(const String& segment);
std::string checkForGate(const std::string& segment);
String checkForGate(const String& segment);
std::size_t getWireEnd(const std::string& segment);
std::size_t getWireEnd(const String& segment);
void onGate(Location loc, const std::string value);
void onGate(Location loc, const String value);
void onKet(Location loc, const std::string value);
void onKet(Location loc, const String value);
void onLineEnd();
void onVertialQuantumWire(Location loc);
std::string mWorkingString;
String mWorkingString;
QuantumCircuitElement* mWorkingElement{ nullptr };
QuantumCircuit* mWorkingCircuit{ nullptr };
};

6
plugins/quantum_computing/src/QuantumState.cpp
View file

@ -1,13 +1,13 @@
#include "QuantumState.h"
const std::vector<Qubit>& QuantumState::getData() const
const Vector<Qubit>& QuantumState::getData() const
{
return mState;
}
std::string QuantumState::toString() const
String QuantumState::toString() const
{
std::string out;
String out;
for (const auto& qubit : mState)
{
out += "|" + qubit.toString() + "\n";

10
plugins/quantum_computing/src/QuantumState.h
View file

@ -2,8 +2,8 @@
#include "Qubit.h"
#include <vector>
#include <string>
#include "Vector.h"
#include "String.h"
class QuantumState
{
@ -13,10 +13,10 @@ public:
mState.push_back(data);
}
const std::vector<Qubit>& getData() const;
const Vector<Qubit>& getData() const;
std::string toString() const;
String toString() const;
private:
std::vector<Qubit> mState;
Vector<Qubit> mState;
};

4
plugins/quantum_computing/src/Qubit.cpp
View file

@ -29,9 +29,9 @@ bool Qubit::isIn1State() const
return mBeta.getReal() == 1.0 && mAlpha.getMagnitude() == 0.0;
}
std::string Qubit::toString(std::size_t precision) const
String Qubit::toString(std::size_t precision) const
{
std::stringstream sstr;
Stringstream sstr;
sstr.precision(precision);
sstr << "alpha " << mAlpha.getReal() << " " << mAlpha.getImaginary() << "i , beta " << mBeta.getReal() << " " << mBeta.getImaginary() << "i";
return sstr.str();

4
plugins/quantum_computing/src/Qubit.h
View file

@ -2,7 +2,7 @@
#include "ComplexNumber.h"
#include <string>
#include "String.h"
class Qubit
{
@ -17,7 +17,7 @@ public:
bool isIn1State() const;
std::string toString(std::size_t precision=3) const;
String toString(std::size_t precision=3) const;
private:
ComplexNumber mAlpha;
ComplexNumber mBeta;

2
plugins/quantum_computing/src/circuit_elements/QuantumCircuitElement.h
View file

@ -1,6 +1,6 @@
#pragma once
#include <memory>
#include "Memory.h"
class QuantumCircuitElement
{

6
plugins/quantum_computing/src/circuit_elements/QuantumGate.cpp
View file

@ -1,6 +1,6 @@
#include "QuantumGate.h"
NInMOutQuantumGate::NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, std::vector<AbstractQuantumWire*> inputs, std::vector<AbstractQuantumWire*> outputs)
NInMOutQuantumGate::NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, Vector<AbstractQuantumWire*> inputs, Vector<AbstractQuantumWire*> outputs)
: QuantumGate(),
mNumIn(numIn),
mNumOut(numOut)
@ -11,7 +11,7 @@ NInMOutQuantumGate::NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, st
}
else
{
mInputs = std::vector<AbstractQuantumWire*>(numIn, nullptr);
mInputs = Vector<AbstractQuantumWire*>(numIn, nullptr);
}
if (outputs.size() == mNumOut)
@ -20,7 +20,7 @@ NInMOutQuantumGate::NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, st
}
else
{
mOutputs = std::vector<AbstractQuantumWire*>(numOut, nullptr);
mOutputs = Vector<AbstractQuantumWire*>(numOut, nullptr);
}
}

10
plugins/quantum_computing/src/circuit_elements/QuantumGate.h
View file

@ -4,7 +4,7 @@
#include "QuantumWire.h"
#include <vector>
#include "Vector.h"
class QuantumGate : public QuantumCircuitElement
{
@ -39,13 +39,13 @@ public:
return Type::GATE;
}
};
using QuantumGatePtr = std::unique_ptr<QuantumGate>;
using QuantumGatePtr = Ptr<QuantumGate>;
class NInMOutQuantumGate : public QuantumGate
{
public:
NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, std::vector<AbstractQuantumWire*> inputs = {}, std::vector<AbstractQuantumWire*> outputs = {});
NInMOutQuantumGate(std::size_t numIn, std::size_t numOut, Vector<AbstractQuantumWire*> inputs = {}, Vector<AbstractQuantumWire*> outputs = {});
virtual ~NInMOutQuantumGate() = default;
@ -85,8 +85,8 @@ private:
std::size_t mNumIn{ 1 };
std::size_t mNumOut{ 1 };
std::vector<AbstractQuantumWire*> mInputs;
std::vector<AbstractQuantumWire*> mOutputs;
Vector<AbstractQuantumWire*> mInputs;
Vector<AbstractQuantumWire*> mOutputs;
};
class TwoInOneOutQuantumGate : public NInMOutQuantumGate

2
plugins/quantum_computing/src/circuit_elements/QuantumTerminal.cpp
View file

@ -1,6 +1,6 @@
#include "QuantumTerminal.h"
QuantumTerminal::QuantumTerminal(TerminalType type, const std::string& label)
QuantumTerminal::QuantumTerminal(TerminalType type, const String& label)
: mLabel(label),
mType(type)
{

10
plugins/quantum_computing/src/circuit_elements/QuantumTerminal.h
View file

@ -3,8 +3,8 @@
#include "QuantumCircuitElement.h"
#include "Qubit.h"
#include <string>
#include <memory>
#include "String.h"
#include "Memory.h"
class QuantumWire;
@ -17,7 +17,7 @@ public:
OUTPUT
};
QuantumTerminal(TerminalType type, const std::string& label = {});
QuantumTerminal(TerminalType type, const String& label = {});
QuantumWire* getConnection() const;
@ -40,9 +40,9 @@ public:
void setValue(const Qubit& value);
private:
std::string mLabel;
String mLabel;
TerminalType mType;
Qubit mValue;
QuantumWire* mConnection{ nullptr };
};
using QuantumTerminalPtr = std::unique_ptr<QuantumTerminal>;
using QuantumTerminalPtr = Ptr<QuantumTerminal>;

2
plugins/quantum_computing/src/circuit_elements/QuantumWire.h
View file

@ -38,7 +38,7 @@ public:
Type getType() const override;
WireType getWireType() const override;
};
using QuantumWirePtr = std::unique_ptr<QuantumWire>;
using QuantumWirePtr = Ptr<QuantumWire>;
class ClassicalWire : public AbstractQuantumWire
{

2
plugins/quantum_computing/src/visuals/BlochSphereNode.cpp
View file

@ -41,7 +41,7 @@ void BlochSphereNode::update(SceneInfo*)
mOuterCircle = std::make_unique<CircleNode>(loc, mSize/2.0);
const auto end_point_x = Point2(loc.getX() + 1.2 * mSize / 2.0, loc.getY());
const std::vector<Point2> points{end_point_x };
const Vector<Point2> points{end_point_x };
mXAxis = std::make_unique<LineNode>(loc, points);
mCentreCircle = std::make_unique<CircleNode>(loc, mSize / 50.0);

18
plugins/quantum_computing/src/visuals/BlochSphereNode.h
View file

@ -2,7 +2,7 @@
#include "AbstractVisualNode.h"
#include <memory>
#include "Memory.h"
class BlochSphere;
class CircleNode;
@ -23,12 +23,12 @@ private:
bool mContentDirty{ true };
BlochSphere* mContent{ nullptr };
std::unique_ptr<CircleNode> mOuterCircle;
std::unique_ptr<CircleNode> mInnerCircle;
std::unique_ptr<CircleNode> mCentreCircle;
std::unique_ptr<CircleNode> mStateMarkerCircle;
std::unique_ptr<LineNode> mXAxis;
std::unique_ptr<LineNode> mYAxis;
std::unique_ptr<LineNode> mZAxis;
std::unique_ptr<LineNode> mStateVector;
Ptr<CircleNode> mOuterCircle;
Ptr<CircleNode> mInnerCircle;
Ptr<CircleNode> mCentreCircle;
Ptr<CircleNode> mStateMarkerCircle;
Ptr<LineNode> mXAxis;
Ptr<LineNode> mYAxis;
Ptr<LineNode> mZAxis;
Ptr<LineNode> mStateVector;
};

8
plugins/quantum_computing/src/visuals/QuantumCircuitNode.h
View file

@ -29,10 +29,10 @@ private:
bool mContentDirty{ true };
QuantumCircuit* mContent{ nullptr };
std::vector<std::unique_ptr<QuantumTerminalNode> > mInputTerminalNodes;
std::vector<std::unique_ptr<QuantumTerminalNode> > mOutputTerminalNodes;
std::vector<std::unique_ptr<QuantumGateNode> > mGateNodes;
std::vector<std::unique_ptr<QuantumWireNode> > mWireNodes;
Vector<Ptr<QuantumTerminalNode> > mInputTerminalNodes;
Vector<Ptr<QuantumTerminalNode> > mOutputTerminalNodes;
Vector<Ptr<QuantumGateNode> > mGateNodes;
Vector<Ptr<QuantumWireNode> > mWireNodes;
std::unordered_map<AbstractQuantumWire*, QuantumCircuitElement*> mWireInputConnections;
std::unordered_map<AbstractQuantumWire*, QuantumCircuitElement*> mWireOutputConnections;

2
plugins/quantum_computing/src/visuals/QuantumGateNode.cpp
View file

@ -44,7 +44,7 @@ void QuantumGateNode::createOrUpdateGeometry(SceneInfo*)
{
mLabel = std::make_unique<EquationNode>(Point(mBodyWidth /3.0, mBodyHeight / 3.0));
std::string label_content;
String label_content;
if (mContent->getGateType() == QuantumGate::GateType::X)
{
label_content = "X";

6
plugins/quantum_computing/src/visuals/QuantumGateNode.h
View file

@ -25,10 +25,10 @@ private:
QuantumGate* mContent{ nullptr };
bool mContentDirty{ true };
std::unique_ptr<RectangleNode> mBody;
Ptr<RectangleNode> mBody;
double mBodyWidth = 30;
double mBodyHeight = 24;
std::unique_ptr<LatexMathExpression> mLabelExpression;
std::unique_ptr<EquationNode> mLabel;
Ptr<LatexMathExpression> mLabelExpression;
Ptr<EquationNode> mLabel;
};

2
plugins/quantum_computing/src/visuals/QuantumTerminalNode.cpp
View file

@ -30,7 +30,7 @@ void QuantumTerminalNode::createOrUpdateGeometry(SceneInfo*)
if (!mLabel && mContent->getTerminalType() != QuantumTerminal::TerminalType::OUTPUT)
{
const auto value = mContent->getValue();
std::string label;
String label;
if (value.isIn0State())
{
label = "\\ket{0}";

4
plugins/quantum_computing/src/visuals/QuantumTerminalNode.h
View file

@ -25,6 +25,6 @@ private:
double mWidth = 20.0;
double mHeight = 10.0;
std::unique_ptr<LatexMathExpression> mLabelExpression;
std::unique_ptr<EquationNode> mLabel;
Ptr<LatexMathExpression> mLabelExpression;
Ptr<EquationNode> mLabel;
};

2
plugins/quantum_computing/src/visuals/QuantumWireNode.cpp
View file

@ -54,7 +54,7 @@ void QuantumWireNode::createOrUpdateGeometry(SceneInfo*)
auto loc = mOutputLocation;
loc.moveBy(-mInputLocation.getX(), -mInputLocation.getY(), -mInputLocation.getZ());
std::vector<Point2> points;
Vector<Point2> points;
if (loc.getY() == 0.0)
{

2
plugins/quantum_computing/src/visuals/QuantumWireNode.h
View file

@ -29,5 +29,5 @@ private:
Point2 mInputLocation;
Point2 mOutputLocation;
std::unique_ptr<LineNode> mLine;
Ptr<LineNode> mLine;
};