cofmsg_group_mod.h

/*
 * cofmsg_group_mod.h
 *
 *  Created on: 18.03.2013
 *      Author: andi
 */

#ifndef COFMSG_GROUP_MOD_H_
#define COFMSG_GROUP_MOD_H_ 1

#include "rofl/common/openflow/messages/cofmsg.h"
#include "rofl/common/openflow/cofbuckets.h"
#include "rofl/common/openflow/cofgroupmod.h"

namespace rofl {
namespace openflow {

class cofmsg_group_mod :
        public cofmsg
{
private:

        rofl::openflow::cofbuckets                      buckets;

        union {
                uint8_t*                                        ofhu_group_mod;
                struct openflow12::ofp_group_mod*               ofhu12_group_mod;
                struct openflow13::ofp_group_mod*               ofhu13_group_mod;
        } ofhu;

#define ofh_group_mod   ofhu.ofhu_group_mod
#define ofh12_group_mod ofhu.ofhu12_group_mod
#define ofh13_group_mod ofhu.ofhu13_group_mod

public:


        cofmsg_group_mod(
                        uint8_t of_version,
                        uint32_t xid,
                        rofl::openflow::cofgroupmod const& ge);


        cofmsg_group_mod(
                        uint8_t of_version = 0,
                        uint32_t xid = 0,
                        uint16_t command = 0,
                        uint8_t  group_type = 0,
                        uint32_t group_id = 0,
                        rofl::openflow::cofbuckets const& buckets = rofl::openflow::cofbuckets());


        cofmsg_group_mod(
                        cofmsg_group_mod const& group_mod);


        cofmsg_group_mod&
        operator= (
                        cofmsg_group_mod const& group_mod);


        virtual
        ~cofmsg_group_mod();


        cofmsg_group_mod(cmemory *memarea);


        virtual void
        reset();


        virtual uint8_t*
        resize(size_t len);


        virtual size_t
        length() const;


        virtual void
        pack(uint8_t *buf = (uint8_t*)0, size_t buflen = 0);


        virtual void
        unpack(uint8_t *buf, size_t buflen);


        virtual void
        validate();


        void
        check_prerequisites() const;


public:


        uint16_t
        get_command() const;

        void
        set_command(uint16_t command);

        uint8_t
        get_group_type() const;

        void
        set_group_type(uint8_t group_type);

        uint32_t
        get_group_id() const;

        void
        set_group_id(uint32_t group_id);

        rofl::openflow::cofbuckets&
        get_buckets() { return buckets; };

public:

        friend std::ostream&
        operator<< (std::ostream& os, cofmsg_group_mod const& msg) {
                os << rofl::indent(0) << "<cofmsg_group_mod >" << std::endl;
                { rofl::indent i(2); os << dynamic_cast<const cofmsg&>( msg ); };
                switch (msg.get_command()) {
                        case rofl::openflow12::OFPGC_ADD: {
                                os << indent(4) << "<command: -ADD- >" << std::endl;
                        } break;
                        case rofl::openflow12::OFPGC_MODIFY: {
                                os << indent(4) << "<command: -MODIFY- >" << std::endl;
                        } break;
                        case rofl::openflow12::OFPGC_DELETE: {
                                os << indent(4) << "<command: -DELETE- >" << std::endl;
                        } break;
                        default: {
                                os << indent(4) << "<command: -UNKNOWN- >" << std::endl;
                        };
                        }
                os << indent(4) << "<group-type:"       << (int)msg.get_group_type()    << " >" << std::endl;
                os << indent(4) << "<group-id:"         << (int)msg.get_group_id()              << " >" << std::endl;
                rofl::indent i(4);
                os << msg.buckets;
                return os;
        };
};

} // end of namespace openflow
} // end of namespace rofl

#endif /* COFMSG_GROUP_MOD_H_ */