sigc++/scope.cc

   1 // -*- c++ -*-
   2 /*
   3  * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include <sigc++/scope.h>
  20 #include <sigc++/object.h>
  21
  22 #ifdef SIGC_CXX_NAMESPACES
  23 namespace SigC
  24 {
  25 #endif //SIGC_CXX_NAMESPACES
  26
  27 /*********************************************************/
  28
  29 Reference::~Reference()       {if (obj_) obj_->unreference();}
  30 void Reference::set_sink()    {if (obj_) obj_->set_sink();}
  31
  32 void Reference::init(ObjectReferenced *obj)
  33   {
  34     obj_=obj;
  35     cache_=0;
  36     if (obj_)
  37       {
  38         obj_->register_ref(this);
  39         obj_->reference();
  40       }
  41   }
  42
  43 void Reference::set(ObjectReferenced *obj,void* cache,bool is_ptr)
  44   {
  45     if (obj_==obj)
  46       return;
  47     if (obj_) obj_->unreference();
  48     obj_=obj;
  49     cache_=cache;
  50     if (obj_)
  51       {
  52         obj_->register_ref(this);
  53         obj_->reference();
  54         if (is_ptr) obj_->set_sink();
  55       }
  56   }
  57
  58 /*********************************************************/
  59 // object interaction properties
  60 void Scope::reference()   {if (obj_) obj_->reference();}
  61 void Scope::unreference() {if (obj_) obj_->unreference();}
  62 void Scope::set_sink()    {if (obj_) obj_->set_sink();}
  63
  64 void Scope::invalid()
  65   {
  66     if (obj_)
  67       object()->invalid();
  68   }
  69
  70 void Scope::register_scope(ObjectScoped *obj)
  71   {
  72     if (obj)
  73       obj->register_scope(this);
  74   }
  75
  76 void Scope::register_scope(const Scope *parent)
  77   {
  78     if (parent&&parent->obj_)
  79       parent->object()->register_scope(this,parent);
  80   }
  81
  82 void Scope::unregister_scope()
  83   {
  84     if (obj_)
  85       object()->unregister_scope(this);
  86   }
  87
  88
  89 /*********************************************************/
  90 // object interaction properties
  91 void Scope::set(ObjectScoped *obj,void* cache,bool)
  92   {
  93     if (obj_==obj)
  94       return;
  95     unregister_scope();
  96     register_scope(obj);
  97     cache_=(obj_?cache:0);
  98   }
  99
 100 void ScopeNode::disconnect(bool dummy)
 101   {}
 102
 103 void Scope::erase()
 104   {
 105     obj_=0;
 106     cache_=0;
 107   }
 108
 109 Scope::~Scope()
 110   {}
 111
 112 /*********************************************************/
 113
 114 // These are here because they are virtual
 115
 116 void Scopes::Uncounted::disconnect(bool l)
 117   {
 118     unregister_scope();
 119   }
 120
 121 Scopes::Uncounted::~Uncounted()
 122   {
 123     disconnect();
 124   }
 125
 126 void Scopes::Extend::set(ObjectScoped *obj,void* cache,bool is_ptr)
 127   {
 128     Scope::set(obj,cache,is_ptr);
 129     if (is_ptr) set_sink();
 130   }
 131
 132 void Scopes::Extend::on_connect()
 133   {
 134     reference();
 135   }
 136
 137 void Scopes::Extend::erase()
 138   {
 139     unreference();
 140     Scope::erase();
 141   }
 142
 143 void Scopes::Extend::disconnect(bool l)
 144   {
 145     unregister_scope();
 146   }
 147
 148 Scopes::Extend::~Extend()
 149   {
 150     disconnect();
 151   }
 152
 153 void Scopes::Limit::set(ObjectScoped *obj,void* cache,bool is_ptr)
 154   {
 155     Scope::set(obj,cache,is_ptr);
 156     if (is_ptr) set_sink();
 157   }
 158
 159 void Scopes::Limit::on_connect()
 160   {
 161     reference();
 162   }
 163
 164 void Scopes::Limit::erase()
 165   {
 166     unreference();
 167     Scope::erase();
 168   }
 169
 170 void Scopes::Limit::disconnect(bool l)
 171   {
 172     invalid();
 173     unregister_scope();
 174   }
 175
 176 Scopes::Limit::~Limit()
 177   {
 178     disconnect();
 179   }
 180
 181 /*****************************************************************/
 182
 183 inline void splice_node(ScopeNode *n1,ScopeNode *n2)
 184   {
 185     n1->next_=n2;
 186     n2->prev_=n1;
 187   }
 188
 189 inline void unlink_node(ScopeNode *n)
 190   {
 191     if (n->next_==n) return;
 192     splice_node(n->prev_,n->next_);
 193     n->prev_=n->next_=n;
 194   }
 195
 196 void ScopeNode::remove_self() {unlink_node(this);}
 197 ScopeNode::~ScopeNode() {unlink_node(this);}
 198 void ScopeNode::erase() {}
 199
 200 DataNode::~DataNode()  {}
 201 void DataNode::erase() {delete this;}
 202
 203
 204
 205 ScopeIterator_ ScopeList::insert_direct(Iterator pos,NodeType *tmp)
 206   {
 207    if (!tmp) return tmp;
 208    NodeType *after=pos.node();
 209    NodeType *before=(NodeType*)(after->prev_);
 210
 211    splice_node(before,tmp);
 212    splice_node(tmp,after);
 213    return tmp;
 214   }
 215
 216 ScopeIterator_ ScopeList::erase(Iterator pos)
 217   {
 218    NodeType* loc=pos.node();
 219    Iterator tmp=pos;
 220    if (!loc) return tmp;
 221    ++tmp;
 222
 223    unlink_node(loc);
 224    loc->erase();
 225    return tmp;
 226   }
 227
 228 void ScopeList::swap_elements(Iterator p1,Iterator p2)
 229   {
 230    NodeType *loc1=p1.node();
 231    NodeType *loc2=p2.node();
 232
 233    if (!loc1||!loc2) return;
 234
 235    NodeType *before1=(NodeType*)loc1->prev_;
 236    NodeType *after1=(NodeType*)loc1->next_;
 237    NodeType *before2=(NodeType*)loc2->prev_;
 238    NodeType *after2=(NodeType*)loc2->next_;
 239
 240    if (before1==loc1)
 241      {
 242       // loc1 is a stray?
 243       if (before2==loc2) return;
 244       splice_node(loc2,loc2);
 245       splice_node(before2,loc1);
 246       splice_node(loc1,after2);
 247       return;
 248      }
 249    if (before2==loc2)
 250      {
 251       // loc2 is a stray?
 252       splice_node(loc1,loc1);
 253       splice_node(before1,loc2);
 254       splice_node(loc2,after1);
 255       return;
 256      }
 257    if (loc1==before2)
 258      {// loc1 is right before loc2
 259       splice_node(before1,loc2);
 260       splice_node(loc2,loc1);
 261       splice_node(loc1,after2);
 262       return;
 263      }
 264    if (loc2==before1)
 265      {// loc2 is right before loc1
 266       splice_node(before2,loc1);
 267       splice_node(loc1,loc2);
 268       splice_node(loc2,after1);
 269       return;
 270      }
 271
 272    splice_node(before1,loc2);
 273    splice_node(loc2,after1);
 274    splice_node(before2,loc1);
 275    splice_node(loc1,after2);
 276   }
 277
 278 #ifdef SIGC_CXX_NAMESPACES
 279 } // namespace
 280 #endif