Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
_slist.c
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 2k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

_slist.c：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _slist.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #include <LEDA/impl/slist.h>
  15. //------------------------------------------------------------------------------
  16. // Members of class SLIST
  17. //------------------------------------------------------------------------------
  19. SLIST::SLIST()      
  20. { h=0; 
  21.   t=0;
  22.   count=0;
  23.   iterator=0; 
  24. }
  26. SLIST::SLIST(GenPtr a) 
  27. { h=t=new slink(a,0);
  28.   count=1; 
  29.   iterator=0;  
  30. }
  33. SLIST::SLIST(const SLIST& x)
  34. { register slink* p;
  36.   iterator=h=t=0; 
  37.   count = 0; 
  38.                               
  39.   for (p = x.h; p; p = p->succ) append(p->e); 
  41.   if (!int_type())
  42.     for (p = h; p; p = p->succ) x.copy_el(p->e);
  43. }
  45. GenPtr SLIST::pop()    
  46. { if (iterator!=0) error_handler(1,"pop: deletion while iterator is active");
  47.   GenPtr res;
  48.   if (h) 
  49.   { if (t==h) t = 0;
  50.     slink* x=h; 
  51.     res = x->e;
  52.     h=x->succ; 
  53.     delete x;
  54.     count--;
  55.    }
  56.   return res;
  57. }
  59. /*
  60. void SLIST::del_succ(slink* p)    
  61. { slink* q = p->succ;
  62.   if (q) 
  63.   { if (t==q) t = p;
  64.     p->succ = q->succ; 
  65.     delete q;
  66.     count--;
  67.    }
  68. }
  69. */
  72. slink* SLIST::insert(GenPtr a, slink* p)   
  73. { if (iterator!=0) 
  74.          error_handler(2,"insert: insertion while iterator is active");
  75.   count++;
  76.   p->succ = new slink(a,p->succ); 
  77.   if (t==p) t = p->succ;
  78.   return h;
  79. }
  81. void SLIST::conc(SLIST& l)
  82. { if (iterator!=0) error_handler(2,"conc: iterator is active");
  83.  if (count > 0) 
  84.    { t->succ = l.h;
  85.      if (l.count > 0) t = l.t; 
  86.     }
  87.  else 
  88.    { h = l.h; 
  89.      t = l.t; 
  90.     }
  91.  count = count+l.count;
  92.  l.h = l.t = 0;
  93.  l.count = 0;
  94. }
  97. slink* SLIST::cyclic_succ(slink* loc) const
  98. { if (loc==0) return 0;
  99.   return loc->succ? loc->succ : h;
  100.  }
  102. SLIST& SLIST::operator=(const SLIST& x)
  103. { register slink* p;
  105.   clear();
  107.   for (p = x.h; p; p = p->succ) append(p->e); 
  109.   if (!int_type())
  110.     for (p = h; p; p = p->succ) copy_el(p->e);
  112.   return *this;
  113.  }
  115. void SLIST::clear()
  116. { if (h==0) return;
  118.   register slink* p;
  120.   if(!int_type())
  121.     for(p = h; p; p = p->succ) clear_el(p->e);
  123.   deallocate_list(h,t,sizeof(slink));
  124.   iterator=h=t=0;
  125.   count=0;
  126.  }