logic_vm.hpp

Ugrás a fájl dokumentációjához.

#ifndef __LOGIC_VM_HPP__
#define __LOGIC_VM_HPP__

#include <iostream>
#include <fstream>
#include <list>
#include <vector>
#include <functional>
#include <utility>

class logic_vm {
    public:
        class block {
            public:
                class port {
                    private:
                        std::string name;
                        bool state;
                        std::vector<port*> driven;
                        block* owner;
                        bool uninit;
                    public:
                        port(std::string const &name = "port default", bool state = false, block *owner = nullptr, bool uninit=true) : name(name), state(state), owner(owner), uninit(uninit) {
                        }
                        void set_state(bool new_state) {
                            if ((state != new_state) || uninit) {
                                uninit=false;
                                if(owner!=nullptr) {
                                    if(owner->parent!=nullptr) {
                                        std::cout << owner->parent->get_name() << ".";
                                    }
                                    std::cout << owner->get_id() << ".";
                                }
                                std::cout << name << ": " << state << " -> " << new_state << std::endl;  
                                state = new_state;
                                if(owner!=nullptr && driven.size()==0) {
                                    if (owner->parent != nullptr) {
                                        owner->parent->queue.push_back(std::make_pair(owner->parent->get_time() + owner->get_delay(), [&] () {owner->eval(); } )); 
                                    }
                                    else {
                                        throw "";
                                    }
                                }
                                if(driven.size()>0) {
                                    for(auto &drive: driven) {
                                        drive->set_state(state);
                                    }
                                }
                            }
                        }
                        void set_name(std::string const &new_name) {
                            name = new_name;
                        }
                        block* get_owner() { return owner; }
                        bool get_state() { return state; }
                        std::string get_name() { return name; }
                        void add_driven(port &p) {
                            driven.push_back(&p);
                            owner->parent->dot_file << owner->id << name << "->" << p.owner->id << p.name << "\n";
                        }
                        void print() {
                            std::cout << "\t" << name << " -> " << state;
                            //                    if(owner!=nullptr)
                            //                        std::cout << "\t Owner: " << owner->id ;
                            //                    std::cout << std::endl;
                        }
                        ~port() {}
                };
            protected:
                std::string id;
                std::vector<port> input;
                std::vector<port> output;
                std::vector<std::function<void()> > events;
                unsigned delay;
                logic_vm *parent;
            public:
                block(std::string const &id = "block default", unsigned delay=1, logic_vm *parent=nullptr) : id(id), delay(delay), parent(parent) {};
                void set_id(std::string const &tag) {
                    id = tag;
                }
                std::string get_id() { return id; }
                void add_port(std::string const &name, std::string type) {
                    parent->dot_file << id << name << " [label=\"" << name << "\" shape=\"circle\"]\n";
                    if(type=="input") {
                        input.push_back(port(name,false,this));
                        parent->dot_file << id << name << "->" << id << "\n";
                    }
                    else {
                        output.push_back(port(name,false,this));
                        parent->dot_file << id << "->" << id << name << "\n";
                    }
                }
                unsigned get_delay() { return delay; }
                void set_port(std::string const &name, bool value) {
                    for(auto &p: input) {
                        if(p.get_name() == name) {
                            p.set_state(value);
                        }
                    }
                }
                port & get_port(std::string const& name){
                    for(auto &in: input) 
                        if(in.get_name() == name)
                            return in;
                    for(auto &out: output)
                        if(out.get_name() == name)
                            return out;
                    throw "";
                }
                void connect(std::string const &out, block &b, std::string const &in) {
                    this->get_port(out).add_driven(b.get_port(in));

                    std::cout << "Connect ";
                    if(this->parent != nullptr)
                        std::cout << this->parent->get_name() << ".";
                    std::cout << this->id << "." << get_port(out).get_name() << " -> ";
                    if(b.parent != nullptr)
                        std::cout << b.parent->get_name() << ".";
                    std::cout << b.id << "." << b.get_port(in).get_name() << std::endl;
                }
                void eval() {
                    for(auto gyi: events) {
                        gyi();
                    }
                }
                void print() {
                    std::cout << "ID: " << id << std::endl;
                    std::cout << "Delay: " << delay << std::endl;
                    std::cout << "Input(s): ";
                    for(auto &in: input) in.print();
                    std::cout << std::endl;
                    std::cout << "Output(s): ";
                    for(auto &out: output) out.print();
                    std::cout << std::endl;
                    if (parent != nullptr) 
                        std::cout << "Parent: " << parent->get_name() << std::endl;
                }
                void set_parent(logic_vm *p) { parent = p; }
                virtual ~block() { }

        };
    private:
        unsigned time_stamp=0;
        std::string vm_name;
    protected:
        std::list<std::pair<unsigned, std::function<void()> > > queue;
        std::ofstream dot_file;
    public:
        std::list<block*> elements;
        logic_vm(std::string const &vm_name="Default-VM") : vm_name(vm_name) { 
            std::cout << "Logic VM " << vm_name << " has been created." << std::endl; 
            dot_file.open(vm_name+".dot");
            dot_file << "digraph " << vm_name << " {\n";
        }
        void add(block *element) {
            element->set_parent(this);
            elements.push_back(element);
            dot_file << element->get_id() << " [label=\"" << element->get_id() << "\" shape=\"box\"]" << "\n";
        }

        block& element(std::string const &id) {
            for( auto &element: elements)
                if (element->get_id() == id)
                    return *element;
            throw "";
        }

        std::string get_name() { return vm_name; }
        unsigned get_time() { return time_stamp; }
        void info() {
            std::cout << "    VM informations:" << std::endl;
            std::cout << "\t vm_name: \t\t" << vm_name << std::endl;
            std::cout << "\t time_stamp: \t\t" << time_stamp << std::endl;
            std::cout << "\t Elements in the VM: \t" << elements.size() << std::endl;
            std::cout << "\t Events in the queue: \t" << queue.size() << std::endl;
        }

        void run(unsigned end) {
            unsigned until = time_stamp+end;
            for(; time_stamp<until; ++time_stamp) {
                while(queue.front().first == time_stamp) {
                    std::cout << "Event at " << time_stamp << std::endl;
                    (queue.front().second)();
                    queue.pop_front();
                }
            }
        }

        void list_queue() {
            for(auto instance: queue) {
                std::cout << "Time: " << instance.first << std::endl;
            }
        }

        ~logic_vm() { 
            dot_file << "}\n";
            dot_file.close();
            std::cout << "Logic VM " << vm_name << " has been destructed." << std::endl; 
        }
};

#endif // __LOGIC_VM_HPP__