twohop.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8 sw=4:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU General Public License is not permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/contrib/olsr/twohop.hh,v 1.3 2008/10/02 21:56:36 bms Exp $

#ifndef __OLSR_TWOHOP_HH__
#define __OLSR_TWOHOP_HH__

class Neighbor;
class Neighborhood;

// From now on, N1 is shorthand for "one-hop neighbor", and
// N2 is shorthand for "two-hop neighbor".

class TwoHopNeighbor {
  public:
    TwoHopNeighbor(EventLoop& ev,
           Neighborhood* parent,
           const OlsrTypes::TwoHopNodeID id,
           const IPv4& main_addr,
           const OlsrTypes::TwoHopLinkID tlid);

    inline OlsrTypes::TwoHopNodeID id() const { return _id; }
    inline IPv4 main_addr() const { return _main_addr; }

    string toStringBrief();

    void add_twohop_link(const OlsrTypes::TwoHopLinkID tlid);

    bool delete_twohop_link(const OlsrTypes::TwoHopLinkID tlid);

    size_t delete_all_twohop_links();

    inline const set<OlsrTypes::TwoHopLinkID>& twohop_links() const {
    return _twohop_links;
    }

    void add_covering_mpr(const OlsrTypes::NeighborID nid);

    void withdraw_covering_mpr(const OlsrTypes::NeighborID nid);

    void reset_covering_mprs();

    inline uint32_t coverage() const { return _coverage; }

    inline bool is_covered() const { return _coverage > 0; }

    inline uint32_t reachability() const { return _reachability; }

    inline void set_reachability(uint32_t value) { _reachability = value; }

    inline bool is_reachable() const { return _reachability > 0; }

    bool is_strict() const { return _is_strict; }

    void set_is_strict(bool is_strict) {
    _is_strict = is_strict;
    }

    const set<OlsrTypes::TwoHopLinkID>& twohop_links() {
    return _twohop_links;
    }

  private:
    EventLoop&          _ev;
    Neighborhood*       _parent;

    OlsrTypes::TwoHopNodeID _id;

    IPv4            _main_addr;

    bool            _is_strict;

    uint32_t            _coverage;

    uint32_t            _reachability;

    set<OlsrTypes::TwoHopLinkID>        _twohop_links;
};

class TwoHopLink {
public:
    TwoHopLink(EventLoop& ev, Neighborhood* parent,
           OlsrTypes::TwoHopLinkID tlid,
           Neighbor* nexthop, const TimeVal& vtime);

    inline OlsrTypes::TwoHopLinkID id() const { return _id; }

    inline Neighbor* nexthop() const { return _nexthop; }

    inline TwoHopNeighbor* destination() const {
    XLOG_ASSERT(0 != _destination);     // Catch programming errors.
    return _destination;
    }

    inline void set_destination(TwoHopNeighbor* destination) {
    // Invariant: set_destination() should only be called once,
    // immediately after the TwoHopLink has been created, to
    // associate it with a TwoHopNeighbor.
    XLOG_ASSERT(0 == _destination);
    _destination = destination;
    }

    inline OlsrTypes::FaceID face_id() const { return _face_id; }

    inline double near_etx() const { return _near_etx; }

    inline double far_etx() const { return _far_etx; }

    inline void set_face_id(const OlsrTypes::FaceID faceid) {
    _face_id = faceid;
    }

    inline void set_near_etx(const double& near_etx) {
    _near_etx = near_etx;
    }

    inline void set_far_etx(const double& far_etx) {
    _far_etx = far_etx;
    }

    inline TimeVal time_remaining() const {
    TimeVal tv;
    _expiry_timer.time_remaining(tv);
    return tv;
    }

    void update_timer(const TimeVal& vtime);

    void event_dead();

private:
    EventLoop&          _ev;
    Neighborhood*       _parent;

    OlsrTypes::TwoHopLinkID _id;

    Neighbor*           _nexthop;

    TwoHopNeighbor*     _destination;

    OlsrTypes::FaceID       _face_id;

    XorpTimer           _expiry_timer;

    double          _near_etx;

    double          _far_etx;
};

#endif // __OLSR_TWOHOP_HH__