db_entry.h

Go to the documentation of this file.

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

#ifndef ctrlplane_db_entry_h
#define ctrlplane_db_entry_h

#include <map>

#include <tbb/atomic.h>

#include "db/db_table.h"

#include <boost/intrusive/list.hpp>
#include <boost/intrusive/set.hpp>

struct DBState {
    virtual ~DBState() { }
};

// Generic database entry
class DBEntryBase {
public:
    typedef DBTableBase::ListenerId ListenerId;
    typedef std::unique_ptr<DBRequestKey> KeyPtr;

    DBEntryBase();
    virtual ~DBEntryBase();
    virtual std::string ToString() const = 0;
    virtual KeyPtr GetDBRequestKey() const = 0;
    virtual bool IsMoreSpecific(const std::string &match) const {
        return false;
    }
    virtual bool IsLessSpecific(const std::string &match) const {
        return false;
    }

    void SetState(DBTableBase *tbl_base, ListenerId listener, DBState *state);
    void ClearState(DBTableBase *tbl_base, ListenerId listener);
    DBState *GetState(DBTableBase *tbl_base, ListenerId listener) const;
    const DBState *GetState(const DBTableBase *tbl_base,
                            ListenerId listener) const;
    bool is_state_empty(DBTablePartBase *tpart);
    bool is_state_empty_unlocked(DBTablePartBase *tpart);

    void Delete();
    void MarkDelete() { flags |= DeleteMarked; }
    void ClearDelete() { flags &= ~DeleteMarked; }
    bool IsDeleted() const { return (flags & DeleteMarked) != 0; }

    void set_onlist() { flags |= Onlist; }
    void clear_onlist() { flags &= ~Onlist; }
    bool is_onlist() { return (flags & Onlist); }

    void SetOnRemoveQ() {
        onremoveq_.fetch_and_store(true);
    }
    bool IsOnRemoveQ() { return (onremoveq_); }
    void ClearOnRemoveQ() {
        onremoveq_.fetch_and_store(false);
    }

    //member hook in change list
    boost::intrusive::list_member_hook<> chg_list_;

    void set_last_change_at(uint64_t time);
    void set_last_change_at_to_now();
    const uint64_t last_change_at() const { return last_change_at_; }
    const std::string last_change_at_str() const;
    void set_last_update_at(uint64_t time);
    void set_last_update_at_to_now();
    const uint64_t last_update_at() const { return last_update_at_; }
    DBTablePartBase *get_table_partition() const;
    void set_table_partition(DBTablePartBase *tpart);
    DBTableBase *get_table() const;
    void Notify();

private:
    enum DbEntryFlags {
        Onlist       = 1 << 0,
        DeleteMarked = 1 << 1,
    };
    typedef std::map<ListenerId, DBState *> StateMap;
    DBTablePartBase *tpart_;
    StateMap state_;
    uint8_t flags;
    tbb::atomic<bool> onremoveq_;
    uint64_t last_change_at_; // time at which entry was last 'changed'
    uint64_t last_update_at_; // time at which entry was last 'updated'
    DISALLOW_COPY_AND_ASSIGN(DBEntryBase);
};

// An implementation of DBEntryBase that uses boost::set as data-store
// Most of the DB Table implementations should derive from here instead of
// DBEntryBase directly.
// Derive directly from DBEntryBase only if there is a strong reason to do so
class DBEntry : public DBEntryBase {
public:
    DBEntry() { };
    virtual ~DBEntry() { };

    // Set key fields in the DBEntry
    virtual void SetKey(const DBRequestKey *key) = 0;

    // Comparator used in Tree management
    virtual bool IsLess(const DBEntry &rhs) const = 0;

    bool operator<(const DBEntry &rhs) const {
        return IsLess(rhs);
    }

private:
    friend class DBTablePartition;
    boost::intrusive::set_member_hook<> node_;
    DISALLOW_COPY_AND_ASSIGN(DBEntry);
};

#endif