RmVectorT.h

//=================================================================================================//
// filename: RmVectorT.h                                                                           //
//                                                                                                 //
//           ATI Research, Inc.                                                                    //
//           3D Application Research Group                                                         //
//                                                                                                 //
// Description:  Old implementation of STL-like vector container                                   //
//                                                                                                 //
//=================================================================================================//
//   (C) 2004 ATI Research, Inc.  All rights reserved.                                             //
//=================================================================================================//

#ifndef _RM_CORE_VECTOR_T_H_
#define _RM_CORE_VECTOR_T_H_

// INCLUDES ===================================================================
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include "RmTypes.h"

// RETURN CODES================================================================
#define VECTOR_OK                0
#define VECTOR_REALLOCATE        -1
#define VECTOR_MEMORY_ERROR      -2
#define VECTOR_OUT_OF_RANGE      -3
#define VECTOR_NOT_FOUND         -4

#ifndef TRUE
   #define TRUE                  1
#endif
#ifndef FALSE
   #define FALSE                 0
#endif

// DATA TYPE DEFINITIONS ======================================================
typedef int (*SortFunc)(const void*, const void*);

typedef struct vector_s
{
   int         count;
   int         allocCount;
   int         elementSize;
   int         (*compare)(const void*, const void*);
   void        *data;
} vector_t;

// MACROS =====================================================================
#define InitVector(name, compare)                                 \
   memset(&name##Vector, 0, sizeof(vector_t));                    \
   name##Size = sizeof(*name);                                    \
   name##Compare = compare;

#define VectorType(type, name)                                    \
   union                                                          \
   {                                                              \
      vector_t   name##Vector;                                    \
      struct                                                      \
      {                                                           \
         int      name##Count;                                    \
         int      name##Alloc;                                    \
         int      name##Size;                                     \
         int      (*name##Compare)(const void*, const void*);     \
         type*    name;                                           \
      };                                                          \
   };

#define VectorTypeWithAlias(type, name, alias)                    \
   union                                                          \
   {                                                              \
      vector_t   name##Vector;                                    \
      struct                                                      \
      {                                                           \
         int      name##Count;                                    \
         int      name##Alloc;                                    \
         int      name##Size;                                     \
         int      (*name##Compare)(const void*, const void*);     \
         type*    name;                                           \
      };                                                          \
      struct                                                      \
      {                                                           \
         int      name##Filler[4];                                \
         type*    alias;                                          \
      };                                                          \
   };

#define VectorObject(type, name)                            \
   union                                                    \
   {                                                        \
      vector_t   vec;                                       \
      struct                                                \
      {                                                     \
         int      count;                                    \
         int      alloc;                                    \
         int      size;                                     \
         int      (*compare)(const void*, const void*);     \
         type*    data;                                     \
      };                                                    \
   } name;

#define VectorTypedef(type, name, data)                  \
   typedef struct                                        \
   {                                                     \
      int      count;                                    \
      int      alloc;                                    \
      int      size;                                     \
      int      (*compare)(const void*, const void*);     \
      type*    data;                                     \
   } name;

// FUNCTION PROTOTYPES ========================================================
int RM_API VectorAddElement(vector_t* v, void* element, int nIndex, char append);
int RM_API VectorAppend(vector_t* v, void* element, int nIndex);
int RM_API VectorAppendBack(vector_t* v, void* element);
int RM_API VectorCheckAlloc(vector_t* v);
int RM_API VectorFind(vector_t* v, void* element, int* result);
void  RM_API VectorFree(vector_t* v);
int RM_API VectorInsert(vector_t* v, void* element, int nIndex);
int RM_API VectorRemoveIndex(vector_t* v, int nIndex);
int RM_API VectorRemoveSortedElement(vector_t* v, void* element);
void  RM_API VectorSort(vector_t* v);
int RM_API VectorSortedInsert(vector_t* v, void* element);

#endif

---