BaseBlock.h

Go to the documentation of this file.

#ifndef BUSINESS_LOGIC_ELEMENTS_BLOCKS_BASE_BLOCK_H
#define BUSINESS_LOGIC_ELEMENTS_BLOCKS_BASE_BLOCK_H
 
#include <magic_enum/magic_enum.hpp>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "constants.h"
#include "delegate/IBlockLifecycleManagerDelegate.h"
#include "delegate/INewBlockChoiceDelegate.h"
#include "delegate/IWindowDelegate.h"
#include "elements/blocks/BlockType.h"
#include "elements/interactions/IDraggable.h"
#include "geometry/Point2D.h"
#include "geometry/helpers.h"
#include "logging/Loggable.h"
#include "structures/Port.h"
#include "typenames.h"
 
namespace business_logic::delegate {
    class IBlockLifecycleManagerDelegate;  // forward declaration to satisfy clang-tidy
}
 
namespace business_logic::elements {}
 
namespace business_logic::elements::blocks {
    class BaseBlock : public business_logic::elements::interactions::IDraggable {
       public:
        BaseBlock(
            int cx,
            int cy,
            int blockWidth,
            int blockHeight,
            business_logic::delegate::INewBlockChoiceDelegate* newBlockChoiceDelegate,
            // NOLINTBEGIN
            business_logic::delegate::IBlockLifecycleManagerDelegate* blockLifecycleManagerDelegate,
            // NOLINTEND
            business_logic::delegate::IWindowDelegate* windowDelegate,
            std::shared_ptr<spdlog::logger> logger);
 
        void updateWidthHeight(int newWidth, int newHeight);
 
        ~BaseBlock() noexcept override;
 
        // disable copy semantics
        BaseBlock(const BaseBlock&) = delete;
        BaseBlock& operator=(const BaseBlock&) = delete;
 
        // disable move semantics
        BaseBlock(BaseBlock&&) = delete;
        BaseBlock& operator=(BaseBlock&&) = delete;
 
        virtual bool isHovered(int x, int y) const {
            return x >= leftX && x <= rightX && y >= topY && y <= bottomY;
        }
 
        virtual std::optional<std::string> getValueToRenderAboveBlock(
            [[maybe_unused]] bool isHovered);
 
        void onDragStart() override;
 
        void onDragProgress(int x, int y) override;
 
        void onDragEnd() override;
 
        const business_logic::geometry::Point2D& getPortCoordinates(
            const structures::Port* port) const;
 
        std::optional<const structures::Port*> getPortAtCoordinates(
            const geometry::Point2D& point) const;
 
        virtual std::string getSelfId() const = 0;
 
        virtual BlockType getBlockType() const = 0;
 
        const FloatingPoint& getPortValue(const structures::Port* port) const;
 
        void setPortValue(const business_logic::elements::structures::Port* port,
                          const FloatingPoint& value);
 
        virtual void calculateOutputValues() = 0;
 
        // make the hash function a friend to allow it to access non-public members
        friend struct std::hash<BaseBlock>;
 
        virtual const std::vector<structures::Port>& getInputPorts() const = 0;
 
        virtual const std::vector<structures::Port>& getOutputPorts() const = 0;
 
        int getCx() const { return cx; }
 
        int getCy() const { return cy; }
 
        int getLeftX() const { return leftX; }
 
        int getRightX() const { return rightX; }
 
        int getTopY() const { return topY; }
 
        int getBottomY() const { return bottomY; }
 
        int getWidth() const { return width; }
 
        int getHeight() const {  // cppcheck-suppress unusedFunction
            return height;
        }
 
        std::unordered_map<const structures::Port*, geometry::Point2D>& getPortCoordinates() {
            return portCoordinates;
        }
 
       protected:
        int cx;
 
        int cy;
 
        int width;
 
        int height;
 
        int leftX;
 
        int rightX;
 
        int topY;
 
        int bottomY;
 
        float centerY;
 
        std::shared_ptr<spdlog::logger> logger;
 
        std::unordered_map<const structures::Port*, FloatingPoint> portValues;
 
        business_logic::delegate::INewBlockChoiceDelegate* newBlockChoiceDelegate;
 
        // NOLINTBEGIN
        business_logic::delegate::IBlockLifecycleManagerDelegate* blockLifecycleManagerDelegate;
        // NOLINTEND
 
        business_logic::delegate::IWindowDelegate* windowDelegate;
 
        static const FloatingPoint NaN;
 
        std::unordered_map<const structures::Port*, geometry::Point2D> portCoordinates;
 
        void cacheCornerCoordinates();
 
        std::optional<const structures::Port*> checkPort(const structures::Port* port,
                                                         const geometry::Point2D& point) const;
    };
}  // namespace business_logic::elements::blocks
 
namespace std {
    template <>
    struct hash<business_logic::elements::blocks::BaseBlock> {
        std::size_t operator()(const business_logic::elements::blocks::BaseBlock& p) const {
            return std::hash<int>()(p.cx) ^ (std::hash<int>()(p.cy) << 1U);
        }
    };
}  // namespace std
 
#endif  // BUSINESS_LOGIC_ELEMENTS_BLOCKS_BASE_BLOCK_H