00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef _PB_ARRAY_
00025 #define _PB_ARRAY_
00026 #include <string.h>
00027
00028 #include <Inventor/SbBasic.h>
00029
00030 #include <Inventor/STL/vector>
00031
00032 #define PO_ARRAY_HEADER(className,valueType) \
00033 \
00034 \
00035 \
00036 \
00037 \
00038
00039 class className { \
00040 public: \
00041 className(): \
00042 m_array(0), \
00043 m_allocatedSize(0), \
00044 m_lastInd(-1), \
00045 m_extend(10) \
00046 {}; \ \
00048 className(int init_size, int extend=10); \
00049 className(const className& other_array); \
00050 ~className(); \
00051 \
00052 \ \
00054 const valueType* get() const; \
00055 \ \
00057 valueType get(int index) const; \
00058 \ \
00060 int find(valueType val) const; \
00061 \ \
00063 void set(int index, valueType val); \
00064 \ \
00066 int add(valueType val); \
00067 \ \
00069 int add(int num_val, const valueType* val); \
00070 \
00071 \ \
00073 className &operator=(const className& other_array); \
00074 \ \
00076 className &operator=(const std::vector<valueType>& other_array); \
00077 \ \
00079 void operator+=(const className& other_array); \
00080 \ \
00082 void operator+=(valueType val); \
00083 \
00084 valueType& operator[](int index); \
00085 const valueType& operator[](int index) const; \
00086 \ \
00088 friend int operator ==(const className &array_1, const className &array_2); \
00089 \ \
00091 friend int operator !=(const className &array_1, const className &array_2) \
00092 { return !(array_1 == array_2); } \
00093 \ \
00095 void setCapacity(int capacity, int extend); \
00096 \
00097 \
00098 void squeeze(); \
00099 \ \
00101 int getCapacity() const; \
00102 \ \
00104 int getNum() const; \
00105 \ \
00107 void increasingSort(); \
00108 \ \
00110 void decreasingSort(); \
00111 \ \
00113 \
00114 void empty(); \
00115 \
00116 \
00117 private: \
00118 valueType *m_array; \
00119 int m_allocatedSize; \
00120 int m_lastInd; \
00121 int m_extend; \
00122 valueType *resize(int sz); \
00123 }; \
00124 \
00125 \
00126 \
00127 \
00128 inline const valueType* \
00129 className::get() const {return m_array;} \
00130 \
00131 \
00132 inline valueType \
00133 className::get(int index) const {return m_array[index];} \
00134 \
00135 \
00136 inline int \
00137 className::find(valueType val) const { \
00138 for ( int i=0; i<=m_lastInd; i++) if (m_array[i]==val) return i; \
00139 return -1; \
00140 } \
00141 \
00142 \
00143 \
00144 inline void \
00145 className::set(int index, valueType val) \
00146 { \
00147 if ( index >= m_allocatedSize ) resize(index+1); \
00148 m_array[index] = val; \
00149 if ( index > m_lastInd ) m_lastInd = index; \
00150 } \
00151 \
00152 \
00153 \
00154 inline int \
00155 className::add(valueType val) \
00156 { \
00157 m_lastInd++; \
00158 if ( m_lastInd >= m_allocatedSize ) resize(m_lastInd+1); \
00159 m_array[m_lastInd] = val; \
00160 \
00161 return m_lastInd; \
00162 } \
00163 \
00164 \
00165 inline void \
00166 className::operator+=(valueType val) \
00167 { \
00168 add(val); \
00169 } \
00170 \
00171 \
00172 \
00173 inline const valueType& \
00174 className::operator[](int index) const \
00175 { \
00176 return m_array[index]; \
00177 } \
00178 \
00179 \
00180 \
00181 \
00182 inline valueType& \
00183 className::operator[](int index) \
00184 { \
00185 if (index > m_lastInd) m_lastInd = index; \
00186 return m_array[index]; \
00187 } \
00188 \
00189 \
00190 \
00191 inline int \
00192 className::getCapacity() const {return m_allocatedSize;} \
00193 \
00194 \
00195 \
00196 inline int \
00197 className::getNum() const {return m_lastInd+1;} \
00198 \
00199 \
00200 \
00201 \
00202 inline void \
00203 className::empty() {m_lastInd = -1;}
00204
00205
00206 #endif
00207
00208
00209
00210
00211
00212
00213
00214