Return to queue.h CVS log

Up to [Previous NeXT emulator] / previous_trunk / src / includes

Annotation of previous_trunk/src/includes/queue.h, revision 1.1

1.1     ! root        1: /*  
        !             2:  *          File: queue.h
        !             3:  *        Author: Robert I. Pitts <[email protected]>
        !             4:  * Last Modified: March 9, 2000
        !             5:  *         Topic: Queue - Array Implementation
        !             6:  * ----------------------------------------------------------------
        !             7:  */
        !             8: 
        !             9: #ifndef _QUEUE_H
        !            10: #define _QUEUE_H
        !            11: 
        !            12: /*
        !            13:  * Constants
        !            14:  * ---------
        !            15:  * ERROR_*   These signal error conditions in queue functions
        !            16:  *           and are used as exit codes for the program.
        !            17:  */
        !            18: #define ERROR_QUEUE   2
        !            19: #define ERROR_MEMORY  3
        !            20: 
        !            21: /*
        !            22:  * Type: queueElementT
        !            23:  * -------------------
        !            24:  * This is the type of objects held in the queue.
        !            25:  */
        !            26: 
        !            27: /*typedef char queueElementT;
        !            28: typedef unsigned char *queueElementT;
        !            29: */
        !            30: 
        !            31: struct queuepacket {
        !            32:         int len;
        !            33:         unsigned char data[4096];
        !            34: };
        !            35: typedef struct queuepacket *queueElementT;
        !            36: 
        !            37: /*
        !            38:  * Type: queueADT
        !            39:  * --------------
        !            40:  * The actual implementation of a queue is completely
        !            41:  * hidden.  Client will work with queueADT which is a
        !            42:  * pointer to underlying queueCDT.
        !            43:  */
        !            44: 
        !            45: /*
        !            46:  * NOTE: need word struct below so that the compiler
        !            47:  * knows at least that a queueCDT will be some sort
        !            48:  * of struct.
        !            49:  */
        !            50: 
        !            51: typedef struct queueCDT *queueADT;     
        !            52: 
        !            53: /*
        !            54:  * Function: QueueCreate
        !            55:  * Usage: queue = QueueCreate();
        !            56:  * -------------------------
        !            57:  * A new empty queue is created and returned.
        !            58:  */
        !            59: 
        !            60: queueADT QueueCreate(void);
        !            61: 
        !            62: /* Function: QueueDestroy
        !            63:  * Usage: QueueDestroy(queue);
        !            64:  * -----------------------
        !            65:  * This function frees all memory associated with
        !            66:  * the queue.  "queue" may not be used again unless
        !            67:  * queue = QueueCreate() is called first.
        !            68:  */
        !            69: 
        !            70: void QueueDestroy(queueADT queue);
        !            71: 
        !            72: /*
        !            73:  * Functions: QueueEnter, QueueDelete
        !            74:  * Usage: QueueEnter(queue, element);
        !            75:  *        element = QueueDelete(queue);
        !            76:  * --------------------------------------------
        !            77:  * These are the fundamental queue operations that enter
        !            78:  * elements in and delete elements from the queue.  A call
        !            79:  * to QueueDelete() on an empty queue or to QueueEnter()
        !            80:  * on a full queue is an error.  Make use of QueueIsFull()
        !            81:  * and QueueIsEmpty() (see below) to avoid these errors.
        !            82:  */
        !            83: 
        !            84: void QueueEnter(queueADT queue, queueElementT element);
        !            85: queueElementT QueueDelete(queueADT queue);
        !            86: 
        !            87: 
        !            88: /*
        !            89:  * Functions: QueueIsEmpty, QueueIsFull
        !            90:  * Usage: if (QueueIsEmpty(queue)) ...
        !            91:  * -----------------------------------
        !            92:  * These return a true/false value based on whether
        !            93:  * the queue is empty or full, respectively.
        !            94:  */
        !            95: 
        !            96: int QueueIsEmpty(queueADT queue);
        !            97: int QueueIsFull(queueADT queue);
        !            98: 
        !            99: 
        !           100: /*
        !           101:  * Function: QueuePeek
        !           102:  * Usage: qeuesize = QueuePeek(queue) ...
        !           103:  * -----------------------------------
        !           104:  * This returns the number of elements currently
        !           105:  * stored in the queue.
        !           106:  */
        !           107: int QueuePeek(queueADT queue);
        !           108: 
        !           109: #endif  /* not defined _QUEUE_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.