Replace uint8_t with size_t

agui2/src/Algorithm/Algorithm.cpp

@@ -24,12 +24,12 @@ Algorithm::Algorithm(std::string fullName)
     }
 }
-uint8_t Algorithm::getInputCount() const {
+size_t Algorithm::getInputCount() const {
     if (this->overloads.empty()) {
         throw std::runtime_error { std::string("Input count has not yet been determined for algorithm ") + this->fullName };
     }
-    return static_cast<uint8_t>(this->overloads[0].parameterTypes.size());
+    return this->overloads[0].parameterTypes.size();
 }
 void Algorithm::addOverload(Algorithm::Overload overload) {

agui2/src/Algorithm/Algorithm.hpp

@@ -22,7 +22,7 @@ public:
     const std::string& getFullName() const { return this->fullName; }
     std::string getPrettyName() const;
-    uint8_t getInputCount() const;
+    size_t getInputCount() const;
     std::shared_ptr<abstraction::OperationAbstraction> execute(
             const std::vector<std::shared_ptr<abstraction::OperationAbstraction>>& params) const;

agui2/src/Execution/ParallelExecutor.cpp

@@ -40,7 +40,7 @@ std::shared_ptr<abstraction::OperationAbstraction> ParallelExecutor::execute(Out
         }
     }
-    std::vector<std::vector<uint8_t>> M;
+    std::vector<std::vector<size_t>> M;
     size_t N = boxes.size();
     M.resize(N);
     for (size_t i = 0; i < N; ++i) {
@@ -58,7 +58,7 @@ std::shared_ptr<abstraction::OperationAbstraction> ParallelExecutor::execute(Out
     for (size_t k = 0; k < N; k++) {
         for (size_t i = 0; i < N; i++) {
             for (size_t j = 0; j < N; j++) {
-                M[i][j] = M[i][j] | static_cast<uint8_t>(M[i][k] & M[k][j]);
+                M[i][j] = M[i][j] | static_cast<size_t>(M[i][k] & M[k][j]);
             }
         }
     }

agui2/src/Graphics/Connection/InputConnectionBox.cpp

 #include <Graphics/Connection/InputConnectionBox.hpp>
-InputConnectionBox::InputConnectionBox(GraphicsBox* parent, uint8_t slot)
+InputConnectionBox::InputConnectionBox(GraphicsBox* parent, size_t slot)
     : ConnectionBox(parent, ConnectionBox::Type::Input)
     , slot(slot)
 {}

agui2/src/Graphics/Connection/InputConnectionBox.hpp

@@ -5,18 +5,18 @@ class InputConnectionBox : public ConnectionBox {
     friend class Connection;
 public:
-    explicit InputConnectionBox(GraphicsBox* parent, uint8_t slot);
+    explicit InputConnectionBox(GraphicsBox* parent, size_t slot);
     void setConnection(Connection* connection);
     const Connection* getConnection() const { return this->connection; }
-    uint8_t getSlot() const { return this->slot; }
+    size_t getSlot() const { return this->slot; }
 private:
     void on_Disconnect() override;
 protected:
     Connection* connection = nullptr;
-    uint8_t slot;
+    size_t slot;
 };

agui2/src/Graphics/GraphicsBox.cpp

@@ -26,11 +26,11 @@ GraphicsBox::GraphicsBox(std::unique_ptr<ModelBox> modelBox, QPointF pos)
     this->setZValue(1);
     this->boundRect = QFontMetrics(this->font).boundingRect(this->text);
-    this->boundRect.setHeight(std::max(this->boundRect.height(), std::max(this->modelBox->getMaxInputCount(), uint8_t(1)) * 16.0));
+    this->boundRect.setHeight(std::max(this->boundRect.height(), std::max(this->modelBox->getMaxInputCount(), size_t(1)) * 16.0));
     this->boundRect.adjust(-20, -20, 20, 20);
-    uint8_t maxInputCount = this->modelBox->getMaxInputCount();
-    for (uint8_t i = 0; i < maxInputCount; ++i)
+    size_t maxInputCount = this->modelBox->getMaxInputCount();
+    for (size_t i = 0; i < maxInputCount; ++i)
     {
         auto* box = new InputConnectionBox(this, i);
         box->setPos(this->boundRect.left(), this->boundRect.top() + ((i + 1) * this->boundRect.height()) / float(maxInputCount + 1));

agui2/src/Models/ModelBox.cpp

@@ -8,7 +8,7 @@
 std::vector<ModelBox*> ModelBox::allModelBoxes;
-ModelBox::ModelBox(ModelType type, uint8_t maxInputCount)
+ModelBox::ModelBox(ModelType type, size_t maxInputCount)
     : type(type)
     , maxInputCount(maxInputCount)
     , inputs(maxInputCount, nullptr)
@@ -23,17 +23,17 @@ ModelBox::~ModelBox() {
     bs.erase(std::remove(bs.begin(), bs.end(), this), bs.end());
 }
-void ModelBox::setInput(uint8_t slot, ModelBox* model) {
+void ModelBox::setInput(size_t slot, ModelBox* model) {
     Q_ASSERT(slot < this->maxInputCount);
     this->inputs[slot] = model;
 }
-void ModelBox::addOutput(ModelBox* model, uint8_t slot) {
+void ModelBox::addOutput(ModelBox* model, size_t slot) {
     Q_ASSERT(this->canHaveOutput());
     this->outputs.emplace(model, slot);
 }
-void ModelBox::removeOutput(ModelBox* model, uint8_t slot) {
+void ModelBox::removeOutput(ModelBox* model, size_t slot) {
     Q_ASSERT(this->canHaveOutput());
     this->outputs.erase({model, slot});
 }

agui2/src/Models/ModelBox.hpp

@@ -17,7 +17,7 @@ enum class ModelType {
 class ModelBox {
     friend class ParallelExecutor;
 protected:
-    explicit ModelBox(ModelType type, uint8_t maxInputCount);
+    explicit ModelBox(ModelType type, size_t maxInputCount);
 public:
     virtual ~ModelBox();
@@ -26,11 +26,11 @@ public:
     ModelType getType() const { return this->type; }
     virtual std::string getName() const = 0;
-    void setInput(uint8_t slot, ModelBox* model);
-    void addOutput(ModelBox* model, uint8_t slot);
-    void removeOutput(ModelBox* model, uint8_t slot);
-    uint8_t getMaxInputCount() const { return this->maxInputCount; }
+    void setInput(size_t slot, ModelBox* model);
+    void addOutput(ModelBox* model, size_t slot);
+    void removeOutput(ModelBox* model, size_t slot);
+    size_t getMaxInputCount() const { return this->maxInputCount; }
     virtual bool canHaveOutput() const { return true; }
     std::shared_ptr<abstraction::OperationAbstraction> getCachedResult() const { return this->result; }
@@ -44,9 +44,9 @@ public:
 protected:
     ModelType type;
-    uint8_t maxInputCount = 0;
+    size_t maxInputCount = 0;
     std::vector<ModelBox*> inputs;
-    std::set<std::pair<ModelBox*, uint8_t>> outputs;
+    std::set<std::pair<ModelBox*, size_t>> outputs;
     std::shared_ptr<abstraction::OperationAbstraction> result;
     GraphicsBox* graphicsBox = nullptr;