tab.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// DESCRIPTION: Declaration of a generic "table" class
// AUTHOR: Dan Silva, September 13, 1994
//***************************************************************************/


/*-------------------------------------------------------------------------------

 A Generic "Table" class.      
    
    (DSilva 9-13-94)

    This is a type-safe variable length array which also supports list-like
    operations of insertion, appending and deleting.  Two instance variables
    are maintained: "nalloc" is the number items allocated in the
    array; "count" is the number actual used. (count<=nalloc).
    Allocation is performed automatically when Insert or Append operations
    are performed.  It can also be done manually by calling Resize or Shrink.
    Note: Delete does not resize the storage: to do this call Shrink().  
    If you are going to do a sequence of Appends, it's more efficient to 
    first call Resize to make room for them.  Beware of using the Addr 
    function: it returns a pointer which may be invalid after subsequent 
    Insert, Append, Delete, Resize, or Shrink operations.  
    
    
    The implementation minimizes the storage of empty Tables: they are
    represented by a single NULL pointer.  Also, the major part of the
    code is generic, shared by different Tabs for different types of items.

------------------------------------------------------------------------------*/

#pragma once

#include "maxheap.h"
#include <malloc.h>
#include <stdlib.h>
#include <wtypes.h>
#include "utilexp.h"
#include "assert1.h"

typedef int CNT;

struct TabHdr: public MaxHeapOperators 
{
    CNT count;
    CNT nalloc;
};

// Functions for internal use only: Clients should never call these.
//
UtilExport int TBMakeSize(TabHdr** pth, int num, int elsize); 
UtilExport int TBInsertAt(TabHdr** pth, int at, int num, void *el, int elsize, int extra); 
UtilExport int TBCopy(TabHdr** pth, int at, int num, void *el, int elsize); 
UtilExport int TBDelete(TabHdr** pth, int starting, int num, int elsize);
UtilExport void TBSetCount(TabHdr** pth, int n, int elsize, BOOL resize);
UtilExport void zfree(void**p);

#define NoExport
        
template <class T> class NoExport TabHd: public MaxHeapOperators 
{
    public:
        CNT count;
        CNT nalloc;
        T data[100];
        TabHd() { 
            count = 0; nalloc = 0; 
        }
        // Unimplemented assignment operator
        TabHd& operator=(const TabHd&);
};


// Type of function to pass to Sort.
// Note: Sort just uses the C lib qsort function. If we restricted
// all Tab items to have well defined <,>,== then we wouldn't need
// this callback function.
typedef int( __cdecl *CompareFnc) ( const void *elem1, const void *elem2 );


template <class T> class NoExport Tab: public MaxHeapOperators 
{
    private:
        TabHd<T> *th;

    public:
        Tab() : th(0) { }
        

        Tab(const Tab& tb) : th(0) {  
            TBCopy((TabHdr**)&th, 0, tb.Count(), (tb.th ? &tb.th->data : NULL), sizeof(T)); 
        }


        ~Tab() {
            zfree((void**)&th); 
        }


        void Init() {
            th = 0;
        }


        int Count() const 
        { 
            if (th) {
                return (th->count); 
            }
            return 0; 
        }  


        void ZeroCount() 
        { 
            if (th) {
                th->count = 0; 
            }
        }
        

        void SetCount(int n, BOOL resize=TRUE) { 
            TBSetCount((TabHdr **)&th, n, sizeof(T), resize); 
        }


        T* Addr(const INT_PTR i) const {             
            DbgAssert(th);
            DbgAssert(i < th->count); 
            return (&th->data[i]); 
        }


        int Insert(int at, int num, T *el) {
            return (TBInsertAt((TabHdr**)&th, at, num, (void *)el, sizeof(T), 0));
        }


        int Append(int num, T *el, int allocExtra=0) {
            return (TBInsertAt((TabHdr**)&th, (th ? th->count : 0), num, (void *)el, sizeof(T), allocExtra)); 
        }
        

        int Delete(int start, int num) { 
            return (TBDelete((TabHdr**)&th, start, num, sizeof(T)));
        } 
        

        int Resize(int num) { 
            return (TBMakeSize((TabHdr**)&th, num, sizeof(T)));
        }   
        
        void Shrink() {
            TBMakeSize((TabHdr**)&th, (th ? th->count : 0), sizeof(T)); 
        }


        void Sort(CompareFnc cmp) 
        {
            if (th) {
                qsort(th->data, th->count, sizeof(T), cmp);
            }
        }


        Tab& operator=(const Tab& tb) {
            TBCopy((TabHdr**)&th, 0, tb.Count(), (tb.th ? &tb.th->data : NULL), sizeof(T)); 
            return *this;
        }


        T& operator[](const INT_PTR i) const {       
            DbgAssert(th);
            DbgAssert(i < th->count); 
            return (th->data[i]); 
        }
};

#ifndef __tab_name2
#define __tab_name2(a, b) a##b
#endif
//#pragma deprecated("__tab_name2")

#define MakeTab(TYPE) typedef Tab<TYPE> __tab_name2(TYPE, Tab);                                                             
//#pragma deprecated("MakeTab")

UtilExport void TabStartRecording();
UtilExport void TabStopRecording();
UtilExport void TabPrintAllocs();
UtilExport void TabAssertAllocNum(int i);