//scheme                                                                               
//XLIST =                                                                              
//hide h_begin in                                                                      
//class                                                                                
//    type Item,                                                                       
//         xList = {|(tail, cur, ln): Item-list >< Item-list >< Nat:-                  
//                           exists beg: Item-list :- tail = beg ^ cur /\              
//                           len (tail) = ln                                           
//                 |}                                                                  
//    value                                                                                                                                 
//        h_begin     : Item-list >< Item-list -> Item-list                            
//        h_begin (tail, cur) is                                                       
//             let beg : Item-list :- tail = beg ^ cur in beg end                      
//                                                                                     
//        ,x_addHead  : xList >< Item  -> xList                                        
//         x_addHead ((t,c,l), i)  is                                                  
//             (<.i.>^t, c, l+1)                                                       
//                                                                                     
//        ,x_delHead  : xList        -~-> xList  >< Item                               
//         x_delHead ((t,c,l))  is                                                     
//             ( (tl t, if t = c then tl c else c end, l-1),  hd t)                    
//             pre t ~= <..>                                                           
//        ,x_addNext  : xList >< Item  -> xList                                        
//         x_addNext ((t, c, l), i) is                                                 
//             (h_begin(t,c)^<.i.>^c, <.i.>^c, l+1)                                    
//        ,x_delNext  : xList        -~-> xList  >< Item                               
//         x_delNext (t, c, l) is                                                      
//             ((h_begin(t, c) ^ <.hd c.> ^ tl tl c , tl tl c, l-1), hd tl c           
//             )                                                                       
//             pre len c > 1                                                           
//        ,x_headItem : xList        -~-> xList ><  Item                               
//         x_headItem (t, c, l) is                                                     
//             ((t, t, l), hd t)                                                       
//             pre t ~= <..>                                                           
//        ,x_nextItem : xList        -~-> xList ><  Item                               
//         x_nextItem (t, c, l) is                                                     
//             ((t, tl c, l), hd c)                                                    
//             pre c ~= <..>                                                           
//       ,x_delItem  : xList ><  Item  -> xList                                        
//        x_delItem ((t, c, l), i)  is                                                 
//             if    i isin h_begin (t, c) then                                        
//                                    /* to delete first occurence item in t*/         
//                 (let beg : Item-list  in                                            
//                      let tail : Item-list :- t = beg ^ <.i.> ^ tail /\              
//                                              i ~isin beg in                         
//                                                      beg ^ tail                     
//                      end                                                            
//                  end,                                                               
//                  c,                                                                 
//                  l-1                                                                
//                 )                                                                   
//             elsif i isin          c  then                                           
//                 (let beg : Item-list  in                                            
//                      let tail : Item-list :- t = beg ^ <.i.> ^ tail /\              
//                                              i ~isin beg in                         
//                                                      beg ^ tail                     
//                      end                                                            
//                  end,                                                               
//                  let beg : Item-list  in                                            
//                      let tail : Item-list :- c = beg ^ <.i.> ^ tail /\              
//                                              i ~isin beg in                         
//                                                      beg ^ tail                     
//                      end                                                            
//                  end,                                                               
//                  l-1                                                                
//                 )                                                                   
//             else                                                                    
//                 (t,c,l)                                                             
//             end                                                                     
//        ,x_slctItem : xList ><  Nat  -~->       Item                                 
//         x_slctItem((t,c,l), n)   is                                                 
//            t(n)                                                                     
//            pre l >= n                                                               
//          ,item : xList ><  Item -> Item                                               
//         item (x, i) is i                                                            
//end
                                                                                
#ifndef  __XLIST_H
#define  __XLIST_H

typedef struct  TList_ { 
    struct  TList_ *  tail; 
    void           *  item;
}TList_;

typedef struct  TList { 
    struct  TList_ *  tail; 
    struct  TList_ *  cur;
    ulong             len;

# ifdef __cplusplus
    TList ()                             ;
    ~TList()                             ;
    x_bool isEmpty () const              ;
    long   addHead (const void * newHed) ;
    void * delHead ()                    ;
    long   addNext (const void * newHed) ;
    void * delNext ()                    ;
    void * head    () const              ;
    void * curnt   () const              ;
    void * next    () const              ;
    void * slct    (const ulong p) const ;
    long   del     ( const void * item)  ;
# endif
     
}TList;

# ifdef __cplusplus

template <class I>
struct T_TList : TList {
 I * delHead ()                    { return (I*)TList::delHead(); }
 I * delNext ()                    { return (I*)TList::delNext(); }
 I * head    () const              { return (I*)TList::head ();   }
 I * curnt   () const              { return (I*)TList::curnt();   }
 I * next    () const              { return (I*)TList::next ();   }        
 I * slct    (const ulong p)const  { return (I*)TList::slct (p);   }
} 
;

# endif


# ifdef __cplusplus
      extern "C"    {
# endif

TList *
x_crtList (void);

TList *
x_iniList (TList *  list);

//
//            any member of list must be removed first
//
TList *
x_dstList (TList * list);


long
x_addHead  ( TList * list, const void * newHead);

void *                   // it show the deleted item
x_delHead (TList * list);



long
x_addNext  ( TList * list, const void * newNext);

void *                   // it show the deleted item
x_delNext (TList * list);



long
x_headItem(void ** item, const TList * list);

long
x_curItemL(void ** item, const TList * list);

long
x_nextItem(void ** item, const TList * list);


long
x_delItem(TList * list, const void * delItem);

void *                     // position should start with 0 as the array in C
                           // head is n, head->tail is n-1,...
x_slctItem (const TList * list, ulong position);

x_bool
x_isListEmpty (const TList * list);


//uint
//x_lenList  (const TList * list);

# ifdef __cplusplus
   }


 inline        TList:: TList  ()                    {x_iniList (this);}
 inline        TList:: ~TList ()                    {x_iniList (this);}
 inline x_bool TList:: isEmpty() const              {return x_isListEmpty(this) ;}
 inline long   TList:: addHead(const void * newHead){return x_addHead(this, newHead);}
 inline void * TList:: delHead()                    {return x_delHead(this); }
 inline long   TList:: addNext(const void * newHead){return x_addNext(this, newHead);}
 inline void * TList:: delNext()                    {return x_delNext(this); }
 inline void * TList:: head   () const              {
                                      void * rc = 0;
                                      if(x_headItem(&rc, this) != _OK)
                                          rc = 0;
                                      return rc;
                                     }
 inline void * TList:: curnt   () const              {
                                      void * rc = 0;
                                      if(x_curItemL(&rc, this) != _OK)
                                          rc = 0;
                                      return rc;
                                     }
 inline void * TList:: next  () const               {
                                      void * rc = 0;
                                      if(x_nextItem(&rc, this) != _OK)
                                          rc = 0;
                                      return rc;
                                     }
 inline void * TList:: slct  (const ulong p) const  {return x_slctItem(this,p);  }

 inline long   TList:: del   ( const void * item)   {return x_delItem(this, item); }

# endif



#endif