//  File name: sparse_mask.h
//    by Ee-Chien Chang
#ifndef SPARSE_MASK_H

#define SPARSE_MASK_H
class  item
{
   friend
       ostream & operator << ( ostream&, item * );
   public:
       
       item ( int st, int en, item * ne )  { start_from = st;
                                             end_at     = en;
                                             next       = ne;
                                           }
 //   ~item () {
 //cout << "delete item " << start_from << " " << end_at << "  deleted" <<endl;}

   int         start_from;
   int         end_at;
   item  *next;
};


class linked_list
{
  friend
      ostream & operator << ( ostream&, linked_list * );

  public:
             linked_list () {  list = 0 ;}
            ~linked_list ();

      void   set_to_null () {  list = 0 ;}
      void   set         ( int start_from, int end_at );
      int    unset       ( int start_from, int end_at );
      item * set_disjoint( int &total, int start_from, int end_at );
      item * zeros       ( int *total, int start_from, int end_at );
      item * ones        ( int *total, int start_from, int end_at );
      item * first_occurance(          int start_from, int end_at );
      
      int   operator[]  (int index);
      int   nos_item    ();

  private:
      void  insertItem  ( int start_from, int end_at, item *prev);
      int   max (int a, int b ) { if (a>b) {return a;} else {return b;} }
      int   min (int a, int b ) { if (a<b) {return a;} else {return b;} }

  public:
      item *list;
};

class  sparse_mask
{
   public:
                 sparse_mask ();
                 sparse_mask ( int row, int col );
   int		 unset ( int st_row, int st_col, int en_row, int en_col);
                 ~sparse_mask();

   void          reInit      ( int row, int col );
   linked_list & operator [] ( int index )
                                { 
                                  #ifdef BOUND_CHECK
                                    if ( (index<0)||(index>=nos_row ) )
                                      {
                                        cout << "ERROR OUT OF BOUND " 
                                             << " row " << index 
                                             << "nos_row " << nos_row 
                                             << "nos_col " << nos_col <<  endl;
                                        exit (0);
                                      }
                                  #endif
                                  return *table[index] ;
                                 }
  
   linked_list  **table; 

   int           nos_row;
   int           nos_col;
};
     
//---------------------------------------------------
//            M A S K      T R E E
//---------------------------------------------------
//   just an array of sparse mask.
//---------------------------------------------------

class mask_tree
{
   public:
                  mask_tree () { nos_level =0; mask_list = 0;}
                  mask_tree ( int nos_level,  int width, int height );
                ~ mask_tree ();
   void           reInit    ( int nos_level,  int width, int height );
   sparse_mask  & operator [] ( int index ) { return *mask_list[index] ;}

   private:
         int           nos_level     ;
         sparse_mask **mask_list     ;  //array  [nos_level] of sparse mask
};
#endif