NetlistManagerClass.h

#ifndef _NetlistManagerClass_H_
#define _NetlistManagerClass_H_
 
#include <list>
#include <SDL.h>
#include "NetlistClass.h"
#include "MathMatrixClass.h"
 
class AsgardClass;
class WireObject;
class FootPinNode;
 
class NetlistManagerClass
{
    private:
        void resortNetlistsIndex();
        void releaseMemory();
        void releaseMathQuestionMemory();
        void createMathQuestionMemory();
 
        MathMatrixClass::Matrix* mathQuestionA = nullptr;
        MathMatrixClass::VectorDouble* mathQuestionB = nullptr;
        MathMatrixClass::VectorDouble* mathQuestionSolution = nullptr;
        MathMatrixClass::VectorIndex* mathQuestionSolutionBeloneNetlistIndex = nullptr;
 
        AsgardClass* asgard = nullptr;
 
    public:
 
        enum class BindResult
        {
            Failed = 0,
            NewLine,
            NewFootPin,
            CurrentNetlist,
            Subline,
        };
 
        NetlistManagerClass( AsgardClass* );
        ~NetlistManagerClass();
 
        void Drawing();
 
        NetlistManagerClass::BindResult addOrBindNetlist( WireObject* );
        NetlistManagerClass::BindResult addOrBindNetlist( FootPinNode* );
 
        NetlistClass* merge( NetlistClass* , NetlistClass* );
 
        void resetToBlank();
 
        void BuildMatrixParams(std::list<NetlistClass*>&, std::list<NetlistClass*>&);
        void PrintMatrixParams();
        void CalculateVoltages(std::list<NetlistClass*>&);
        void Reporting(std::list<NetlistClass*>&);
        void Reporting();
 
    private: 
        bool showingVoltageText = false;
    public:
        bool isShowingVoltageText() const { return this->showingVoltageText; };
        void setShowingVoltageText(bool _val) { this->showingVoltageText = _val; };
 
    private:
        std::list<NetlistClass*> netlists;
    public:
        void removeNetlist(NetlistClass*);
        size_t countNetlists() const { return this->netlists.size(); };
 
    public:
        NetlistClass* createNetlist(BaseElectronObject*);
 
        void WriteBackVoltageToEachNetlists(std::list<NetlistClass*>&);
        void WriteBackVoltageToEachFootPins(std::list<NetlistClass*>&);
 
    public:
        std::list< std::list<NetlistClass*> > netlistParts();
 
        std::list<NetlistClass*> fetchGroundNetlists(const std::list<NetlistClass*>&);
};
 
#endif