BList.h

Go to the documentation of this file.

/*******************************************************************************
 *  BList.h     BEAM List
 *  T.Barnaby,  BEAM Ltd,   4/8/00
 *  Copyright (c) 2022 All Right Reserved, Beam Ltd, https://www.beam.ltd.uk
 *  For license see LICENSE.txt at the root of the beamlib source tree.
 *******************************************************************************
 */
#ifndef BLIST_H
#define BLIST_H 1
 
class BNode {
public:
        BNode() : next(0), prev(0){}
    BNode*  next;
    BNode*  prev;
};
 
class BIter {
public:
        BIter(BNode* i = 0)     {   oi = i;         }
        operator BNode* ()      {   return oi;      }
    int operator==(const BIter& i)  {   return (i.oi == oi);    }
    int valid()             {   return (oi != 0);   }
private:
    BNode*  oi;
};
 
template <class T> class BList {
public:
    class Node : public BNode {
    public:
            Node(const T& i) : item(i){}
        T   item;
    };
    typedef int     (*SortFunc)(T& a, T& b);        
 
    // Contructors
        BList();
        BList(const BList<T>& l);
    virtual ~BList();
        
    // Navigation
    void    start(BIter& i) const;              
    BIter   begin() const;                  
    BIter   end() const;                    
    BIter   end(BIter& i) const;                
    void    next(BIter& i) const;               
    void    prev(BIter& i);                 
    BIter   goTo(int pos) const;                
    int position(BIter i);              
    
    // Information
    unsigned int    number() const;             
    unsigned int    size() const;               
    int isStart(BIter& i) const;            
    int isEnd(BIter& i) const;              
    
    // Get items
    T&  front();                    
    T&  rear();                     
    T&  get(BIter i);                   
    const T&    get(BIter i) const;         
    
    // Insert items
    void    append(const T& item);              
    virtual void    insert(BIter& i, const T& item);    
    void    insertAfter(BIter& i, const T& item);       
    
    // Delete items
    virtual void    clear();                
    virtual void    del(BIter& i);              
    void    deleteLast();                   
    void    deleteFirst();                  
 
    // Stack
    void    push(const T& i);               
    T   pop();                      
 
    // Queue
    void    queueAdd(const T& i);               
    T   queueGet();                 
 
    // Misc
    void    append(const BList<T>& l);          
    int has(const T& i) const;              
    void    swap(BIter i1, BIter i2);           
    void    sort();                     
    void    sort(SortFunc func);                
                
    // Operator functions
    BList<T>&   operator=(const BList<T>& l);
    T&  operator[](int i);
    const T&    operator[](int i) const;
    T&  operator[](BIter i);
    const T&    operator[](const BIter& i) const;
    BList<T>    operator+(const BList<T>& l) const;
 
protected:
    virtual Node*       nodeGet(BIter i);
    virtual const Node* nodeGet(BIter i) const;
    virtual Node*       nodeCreate(const T& item);
    Node*           onodes;
    unsigned int        olength;
 
private:
    virtual Node*       nodeCreate();
};
 
#include <BList_func.h>
 
// Macros
#define BListLoop(list, i)  for(BIter i = list.begin(); !list.isEnd(i); list.next(i))
 
#endif