wireId.h

Go to the documentation of this file.

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

// Circular inclusion
class CircuitTree;
class CircuitGroup;
class WireManager;
class IOPin;

class WireId {
    public:
        struct PinConnection {
            PinConnection(IOPin* pin, WireId* other) :
                pin(pin), other(other) {}
            IOPin* pin;
            WireId* other;
        };

        class CircIterator {
            typedef std::vector<CircuitTree*>::iterator CircIter;
            typedef std::vector<PinConnection>::iterator PinIter;

            public:
                CircIterator(const CircIter& iter, WireId* parent);
                CircIterator(const PinIter& iter, WireId* parent) :
                    pinIter(iter), isCircIter(false), parent(parent) {}

                CircIterator(const CircIterator& oth) {
                    operator=(oth);
                }
                void operator=(const CircIterator& oth) {
                    isCircIter = oth.isCircIter;
                    if(isCircIter)
                        circIter = oth.circIter;
                    else
                        pinIter = oth.pinIter;
                }

                CircIterator& operator++();

                CircuitTree* operator*() const;

                bool operator==(const CircIterator& oth) const {
                    return parent == oth.parent &&
                        isCircIter == oth.isCircIter &&
                        ((isCircIter && circIter == oth.circIter)
                         || (!isCircIter && pinIter == oth.pinIter));
                }
                bool operator!=(const CircIterator& oth) const {
                    return !operator==(oth);
                }


            private:
                union {
                    CircIter circIter;
                    PinIter pinIter;
                };
                bool isCircIter;
                WireId* parent;
        };

        class NoSuchConnection : public std::exception {};

        WireId(size_t id, const std::string& name, WireManager* manager);

        ~WireId();

        bool operator==(const WireId& oth) const;

        bool operator==(WireId& oth);

        bool operator!=(const WireId& oth) const;
        bool operator!=(WireId& oth);

        bool operator<(const WireId& oth) const;

        bool operator<(WireId& oth);

        void connect(CircuitTree* circ);

        void connect(const PinConnection& pin);

        void connect(IOPin* pin, WireId* other);

        void disconnect(CircuitTree* circ);

        void disconnect(IOPin* pin);

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

        const std::vector<PinConnection>& connectedPins();

        size_t connectedCount() {
            return connectedCirc().size() + connectedPins().size();
        }

        CircIterator adjacent_begin();

        CircIterator adjacent_end();

        std::vector<CircuitTree*> connected();

        const std::string& name() { return inner()->name; }

        const std::string& name() const { return inner()->name; }

        std::string uniqueName();

    private:
        void walkConnected(std::unordered_set<CircuitTree*>& curConnected,
                std::unordered_set<WireId>& seenWires,
                WireId* curWire);

        struct Inner {
            size_t id;
            std::string name;
            WireManager* manager;
            std::vector<CircuitTree*> connected;
            std::vector<PinConnection> connectedPins;
        };

        void merge(WireId* other);
        void rename(const std::string& nName) { inner()->name = nName; }

        WireId* ufRoot();
        inline Inner* inner() { return ufRoot()->end; };
        const Inner* inner() const;

        union {
            Inner* end;
            WireId* chain;
        };
        bool isEndpoint;
        unsigned short ufDepth;

    friend WireManager; // set the wire's name
    friend struct std::hash<WireId>;
    friend struct std::hash<WireId*>;
    friend struct HashWirePtr;
};

namespace std {
    template<> struct hash<WireId> {
        typedef WireId argument_type;
        typedef std::size_t result_type;
        result_type operator()(const argument_type& wire) const {
            return wire.inner()->id;
        }
    };

    template<> struct hash<WireId*> {
        typedef WireId* argument_type;
        typedef std::size_t result_type;
        result_type operator()(const argument_type& wire) const {
            return wire->inner()->id;
        }
    };

    template<> struct equal_to<WireId*> {
        bool operator()(const WireId* lhs, const WireId* rhs) const
        {
            return *lhs == *rhs;
        }
    };
}