PlacementManagerClass.h

#ifndef _PlacementManagerClass_H_
#define _PlacementManagerClass_H_
 
#include <list>
#include <fstream>
#include <SDL.h>
 
#include "./helpers/SDLHelper.h"
 
#include "BaseElectronObject.h"
#include "BaseIcObject.h"
#include "WireObject.h"
#include "FootPinNode.h"
 
class AsgardClass;
 
class PlacementManagerClass
{
    private:
        void releaseMemory();
 
        std::list<FootPinNode*> findAllPinsOnSegment( WireObject* );
        std::list<WireObject*> findAllWiresOnPin( FootPinNode* );
 
        std::list<WireObject*> findoutRedundantWires();
 
        std::list<WireObject*> findoutExactlyIdenticalWires();
 
        // 对指定的多条线段进行批量删除
        void removeWires(std::list<WireObject*>&);
 
        // 对指定的线段进行删除
        void removeWire(WireObject*);
        void removeFootPin(FootPinNode*);
 
        void loginWire(WireObject*);
        void loginIc(BaseIcObject*);
        void loginFootPin(FootPinNode*);
 
        void logoutWire(WireObject*);
        void logoutFootPin(FootPinNode*);
 
        void splitLineByPin(FootPinNode*);
 
    private:
        AsgardClass* asgard = nullptr;
 
    public:
        PlacementManagerClass(AsgardClass*);
        ~PlacementManagerClass();
 
    public:
        std::list<BaseIcObject*> snIcObjects;
 
        std::list<WireObject*> snWires;
 
        std::list<FootPinNode*> snFreeFootPins;
 
        std::list<FootPinNode*> snBoundFootPins;
 
        void Drawing();
 
        bool isPreviewICHolderInFreePlace( BaseIcObject* );
        bool isPreviewWireHolderInFreePlace( WireObject* );
        bool isPreviewFreePointHolderInFreePlace( FootPinNode* );
 
        template<typename T>
            bool conflictWith(const SDL_Rect& rect, const std::list<T>& target)
            {
                for(const auto& _obj : target)
                {
                    const SDL_Rect targetRect = _obj->getLocationRect();
                    if(SDLHelper::SDL_RectsOverlap(rect, targetRect))
                    {
                        return true;
                    }
                }
                return false;
            };
 
        bool PlaceWire( WireObject* );
 
        bool PlaceFootPin( FootPinNode* );
 
        bool PlaceIc( BaseIcObject* );
 
        void resetToBlank();
 
        BaseElectronObject* findObjectUnderMousePos( SDL_Point& );
 
        void ObjectsReport();
 
        void eraseRedundantWires();
 
        bool eraseExactlyIdenticalWires();
 
    private: // 电流结果输出选项
        bool showingCurrentText = false;
    public:
        bool isShowingCurrentText() const { return this->showingCurrentText; };
        void setShowingCurrentText(bool _val) { this->showingCurrentText = _val; };
 
    public: 
        void CalculateCurrents();
        bool buildingFootPinsCurrent();
        void resetCurrentCalculateState();
 
        std::unordered_map<std::string, std::set<FootPinNode*>> samePosFootPins;
        //std::map<std::string, std::set<FootPinNode*>> samePosFootPins;
 
        std::list<FootPinNode*> waitToCalculateCurrentFootPins;
 
        bool canCalcCurrentBySamePosOtherPins(FootPinNode* footPin);
        double calcCurrentBySamePosOtherPins(FootPinNode* footPin);
 
        void remarkPinsValidState();
        void markInvalidPins();
 
        void saveToFile(std::ofstream&);
};
 
#endif