circuitGroup.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <vector>
#include <exception>

#include "wireId.h"
#include "wireManager.h"
#include "circuitTree.h"
#include "subcircMatch.h"

class CircuitGroup;

class IOPin {
    public:
        class AlreadyConnected : std::exception {};

        IOPin(WireId* formal, WireId* actual, CircuitGroup* group);

        IOPin(std::string formalName, WireId* actual, CircuitGroup* group);

        void connect(WireId* formal);

        WireId* formal() const { return _formal; }
        std::string formalName() const { return _formalName; }
        WireId* actual() const { return _actual; }
        CircuitGroup* group() const { return _group; }

    private:
        void link();

        WireId* _formal;
        std::string _formalName; 
        WireId* _actual;
        CircuitGroup* _group;

        friend CircuitGroup;
};


class CircuitGroup : public CircuitTree {
    protected:
        // ========= I/O ITERATOR =============================================
        class InnerIoIter : public CircuitTree::InnerIoIter {
                typedef std::vector<IOPin*>::const_iterator LowIter;
                LowIter ptr;
                const CircuitGroup* circ;
            public:
                InnerIoIter(const CircuitGroup* circ, LowIter lowIter)
                    : ptr(lowIter), circ(circ)
                {
                    nextValid();
                }
                InnerIoIter(const InnerIoIter& it)
                    : ptr(it.ptr) {}
                virtual void operator++();
                virtual WireId* operator*() { return (*ptr)->formal(); }
                virtual InnerIoIter* clone() const {
                    return new InnerIoIter(*this);
                }
            protected:
                virtual bool equal(const CircuitTree::InnerIoIter& oth_) const
                {
                    const InnerIoIter& oth =
                        static_cast<const InnerIoIter&>(oth_);
                    return ptr == oth.ptr && circ == oth.circ;
                }
            private:
                void nextValid();
                void innerIncr();
        };

    public:
        IoIter inp_begin() const {
            return IoIter(
                    new InnerIoIter(this, grpInputs.begin())
                    );
        }
        IoIter out_begin() const {
            return IoIter(
                    new InnerIoIter(this, grpOutputs.begin())
                    );
        }
        IoIter out_end() const {
            return IoIter(
                    new InnerIoIter(this, grpOutputs.end())
                    );
        }
        // ========= END I/O ITERATOR =========================================

        CircuitGroup(const std::string& name);

        CircuitGroup(const std::string& name, WireManager* manager);

        ~CircuitGroup();

        CircType circType() const { return CIRC_GROUP; }

        void addChild(CircuitTree* child);

        void addInput(const IOPin& pin);

        void addInput(const std::string& formal, WireId* actual);

        void addOutput(const IOPin& pin);

        void addOutput(const std::string& formal, WireId* actual);

        std::vector<CircuitTree*>& getChildren();
        const std::vector<CircuitTree*>& getChildren() const;

        const std::vector<CircuitTree*>& getChildrenCst() const;

        std::vector<IOPin*>& getInputs();
        const std::vector<IOPin*>& getInputs() const;

        std::vector<IOPin*>& getOutputs();
        const std::vector<IOPin*>& getOutputs() const;

        sign_t ioSigOf(WireId* id);

        WireManager* wireManager() { return wireManager_; }
        // Note: this cannot be `const`, since the `wireManager_` is muted
        // whenever one tries to allocate a wire.

        std::vector<MatchResult> find(CircuitGroup* needle);

        const std::string& name() const { return name_; }

        // Documentation in CircuitTree*
        size_t inputCount() const;
        size_t outputCount() const;
        WireId* nth_input(size_t circId) const;
        WireId* nth_output(size_t circId) const;

        virtual void unplug();

        void toDot(std::basic_ostream<char>& out, int indent=0);

    protected:
        void alteredChild();

        virtual sign_t innerSignature() const;
        virtual bool innerEqual(CircuitTree* othTree);
        void computeIoSigs();

    private:
        class NoSuchChild: public std::exception {};

        void setAncestor(CircuitTree* tree) const;

        void disconnectChild(CircuitTree* toRemove);

        std::string name_;

        WireManager* wireManager_;

        std::vector<CircuitTree*> grpChildren;
        std::vector<IOPin*> grpInputs, grpOutputs;

        memo_ts_t ioSigsTimestamp;
        std::unordered_map<WireId*, sign_t> ioSigs_;

    friend class CircuitTree;
};