cflowtable.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * cflowtable.h
 *
 *  Created on: 15.08.2014
 *      Author: andreas
 */

#ifndef CFLOWTABLE_H_
#define CFLOWTABLE_H_

#include <map>
#include <ostream>
#include <exception>
#include <inttypes.h>

#include <rofl/common/crofbase.h>
#include <rofl/common/crofdpt.h>
#include <rofl/common/caddress.h>

#include "cflowentry.h"

namespace rofl {
namespace examples {
namespace ethswctld {

class cflowtable : public cflowentry_env {
public:

        static
        cflowtable&
        add_flowtable(
                        const rofl::cdptid& dptid) {
                if (cflowtable::flowtables.find(dptid) != cflowtable::flowtables.end()) {
                        delete cflowtable::flowtables[dptid];
                        cflowtable::flowtables.erase(dptid);
                }
                new cflowtable(dptid);
                return *(cflowtable::flowtables[dptid]);
        };

        static
        cflowtable&
        set_flowtable(
                        const rofl::cdptid& dptid) {
                if (cflowtable::flowtables.find(dptid) == cflowtable::flowtables.end()) {
                        new cflowtable(dptid);
                }
                return *(cflowtable::flowtables[dptid]);
        };

        static
        const cflowtable&
        get_flowtable(
                        const rofl::cdptid& dptid) {
                if (cflowtable::flowtables.find(dptid) == cflowtable::flowtables.end()) {
                        throw exceptions::eFlowNotFound("cflowtable::get_flowtable() dptid not found");
                }
                return *(cflowtable::flowtables.at(dptid));
        };

        static
        void
        drop_flowtable(
                        const rofl::cdptid& dptid) {
                if (cflowtable::flowtables.find(dptid) == cflowtable::flowtables.end()) {
                        return;
                }
                delete cflowtable::flowtables[dptid];
                cflowtable::flowtables.erase(dptid);
        };

        static
        bool
        has_flowtable(
                        const rofl::cdptid& dptid) {
                return (not (cflowtable::flowtables.find(dptid) == cflowtable::flowtables.end()));
        };

public:

        void
        clear() {
                for (std::map<rofl::caddress_ll, std::map<rofl::caddress_ll, cflowentry*> >::iterator
                                it = ftable.begin(); it != ftable.end(); ++it) {
                        for (std::map<rofl::caddress_ll, cflowentry*>::iterator
                                        jt = it->second.begin(); jt != it->second.end(); ++jt) {
                                delete jt->second;
                        }
                }
                ftable.clear();
        };

        cflowentry&
        add_flow_entry(
                        const rofl::caddress_ll& src,
                        const rofl::caddress_ll& dst,
                        uint32_t portno) {
                if (src.is_multicast() || src.is_null() || dst.is_multicast() || dst.is_null()) {
                        throw exceptions::eFlowInval("cflowtable::add_flow_entry() invalid address");
                }
                if (ftable[src].find(dst) != ftable[src].end()) {
                        drop_flow_entry(src, dst);
                }
                ftable[src][dst] = new cflowentry(this, dptid, src, dst, portno);
                return *(ftable[src][dst]);
        };

        cflowentry&
        set_flow_entry(
                        const rofl::caddress_ll& src,
                        const rofl::caddress_ll& dst,
                        uint32_t portno) {
                if (src.is_multicast() || src.is_null() || dst.is_multicast() || dst.is_null()) {
                        throw exceptions::eFlowInval("cflowtable::set_flow_entry() invalid address");
                }
                if (ftable[src].find(dst) == ftable[src].end()) {
                        ftable[src][dst] = new cflowentry(this, dptid, src, dst, portno);
                }
                return *(ftable[src][dst]);
        };

        cflowentry&
        set_flow_entry(
                        const rofl::caddress_ll& src,
                        const rofl::caddress_ll& dst) {
                if (src.is_multicast() || src.is_null() || dst.is_multicast() || dst.is_null()) {
                        throw exceptions::eFlowInval("cflowtable::set_flow_entry() invalid address");
                }
                if (ftable[src].find(dst) == ftable[src].end()) {
                        throw exceptions::eFlowNotFound("cflowtable::set_flow_entry() destination address not found");
                }
                return *(ftable[src][dst]);
        };

        const cflowentry&
        get_flow_entry(
                        const rofl::caddress_ll& src,
                        const rofl::caddress_ll& dst) const {
                if (src.is_multicast() || src.is_null() || dst.is_multicast() || dst.is_null()) {
                        throw exceptions::eFlowInval("cflowtable::get_flow_entry() invalid address");
                }
                if (ftable.at(src).find(dst) == ftable.at(src).end()) {
                        throw exceptions::eFlowNotFound("cflowtable::get_flow_entry() destination address not found");
                }
                return *(ftable.at(src).at(dst));
        };

        void
        drop_flow_entry(
                        const rofl::caddress_ll& src,
                        const rofl::caddress_ll& dst) {
                if (ftable[src].find(dst) == ftable[src].end()) {
                        return;
                }
                cflowentry* flowentry = ftable[src][dst];
                ftable[src].erase(dst);
                delete flowentry;
        };

        bool
        has_flow_entry(const rofl::caddress_ll& src, const rofl::caddress_ll& dst) const {
                return (not (ftable.at(src).find(dst) == ftable.at(src).end()));
        };

private:

        cflowtable(
                        const rofl::cdptid& dptid) :
                                dptid(dptid) {
                cflowtable::flowtables[dptid] = this;
        };

        virtual
        ~cflowtable() {
                clear();
                cflowtable::flowtables.erase(dptid);
        };

private:

        virtual void
        flow_timer_expired(
                        const cflowentry& entry) {
                drop_flow_entry(entry.get_src(), entry.get_dst());
        };

public:

        friend std::ostream&
        operator<< (std::ostream& os, cflowtable const& flowtable) {
                try {
                        os << rofl::indent(0) << "<cflowtable dpid:"
                                        << rofl::crofdpt::get_dpt(flowtable.dptid).get_dpid().str() << " >" << std::endl;
                } catch (rofl::eRofDptNotFound& e) {
                        os << rofl::indent(0) << "<cflowtable dptid:" << flowtable.dptid << " >" << std::endl;
                }
                rofl::indent i(2);
                for (std::map<rofl::caddress_ll, std::map<rofl::caddress_ll, cflowentry*> >::const_iterator
                                it = flowtable.ftable.begin(); it != flowtable.ftable.end(); ++it) {
                        for (std::map<rofl::caddress_ll, cflowentry*>::const_iterator
                                        jt = it->second.begin(); jt != it->second.end(); ++jt) {
                                os << *(jt->second);
                        }
                }
                return os;
        };

private:

        rofl::cdptid dptid;
        std::map<rofl::caddress_ll, std::map<rofl::caddress_ll, cflowentry*> > ftable;
        static std::map<rofl::cdptid, cflowtable*> flowtables;
};

}; // namespace ethswctld
}; // namespace examples
}; // namespace rofl

#endif /* CFLOWTABLE_H_ */