Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "ifmap/ifmap_update.h"
       6             : 
       7             : #include "base/time_util.h"
       8             : #include "ifmap/ifmap_node.h"
       9             : 
      10           0 : IFMapObjectPtr::IFMapObjectPtr()
      11           0 :     : type(NIL) {
      12           0 :       u.ptr = NULL;
      13           0 : }
      14             : 
      15        3033 : IFMapObjectPtr::IFMapObjectPtr(IFMapNode *node)
      16        3033 :     : type(NODE) {
      17        3033 :       u.node = node;
      18        3033 : }
      19             : 
      20        3342 : IFMapObjectPtr::IFMapObjectPtr(IFMapLink *link)
      21        3342 :     : type(LINK) {
      22        3342 :       u.link = link;
      23        3342 : }
      24             : 
      25        1698 : void IFMapListEntry::set_queue_insert_at_to_now() {
      26        1698 :     queue_insert_at = UTCTimestampUsec();
      27        1698 : }
      28             : 
      29           0 : std::string IFMapListEntry::queue_insert_ago_str() {
      30           0 :     return duration_usecs_to_string(UTCTimestampUsec() - queue_insert_at);
      31             : }
      32             : 
      33         655 : IFMapUpdate::IFMapUpdate(IFMapNode *node, bool positive)
      34             :     : IFMapListEntry(positive ? UPDATE : DEL),
      35         655 :       data_(node) {
      36         655 : }
      37             : 
      38         630 : IFMapUpdate::IFMapUpdate(IFMapLink *link, bool positive)
      39             :     : IFMapListEntry(positive ? UPDATE : DEL),
      40         630 :       data_(link) {
      41         630 : }
      42             : 
      43         901 : std::string IFMapUpdate::ConfigName() {
      44         901 :     std::string name;
      45         901 :     if (data().type == IFMapObjectPtr::NODE) {
      46         433 :         IFMapNode *node = data().u.node;
      47         433 :         name = node->ToString();
      48         468 :     } else if (data().type == IFMapObjectPtr::LINK) {
      49         468 :         IFMapLink *link = data().u.link;
      50         468 :         name = link->ToString();
      51             :     }
      52         901 :     return name;
      53           0 : }
      54             : 
      55           0 : std::string IFMapUpdate::ToString() {
      56           0 :     return TypeToString() + ":" + ConfigName();
      57             : }
      58             : 
      59        1977 : void IFMapUpdate::AdvertiseReset(const BitSet &set) {
      60        1977 :     advertise_.Reset(set);
      61        1977 : }
      62             : 
      63        1165 : void IFMapUpdate::AdvertiseOr(const BitSet &set) {
      64        1165 :     advertise_ |= set;
      65        1165 : }
      66             : 
      67         204 : void IFMapUpdate::SetAdvertise(const BitSet &set) {
      68         204 :     advertise_ = set;
      69         204 : }
      70             : 
      71         213 : IFMapMarker::IFMapMarker()
      72         213 :     : IFMapListEntry(MARKER) {
      73         213 : }
      74             : 
      75          47 : std::string IFMapMarker::ToString() {
      76          94 :     return std::string("Marker:") + mask.ToNumberedString();
      77             : }
      78             : 
      79        2378 : IFMapState::IFMapState(IFMapNode *node)
      80        2378 :     : sig_(kInvalidSig), data_(node), crc_(0) {
      81        2378 : }
      82             : 
      83        2712 : IFMapState::IFMapState(IFMapLink *link)
      84        2712 :     : sig_(kInvalidSig), data_(link), crc_(0) {
      85        2712 : }
      86             : 
      87        5090 : IFMapState::~IFMapState() {
      88        5090 :     assert(update_list_.empty());
      89        5090 : }
      90             : 
      91       15684 : IFMapUpdate *IFMapState::GetUpdate(IFMapListEntry::EntryType type) {
      92       15684 :     for (UpdateList::iterator iter = update_list_.begin();
      93       35132 :          iter != update_list_.end(); ++iter) {
      94        3448 :         IFMapUpdate *update = iter.operator->();
      95        3448 :         if (update->type == type) {
      96        1566 :             return update;
      97             :         }
      98             :     }
      99       14118 :     return NULL;
     100             : }
     101             : 
     102        1243 : void IFMapState::Insert(IFMapUpdate *update) {
     103        1243 :     update_list_.push_front(*update);
     104        1243 : }
     105             : 
     106        1201 : void IFMapState::Remove(IFMapUpdate *update) {
     107        2402 :     update_list_.erase(update_list_.s_iterator_to(*update));
     108        1201 : }
     109             : 
     110          90 : IFMapNode *IFMapState::GetIFMapNode() const {
     111          90 :     if (data_.IsNode()) {
     112          90 :         return data_.u.node;
     113             :     } else {
     114           0 :         return NULL;
     115             :     }
     116             : }
     117             : 
     118           0 : IFMapLink *IFMapState::GetIFMapLink() const {
     119           0 :     if (data_.IsLink()) {
     120           0 :         return data_.u.link;
     121             :     } else {
     122           0 :         return NULL;
     123             :     }
     124             : }
     125             : 
     126        2378 : IFMapNodeState::IFMapNodeState(IFMapNode *node)
     127        2378 :     : IFMapState(node) {
     128        2378 : }
     129             : 
     130         162 : bool IFMapNodeState::HasDependents() const {
     131         162 :     return !dependents_.empty();
     132             : }
     133             : 
     134        2712 : IFMapLinkState::IFMapLinkState(IFMapLink *link)
     135        2712 :     : IFMapState(link), left_(link), right_(link) {
     136        2712 : }
     137             : 
     138        2715 : void IFMapLinkState::SetDependency(IFMapNodeState *first,
     139             :                                    IFMapNodeState *second) {
     140        2715 :     left_.reset(first);
     141        2715 :     right_.reset(second);
     142        2715 : }
     143             : 
     144          51 : void IFMapLinkState::RemoveDependency() {
     145          51 :     left_.clear();
     146          51 :     right_.clear();
     147          51 : }
     148             : 
     149         753 : bool IFMapLinkState::HasDependency() const {
     150         753 :     return left_.get() != NULL;
     151             : }
     152             :