circuitTree.h

Go to the documentation of this file.

#pragma once
#include <exception>
#include <ostream>
#include <iterator>
#include <typeinfo>

#include "signatureConstants.h"
#include "wireId.h"

class CircuitTree {
    protected:
        class InnerIoIter :
            public std::iterator<std::forward_iterator_tag, WireId*>
        {
            public:
                virtual ~InnerIoIter() {};
                virtual void operator++() {};
                bool operator==(InnerIoIter& oth) {
                    return typeid(*this) == typeid(oth) && equal(oth);
                }
                bool operator!=(InnerIoIter& oth) {
                    return !(operator==(oth));
                }
                virtual WireId* operator*() { return nullptr; }
                virtual InnerIoIter* clone() const {
                    return new InnerIoIter(*this);
                }
            protected:
                virtual bool equal(const InnerIoIter&) const {
                    return true;
                }
        };

    public:
        enum CircType {
            CIRC_GROUP,
            CIRC_COMB,
            CIRC_DELAY,
            CIRC_TRI,
            CIRC_ASSERT,
        };

        class IoIter {
            public:
                IoIter() : inner(nullptr) {}
                IoIter(InnerIoIter* ptr) : inner(ptr) {}
                ~IoIter() { delete inner; }

                IoIter(const IoIter& oth) :
                    inner(oth.inner->clone()) {}
                IoIter& operator=(const IoIter& oth) {
                    delete inner;
                    inner = oth.inner->clone();
                    return *this;
                }

                IoIter& operator++() {
                    ++(*inner);
                    return *this;
                }
                IoIter operator++(int) {
                    IoIter out(*this);
                    operator++();
                    return out;
                }
                WireId* operator*() const { return *(*inner); }

                bool operator==(const IoIter& oth) const {
                    return inner == oth.inner || (*inner) == (*oth.inner);
                }

                bool operator!=(const IoIter& oth) const {
                    return !(operator==(oth));
                }

            private:
                InnerIoIter* inner;
        };

        CircuitTree();
        virtual ~CircuitTree();

        virtual CircType circType() const = 0;

        sign_t sign(int level=2);

        bool equals(CircuitTree* oth);

        bool operator==(const CircuitTree& oth) const {
            return circuitId == oth.circuitId;
        }

        CircuitGroup* ancestor() { return ancestor_; }

        size_t id() const { return circuitId; }

        virtual IoIter inp_begin() const = 0;

        IoIter inp_end() const { return out_begin(); }

        virtual IoIter out_begin() const = 0;

        virtual IoIter out_end() const = 0;

        IoIter io_begin() const { return inp_begin(); }

        IoIter io_end() const { return out_end(); }

        virtual size_t inputCount() const = 0;

        virtual size_t outputCount() const = 0;

        virtual WireId* nth_input(size_t circId) const = 0;

        virtual WireId* nth_output(size_t circId) const = 0;


        virtual void unplug();

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

        void alter(bool uprec = true);

    protected:
        virtual sign_t computeSignature(int level);

        virtual sign_t innerSignature() const = 0;

        virtual bool innerEqual(CircuitTree* othTree) = 0;

        void unplug_common();

        // == Memoization bookkeeping
        typedef size_t memo_ts_t;

        memo_ts_t curHistoryTime;

        memo_ts_t lastAlterationTime;

        struct MemoSign {
            MemoSign(memo_ts_t t, sign_t sig) : timestamp(t), sig(sig) {}
            memo_ts_t timestamp;
            sign_t sig;
        };

        std::vector<MemoSign> memoSig;

        CircuitGroup* ancestor_;

    private:
        static size_t nextCircuitId;
        size_t circuitId;

    friend class CircuitGroup;
};