1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef CSV_TPLTOOLS_HXX 25 #define CSV_TPLTOOLS_HXX 26 27 #include <vector> 28 #include <map> 29 30 31 32 33 namespace csv 34 { 35 36 37 template <class COLLECTION> 38 inline void erase_container( 39 COLLECTION & o_rCollection ); 40 41 /// Version for std::map 42 template <class COLLECTION> 43 void erase_map_of_heap_ptrs( 44 COLLECTION & o_rCollection ); 45 46 /// Version for other containers than std::map, with non-pair value_type. 47 template <class COLLECTION> 48 void erase_container_of_heap_ptrs( 49 COLLECTION & o_rCollection ); 50 51 template <class VECTOR_ELEM> 52 void adjust_vector_size( 53 std::vector<VECTOR_ELEM> & 54 io_rVector, 55 uintt i_nSize, 56 const VECTOR_ELEM & i_nFill ); 57 58 59 template <class KEY, class VAL> 60 const VAL * find_in_map( /// Usable for all kinds of values 61 const std::map< KEY, VAL > & 62 i_rMap, 63 const KEY & i_rKey ); 64 65 66 /** @return the value in the map, if it is in there, else 0. 67 @precond VAL has to be convertable to "0". 68 */ 69 template <class KEY, class VAL> 70 VAL value_from_map( 71 const std::map< KEY, VAL > & 72 i_rMap, 73 const KEY & i_rKey ); 74 75 /** @return the value in the map, if it is in there, else i_notFound. 76 */ 77 template <class KEY, class VAL> 78 VAL value_from_map( 79 const std::map< KEY, VAL > & 80 i_rMap, 81 const KEY & i_rKey, 82 VAL i_notFound ); 83 84 template <class COLLECTION, class VALUE> 85 bool contains( 86 const COLLECTION & i_collection, 87 const VALUE & i_value ); 88 89 // Object oriented for_each: 90 template <class COLLECTION, class CLASS, class MEMFUNC> 91 void call_for_each( 92 const COLLECTION & i_rList, 93 CLASS * io_pThis, 94 MEMFUNC i_fMethod ); 95 96 97 98 99 // IMPLEMENTATION 100 template <class COLLECTION> 101 inline void 102 erase_container( COLLECTION & o_rCollection ) 103 { 104 o_rCollection.erase( o_rCollection.begin(), 105 o_rCollection.end() ); 106 } 107 108 template <class COLLECTION> 109 void 110 erase_map_of_heap_ptrs( COLLECTION & o_rCollection ) 111 { 112 typename COLLECTION::iterator itEnd = o_rCollection.end(); 113 for ( typename COLLECTION::iterator it = o_rCollection.begin(); 114 it != itEnd; 115 ++it ) 116 { 117 delete (*it).second; 118 } 119 120 o_rCollection.erase( o_rCollection.begin(), 121 o_rCollection.end() ); 122 } 123 124 template <class COLLECTION> 125 void 126 erase_container_of_heap_ptrs( COLLECTION & o_rCollection ) 127 { 128 typename COLLECTION::iterator itEnd = o_rCollection.end(); 129 for ( typename COLLECTION::iterator it = o_rCollection.begin(); 130 it != itEnd; 131 ++it ) 132 { 133 delete *it; 134 } 135 136 o_rCollection.erase( o_rCollection.begin(), 137 o_rCollection.end() ); 138 } 139 140 template <class VECTOR_ELEM> 141 void 142 adjust_vector_size( std::vector<VECTOR_ELEM> & io_rVector, 143 uintt i_nSize, 144 const VECTOR_ELEM & i_nFill ) 145 { 146 if ( io_rVector.size() > i_nSize ) 147 { 148 io_rVector.erase( io_rVector.begin() + i_nSize, io_rVector.end() ); 149 } 150 else 151 { 152 io_rVector.reserve(i_nSize); 153 while ( io_rVector.size() < i_nSize ) 154 io_rVector.push_back(i_nFill); 155 } 156 } 157 158 159 template <class KEY, class VAL> 160 const VAL * 161 find_in_map( const std::map< KEY, VAL > & i_rMap, 162 const KEY & i_rKey ) 163 { 164 typename std::map< KEY, VAL >::const_iterator 165 ret = i_rMap.find(i_rKey); 166 return ret != i_rMap.end() 167 ? & (*ret).second 168 : (const VAL*)0; 169 } 170 171 template <class KEY, class VAL> 172 VAL 173 value_from_map( const std::map< KEY, VAL > & i_rMap, 174 const KEY & i_rKey ) 175 { 176 typename std::map< KEY, VAL >::const_iterator 177 ret = i_rMap.find(i_rKey); 178 return ret != i_rMap.end() 179 ? (*ret).second 180 : VAL(0); 181 } 182 183 template <class KEY, class VAL> 184 VAL 185 value_from_map( const std::map< KEY, VAL > & i_rMap, 186 const KEY & i_rKey, 187 VAL i_notFound ) 188 { 189 typename std::map< KEY, VAL >::const_iterator 190 ret = i_rMap.find(i_rKey); 191 return ret != i_rMap.end() 192 ? (*ret).second 193 : i_notFound; 194 } 195 196 template <class COLLECTION, class VALUE> 197 bool 198 contains( const COLLECTION & i_collection, 199 const VALUE & i_value ) 200 { 201 return std::find(i_collection.begin(), i_collection.end(), i_value) 202 != 203 i_collection.end(); 204 } 205 206 template <class COLLECTION, class CLASS, class MEMFUNC> 207 void 208 call_for_each( const COLLECTION & i_rList, 209 CLASS * io_pThis, 210 MEMFUNC i_fMethod ) 211 { 212 typename COLLECTION::const_iterator it = i_rList.begin(); 213 typename COLLECTION::const_iterator itEnd = i_rList.end(); 214 for ( ; it != itEnd; ++it ) 215 { 216 (io_pThis->*i_fMethod)(*it); 217 } 218 } 219 220 221 222 223 } // namespace csv 224 #endif 225