forwarding_class.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */

#ifndef __AGENT_OPER_FORWARDING_CLASS_H
#define __AGENT_OPER_FORWARDING_CLASS_H

#include <cmn/agent.h>
#include <oper_db.h>
#include <cmn/index_vector.h>

class Agent;
class DB;
class ForwardingClassTable;

struct ForwardingClassKey : public AgentOperDBKey {
    ForwardingClassKey(const boost::uuids::uuid &uuid):
        uuid_(uuid) {}

    ForwardingClassKey(const ForwardingClassKey &rhs):
        uuid_(rhs.uuid_) {}

    bool IsLess(const ForwardingClassKey &rhs) const {
        return uuid_ < rhs.uuid_;
    }

    boost::uuids::uuid uuid_;
};

struct ForwardingClassData : public AgentOperDBData {

    ForwardingClassData(const Agent *agent, IFMapNode *node,
                        uint32_t dscp, uint32_t vlan_priority,
                        uint32_t mpls_exp, uint32_t id,
                        const boost::uuids::uuid &qos_queue_uuid,
                        const std::string &name):
    AgentOperDBData(agent, node), dscp_(dscp), vlan_priority_(vlan_priority),
    mpls_exp_(mpls_exp), id_(id), qos_queue_uuid_(qos_queue_uuid) {}

    uint32_t dscp_;
    uint32_t vlan_priority_;
    uint32_t mpls_exp_;
    uint32_t id_;
    boost::uuids::uuid qos_queue_uuid_;
    std::string name_;
};

class ForwardingClass :
    AgentRefCount<ForwardingClass>, public AgentOperDBEntry {
        public:
    ForwardingClass(const boost::uuids::uuid &uuid);
    virtual ~ForwardingClass();

    KeyPtr GetDBRequestKey() const;
    std::string ToString() const;
    virtual bool IsLess(const DBEntry &rhs) const;
    virtual bool DBEntrySandesh(Sandesh *resp, std::string &name) const;

    virtual bool Change(const DBRequest *req);
    virtual void Delete(const DBRequest *req);
    virtual void SetKey(const DBRequestKey *key);

    virtual bool DeleteOnZeroRefCount() const {
        return false;
    }
    virtual void OnZeroRefCount() {};
    uint32_t GetRefCount() const {
        return AgentRefCount<ForwardingClass>::GetRefCount();
    }

    uint32_t dscp() const {return dscp_;}
    uint32_t vlan_priority() const {return vlan_priority_;}
    uint32_t mpls_exp() const { return mpls_exp_;}
    uint32_t id() const {return id_;}
    const QosQueue* qos_queue_ref() const {
        return qos_queue_ref_.get();
    }
    const boost::uuids::uuid& uuid() const {
        return uuid_;
    }
    const std::string& name() const {
        return name_;
    }

    uint16_t nic_queue_id() const {
        return nic_queue_id_;
    }

private:
    boost::uuids::uuid uuid_;
    uint32_t id_;
    uint32_t dscp_;
    uint32_t vlan_priority_;
    uint32_t mpls_exp_;
    QosQueueConstRef qos_queue_ref_;
    std::string name_;
    uint16_t nic_queue_id_;
    DISALLOW_COPY_AND_ASSIGN(ForwardingClass);
};

class ForwardingClassTable : public AgentOperDBTable {
public:
    ForwardingClassTable(Agent *agent, DB *db, const std::string &name);
    virtual ~ForwardingClassTable();
    static const uint32_t kInvalidIndex=0xFF;

    static DBTableBase *CreateTable(Agent *agent, DB *db,
                                    const std::string &name);

    virtual std::unique_ptr<DBEntry> AllocEntry(const DBRequestKey *k) const;

    virtual size_t Hash(const DBEntry *entry) const {return 0;}
    virtual size_t Hash(const DBRequestKey *key) const {return 0;}

    virtual DBEntry *OperDBAdd(const DBRequest *req);
    virtual bool OperDBOnChange(DBEntry *entry, const DBRequest *req);
    virtual bool OperDBDelete(DBEntry *entry, const DBRequest *req);
    virtual bool OperDBResync(DBEntry *entry, const DBRequest *req);

    virtual bool IFNodeToReq(IFMapNode *node, DBRequest &req,
                             const boost::uuids::uuid &u);
    virtual bool IFNodeToUuid(IFMapNode *node, boost::uuids::uuid &u);
    virtual bool ProcessConfig(IFMapNode *node, DBRequest &req,
                               const boost::uuids::uuid &u);
    virtual AgentSandeshPtr GetAgentSandesh(const AgentSandeshArguments *args,
                                            const std::string &context);
    ForwardingClassData* BuildData(IFMapNode *node);
private:
    DISALLOW_COPY_AND_ASSIGN(ForwardingClassTable);
};
#endif