---

mem_push.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/* Copyright 1992, Brown Computer Graphics Group.  All Rights Reserved. */

/* -------------------------------------------------------------------------
 *
 *                <     File description here    >
 *
 * ------------------------------------------------------------------------- */

#ifndef STD_MEM_HAS_BEEN_INCLUDED
#define STD_MEM_HAS_BEEN_INCLUDED

/* --------------------------    Constants     ----------------------------- */

/* --------------------------      Types       ----------------------------- */

typedef char        UGAgeneric;
typedef UGAgeneric *UGAptr;
typedef enum {
     STD_FALSE = 0,
     STD_TRUE  = 1
} STDbool;

/* --------------------------     Classes      ----------------------------- */

/*
 * TITLE :  Stack/Queue Storage Class
 *
 * DESCR :  This private class provides simple queue and/or stack
 *      functionality for data objects.  Means of data access are
 *      not restricted to LIFO or FIFO; enforcement of stack/queue
 *      semantics is left up to child objects.
 *
 * DETAILS :    In order to make data i/o as efficient as possible with a
 *      minimum of reallocations, the data is stored in a series of
 *      rotating buffers, with byte offsets used to mark the
 *      current push and pop positions.
 */
class mem_push {
 public:
    mem_push(size_t datasize = sizeof(UGAgeneric));
    virtual ~mem_push();

   STDbool is_empty () const { return num_objects == 0 ? STD_TRUE : STD_FALSE; }
   
   void remove_all() {remove_top(0, count());}

 protected:
   /*
    * DESCR   : Basic pushoperations, providing double-ended data
    *       access. 
    *
    * DETAILS : Note to class authors: in the current implementation,
    *       the methods @insert_bottom@ and @remove_top@ are more
    *       efficient than their counterparts and should be
    *       preferred. 
    */
   void   insert_top    (UGAptr, size_t count = 1);
   void   insert_bottom (const char *, size_t count = 1);
   size_t remove_top    (UGAptr = NULL, size_t count = 1);
   size_t peek_top      (UGAptr = NULL, size_t count = 1) const;
   
   size_t count () const { return num_objects; }

 private:
   void   increase_mem (size_t);
   void   decrease_mem (size_t);

   size_t block_index  (size_t offset) const  { return offset / block_size; }
   size_t block_offset (size_t offset) const  { return offset % block_size; }
   size_t block_left   (size_t offset) const  { return block_size - block_offset (offset); }
   UGAptr block_addr   (size_t offset) const  { return blocks[block_index(offset)] + 
                                                       block_offset (offset); }

   UGAptr   *blocks;
   size_t    num_blocks;
   size_t    num_objects;
   size_t    obj_size, block_size;
   size_t    top, bottom;
};


/*
 * TITLE   :    Queue memory storage
 */
class STDmem_queue : public mem_push {
 public:
   STDmem_queue (size_t datasize = sizeof(UGAgeneric)):mem_push(datasize) {}

   void   put  (const char *data, size_t count = 1)       { insert_bottom(data, count); }
   size_t get  (UGAptr data=NULL, size_t count = 1)       { return remove_top(data,count);}
   size_t peek (UGAptr data=NULL, size_t count = 1) const { return peek_top(data,count); }
   size_t count()                                   const { return mem_push::count(); }
};
#endif

---