CaFactory.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of nucad (Non-Uniform CA Designer).
 *
 * nucad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * nucad is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with nucad.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CA_FACTORY_H
#define CA_FACTORY_H

#include "Ca.h"

#ifndef BUILDING_DOX
#   include <string>
#endif

class CaEvaluator;

class CaEvaluatorFactory {
    public:
        CaEvaluatorFactory();
        ~CaEvaluatorFactory();

        CaEvaluator *create(const std::string &name);

        void printList(std::ostream &str);

    private:
        struct Private;
        Private *d;
};

template <bool> struct CT_ASSERT;
template <> struct CT_ASSERT <true> { };

class BindNothing
#ifndef BUILDING_DOX
    : public IGateBinding
#endif
{
    public:
        static const TBus BOUND_INPUTS = 0;
        static const TBus BOUND_OUTPUTS = 0;
    public:
        virtual IGateBinding* clone() const {
            return new BindNothing(*this);
        }
        virtual void setInput(CaState &, TBus) const {
        }
        virtual void setOutput(CaState &, TBus) const {
        }
        virtual TBus getOutput(const CaState &) const {
            return 0;
        }
};

template <int INPUT, int ROW, int COL, class PARENT = BindNothing>
class BindInput:
#ifdef BUILDING_DOX
    public IGateBinding
#else
    public PARENT
#endif
{
    public:
        static const TBus MASK = 1 << INPUT;
        static const TBus BOUND_INPUTS = PARENT::BOUND_INPUTS | MASK;
        static const TBus BOUND_OUTPUTS = PARENT::BOUND_OUTPUTS;

    public:
        virtual IGateBinding* clone() const {
            return new BindInput(*this);
        }
        virtual void setInput(CaState &ca, TBus in) const {
            PARENT::setInput(ca, in);
            ca.setCellAtPos(Pos(ROW, COL), in & MASK);
        }

    private:
        // abort compilation if input INPUT is already bound
        CT_ASSERT<!(PARENT::BOUND_INPUTS & MASK)>
            ___COMPILE_TIME_ERROR__INPUT_ALREADY_BOUND___;
};

template <int OUTPUT, int ROW, int COL, class PARENT = BindNothing>
class BindOutput:
#ifdef BUILDING_DOX
    public IGateBinding
#else
    public PARENT
#endif
{
    public:
        static const TBus MASK = 1 << OUTPUT;
        static const TBus BOUND_INPUTS = PARENT::BOUND_INPUTS;
        static const TBus BOUND_OUTPUTS = PARENT::BOUND_OUTPUTS | MASK;

    public:
        virtual IGateBinding* clone() const {
            return new BindOutput(*this);
        }
        virtual void setOutput(CaState &ca, TBus out) const {
            PARENT::setOutput(ca, out);
            ca.setCellAtPos(Pos(ROW, COL), out & MASK);
        }
        virtual TBus getOutput(const CaState &ca) const {
            TBus val = ca.getCellAtPos(Pos(ROW,COL));
            val <<= OUTPUT;
            val |= PARENT::getOutput(ca);
            return val;
        }

    private:
        // abort compilation if output OUTPUT is already bound
        CT_ASSERT<!(PARENT::BOUND_OUTPUTS & MASK)>
            ___COMPILE_TIME_ERROR__OUTPUT_ALREADY_BOUND___;
};

template <int N_IN, int N_OUT>
class AbstractGate: public IGate {
    public:
        virtual size_t nInputs() const {
            return N_IN;
        }
        virtual size_t nOutputs() const {
            return N_OUT;
        }
};

template <int N>
class BusGate: public AbstractGate<N, N> {
    public:
        virtual IGate* clone() const {
            return new BusGate(*this);
        }
        virtual TBus operator[] (TBus in) const {
            return in;
        }
};

template <int N>
class CrossGate: public AbstractGate<N, N> {
    public:
        virtual IGate* clone() const {
            return new CrossGate(*this);
        }
        virtual TBus operator[] (TBus in) const {
            TBus out = 0;
            for (int i = 0; i < N; ++i) {
                const TBus mask = 1 << (N - 1 -i);
                if (in & mask)
                    out |= 1 << i;
            }
            return out;
        }
};

template <int N>
class MulGate: public AbstractGate<N, N> {
        static const int A = N >> 1;
        static const int B = N - A;
    public:
        virtual IGate* clone() const {
            return new MulGate(*this);
        }
        virtual TBus operator[] (TBus in) const {
            TBus inA = in & ((1 << A) - 1);
            in >>= A;
            TBus inB = in & ((1 << B) - 1);
            TBus out = inA * inB;
            return out & ((1 << N) - 1);
        }
};

template <int N>
class CommonGateBase: public AbstractGate<N, 1> {
    public:
        virtual TBus operator[] (TBus in) const {
            bool out = this->init();
            for (unsigned i = 0; i < N; ++i)
                this->perform (out, in & (1 << i));
            return out;
        }

    protected:
        virtual bool init() const = 0;

        virtual void perform(bool &out, bool in) const = 0;
};

template <int N>
class AndGate: public CommonGateBase<N> {
    public:
        virtual IGate* clone() const {
            return new AndGate(*this);
        }
    protected:
        virtual bool init() const {
            return true;
        }
        virtual void perform(bool &out, bool in) const {
            out &= in;
        }
};

template <int N>
class OrGate: public CommonGateBase<N> {
    public:
        virtual IGate* clone() const {
            return new OrGate(*this);
        }
    protected:
        virtual bool init() const {
            return false;
        }
        virtual void perform(bool &out, bool in) const {
            out |= in;
        }
};

template <int N>
class XorGate: public CommonGateBase<N> {
    public:
        virtual IGate* clone() const {
            return new XorGate(*this);
        }
    protected:
        virtual bool init() const {
            return false;
        }
        virtual void perform(bool &out, bool in) const {
            out ^= in;
        }
};

#endif // CA_FACTORY_H

---