lyx_mirror/sigc++/scope.cc
Lars Gullik Bjønnes ee72ce8774 several changes and some new insets, read the Changelog
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@844 a592a061-630c-0410-9148-cb99ea01b6c8
2000-06-28 13:35:52 +00:00

285 lines
5.8 KiB
C++

// -*- c++ -*-
/*
* Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <sigc++/scope.h>
#include <sigc++/object.h>
#ifdef SIGC_CXX_NAMESPACES
namespace SigC
{
#endif //SIGC_CXX_NAMESPACES
/*********************************************************/
Reference::~Reference() {if (obj_) obj_->unreference();}
void Reference::set_sink() {if (obj_) obj_->set_sink();}
void Reference::init(ObjectReferenced *obj)
{
obj_=obj;
cache_=0;
if (obj_)
{
obj_->register_ref(this);
obj_->reference();
}
}
void Reference::set(ObjectReferenced *obj,void* cache,bool is_ptr)
{
if (obj_==obj)
return;
if (obj_) obj_->unreference();
obj_=obj;
cache_=cache;
if (obj_)
{
obj_->register_ref(this);
obj_->reference();
if (is_ptr) obj_->set_sink();
}
}
/*********************************************************/
// object interaction properties
void Scope::reference() {if (obj_) obj_->reference();}
void Scope::unreference() {if (obj_) obj_->unreference();}
void Scope::set_sink() {if (obj_) obj_->set_sink();}
void Scope::invalid()
{
if (obj_)
object()->invalid();
}
void Scope::register_scope(ObjectScoped *obj)
{
if (obj)
obj->register_scope(this);
}
void Scope::register_scope(const Scope *parent)
{
if (parent&&parent->obj_)
parent->object()->register_scope(this,parent);
}
void Scope::unregister_scope()
{
if (obj_)
object()->unregister_scope(this);
}
/*********************************************************/
// object interaction properties
void Scope::set(ObjectScoped *obj,void* cache,bool)
{
if (obj_==obj)
return;
unregister_scope();
register_scope(obj);
cache_=(obj_?cache:0);
}
void ScopeNode::disconnect(bool dummy)
{}
void Scope::erase()
{
obj_=0;
cache_=0;
}
Scope::~Scope()
{}
/*********************************************************/
// These are here because they are virtual
void Scopes::Uncounted::disconnect(bool l)
{
unregister_scope();
}
Scopes::Uncounted::~Uncounted()
{
disconnect();
}
void Scopes::Extend::set(ObjectScoped *obj,void* cache,bool is_ptr)
{
Scope::set(obj,cache,is_ptr);
if (is_ptr) set_sink();
}
void Scopes::Extend::on_connect()
{
reference();
}
void Scopes::Extend::erase()
{
unreference();
Scope::erase();
}
void Scopes::Extend::disconnect(bool l)
{
unregister_scope();
}
Scopes::Extend::~Extend()
{
disconnect();
}
void Scopes::Limit::set(ObjectScoped *obj,void* cache,bool is_ptr)
{
Scope::set(obj,cache,is_ptr);
if (is_ptr) set_sink();
}
void Scopes::Limit::on_connect()
{
reference();
}
void Scopes::Limit::erase()
{
unreference();
Scope::erase();
}
void Scopes::Limit::disconnect(bool l)
{
invalid();
unregister_scope();
}
Scopes::Limit::~Limit()
{
disconnect();
}
/*****************************************************************/
inline void splice_node(ScopeNode *n1,ScopeNode *n2)
{
n1->next_=n2;
n2->prev_=n1;
}
inline void unlink_node(ScopeNode *n)
{
if (n->next_==n) return;
splice_node(n->prev_,n->next_);
n->prev_=n->next_=n;
}
void ScopeNode::remove_self() {unlink_node(this);}
ScopeNode::~ScopeNode() {unlink_node(this);}
void ScopeNode::erase() {}
DataNode::~DataNode() {}
void DataNode::erase() {delete this;}
ScopeIterator_ ScopeList::insert_direct(Iterator pos,NodeType *tmp)
{
if (!tmp) return tmp;
NodeType *after=pos.node();
NodeType *before=(NodeType*)(after->prev_);
splice_node(before,tmp);
splice_node(tmp,after);
return tmp;
}
ScopeIterator_ ScopeList::erase(Iterator pos)
{
NodeType* loc=pos.node();
Iterator tmp=pos;
if (!loc) return tmp;
++tmp;
unlink_node(loc);
loc->erase();
return tmp;
}
ScopeIterator_::ScopeIterator_(const ScopeIterator_ & n)
: node_(n.node_)
{}
void ScopeList::swap_elements(Iterator p1,Iterator p2)
{
NodeType *loc1=p1.node();
NodeType *loc2=p2.node();
if (!loc1||!loc2) return;
NodeType *before1=(NodeType*)loc1->prev_;
NodeType *after1=(NodeType*)loc1->next_;
NodeType *before2=(NodeType*)loc2->prev_;
NodeType *after2=(NodeType*)loc2->next_;
if (before1==loc1)
{
// loc1 is a stray?
if (before2==loc2) return;
splice_node(loc2,loc2);
splice_node(before2,loc1);
splice_node(loc1,after2);
return;
}
if (before2==loc2)
{
// loc2 is a stray?
splice_node(loc1,loc1);
splice_node(before1,loc2);
splice_node(loc2,after1);
return;
}
if (loc1==before2)
{// loc1 is right before loc2
splice_node(before1,loc2);
splice_node(loc2,loc1);
splice_node(loc1,after2);
return;
}
if (loc2==before1)
{// loc2 is right before loc1
splice_node(before2,loc1);
splice_node(loc1,loc2);
splice_node(loc2,after1);
return;
}
splice_node(before1,loc2);
splice_node(loc2,after1);
splice_node(before2,loc1);
splice_node(loc1,after2);
}
#ifdef SIGC_CXX_NAMESPACES
} // namespace
#endif