sc_vector.hh revision 12852
1/* 2 * Copyright 2018 Google, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer; 8 * redistributions in binary form must reproduce the above copyright 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution; 11 * neither the name of the copyright holders nor the names of its 12 * contributors may be used to endorse or promote products derived from 13 * this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * Authors: Gabe Black 28 */ 29 30#ifndef __SYSTEMC_EXT_UTIL_SC_VECTOR_HH__ 31#define __SYSTEMC_EXT_UTIL_SC_VECTOR_HH__ 32 33#include <stdint.h> 34 35#include <exception> 36#include <vector> 37 38#include "../core/sc_object.hh" 39#include "warn_unimpl.hh" 40 41namespace sc_core 42{ 43 44template <typename T, typename MT> 45class sc_vector_assembly; 46 47template <typename T> 48class sc_vector; 49 50template <typename T, typename MT> 51sc_vector_assembly<T, MT> sc_assemble_vector( 52 sc_vector<T> &, MT(T::* member_ptr)); 53 54class sc_vector_base : public sc_object 55{ 56 public: 57 typedef size_t size_type; 58 59 virtual const char *kind() const { return "sc_vector"; } 60 size_type size() const; 61 const std::vector<sc_object *> &get_elements() const; 62}; 63 64template <typename T> 65class sc_vector_iter : 66 public std::iterator<std::random_access_iterator_tag, T> 67{ 68 // Conforms to Random Access Iterator category. 69 // See ISO/IEC 14882:2003(E), 24.1 [lib.iterator.requirements] 70 71 // Implementation-defined 72}; 73 74template <typename T> 75class sc_vector : public sc_vector_base 76{ 77 public: 78 using sc_vector_base::size_type; 79 typedef sc_vector_iter<T> iterator; 80 typedef sc_vector_iter<const T> const_iterator; 81 82 sc_vector() : sc_vector_base() 83 { 84 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 85 } 86 explicit sc_vector(const char *) : sc_vector_base() 87 { 88 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 89 } 90 sc_vector(const char *, size_type) : sc_vector_base() 91 { 92 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 93 } 94 template <typename Creator> 95 sc_vector(const char *, size_type, Creator) : sc_vector_base() 96 { 97 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 98 } 99 virtual ~sc_vector() {} 100 101 void 102 init(size_type) 103 { 104 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 105 } 106 static T * 107 create_element(const char *, size_type) 108 { 109 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 110 return nullptr; 111 } 112 113 template <typename Creator> 114 void 115 init(size_type, Creator) 116 { 117 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 118 } 119 120 T & 121 operator [] (size_type) 122 { 123 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 124 return *(T *)nullptr; 125 } 126 const T & 127 operator [] (size_type) const 128 { 129 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 130 return *(const T *)nullptr; 131 } 132 133 T & 134 at(size_type) 135 { 136 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 137 return *(T *)nullptr; 138 } 139 const T & 140 at(size_type) const 141 { 142 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 143 return *(const T *)nullptr; 144 } 145 146 iterator 147 begin() 148 { 149 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 150 return iterator(); 151 } 152 iterator 153 end() 154 { 155 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 156 return iterator(); 157 } 158 159 const_iterator 160 begin() const 161 { 162 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 163 return const_iterator(); 164 } 165 const_iterator 166 end() const 167 { 168 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 169 return const_iterator(); 170 } 171 172 const_iterator 173 cbegin() const 174 { 175 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 176 return const_iterator(); 177 } 178 const_iterator 179 cend() const 180 { 181 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 182 return const_iterator(); 183 } 184 185 template <typename ContainerType, typename ArgumentType> 186 iterator 187 bind(sc_vector_assembly<ContainerType, ArgumentType>) 188 { 189 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 190 return iterator(); 191 } 192 193 template <typename BindableContainer> 194 iterator 195 bind(BindableContainer &) 196 { 197 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 198 return iterator(); 199 } 200 201 template <typename BindableIterator> 202 iterator 203 bind(BindableIterator, BindableIterator) 204 { 205 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 206 return iterator(); 207 } 208 209 template <typename BindableIterator> 210 iterator 211 bind(BindableIterator, BindableIterator, iterator) 212 { 213 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 214 return iterator(); 215 } 216 217 template <typename ContainerType, typename ArgumentType> 218 iterator 219 operator () (sc_vector_assembly<ContainerType, ArgumentType> c) 220 { 221 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 222 return iterator(); 223 } 224 225 template <typename ArgumentContainer> 226 iterator 227 operator () (ArgumentContainer &) 228 { 229 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 230 return iterator(); 231 } 232 233 template <typename ArgumentIterator> 234 iterator 235 operator () (ArgumentIterator, ArgumentIterator) 236 { 237 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 238 return iterator(); 239 } 240 241 template <typename ArgumentIterator> 242 iterator 243 operator () (ArgumentIterator, ArgumentIterator, iterator) 244 { 245 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 246 return iterator(); 247 } 248 249 private: 250 // Disabled 251 sc_vector(const sc_vector &) : sc_vector_base() {} 252 sc_vector &operator = (const sc_vector &) { return *this; } 253}; 254 255template <typename T, typename MT> 256class sc_vector_assembly 257{ 258 public: 259 friend sc_vector_assembly<T, MT> sc_assemble_vector<>( 260 sc_vector<T> &, MT(T::* member_ptr)); 261 262 typedef size_t size_type; 263 // These next two types are supposed to be implementation defined. We'll 264 // just stick in a substitute for now, but these should probably not just 265 // be STL vector iterators. 266 typedef typename std::vector<T>::iterator iterator; 267 typedef typename std::vector<T>::const_iterator const_iterator; 268 typedef MT (T::* member_type); 269 270 sc_vector_assembly(const sc_vector_assembly &) 271 { 272 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 273 } 274 275 iterator 276 begin() 277 { 278 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 279 return iterator(); 280 } 281 iterator 282 end() 283 { 284 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 285 return iterator(); 286 } 287 288 const_iterator 289 cbegin() const 290 { 291 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 292 return const_iterator(); 293 } 294 const_iterator 295 cend() const 296 { 297 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 298 return const_iterator(); 299 } 300 301 size_type 302 size() const 303 { 304 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 305 return 0; 306 } 307 std::vector<sc_object *> 308 get_elements() const 309 { 310 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 311 return *(std::vector<sc_object *> *)nullptr; 312 } 313 314 typename iterator::reference 315 operator [] (size_type) 316 { 317 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 318 return typename iterator::reference(); 319 } 320 typename const_iterator::reference 321 operator [] (size_type) const 322 { 323 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 324 return typename iterator::reference(); 325 } 326 327 typename iterator::reference 328 at(size_type) 329 { 330 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 331 return typename iterator::reference(); 332 } 333 typename const_iterator::reference 334 at(size_type) const 335 { 336 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 337 return typename iterator::reference(); 338 } 339 340 template <typename ContainerType, typename ArgumentType> 341 iterator 342 bind(sc_vector_assembly<ContainerType, ArgumentType>) 343 { 344 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 345 return iterator(); 346 } 347 348 template <typename BindableContainer> 349 iterator 350 bind(BindableContainer &) 351 { 352 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 353 return iterator(); 354 } 355 356 template <typename BindableIterator> 357 iterator 358 bind(BindableIterator, BindableIterator) 359 { 360 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 361 return iterator(); 362 } 363 364 template <typename BindableIterator> 365 iterator 366 bind(BindableIterator, BindableIterator, iterator) 367 { 368 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 369 return iterator(); 370 } 371 372 template <typename BindableIterator> 373 iterator 374 bind(BindableIterator, BindableIterator, typename sc_vector<T>::iterator) 375 { 376 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 377 return iterator(); 378 } 379 380 template <typename ContainerType, typename ArgumentType> 381 iterator 382 operator () (sc_vector_assembly<ContainerType, ArgumentType>) 383 { 384 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 385 return iterator(); 386 } 387 388 template <typename ArgumentContainer> 389 iterator 390 operator () (ArgumentContainer &) 391 { 392 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 393 return iterator(); 394 } 395 396 template <typename ArgumentIterator> 397 iterator 398 operator () (ArgumentIterator, ArgumentIterator) 399 { 400 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 401 return iterator(); 402 } 403 404 template <typename ArgumentIterator> 405 iterator 406 operator () (ArgumentIterator, ArgumentIterator, iterator) 407 { 408 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 409 return iterator(); 410 } 411 412 template <typename ArgumentIterator> 413 iterator 414 operator () (ArgumentIterator, ArgumentIterator, 415 typename sc_vector<T>::iterator) 416 { 417 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 418 return iterator(); 419 } 420 421 private: 422 // Temporary constructor which will (eventually) actually bind an 423 // sc_vector_assembly instance to an sc_vector. 424 sc_vector_assembly<T, MT>() 425 { 426 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 427 } 428}; 429 430template <typename T, typename MT> 431sc_vector_assembly<T, MT> 432sc_assemble_vector(sc_vector<T> &, MT(T::* member_ptr)) 433{ 434 sc_utils_warn_unimpl(__PRETTY_FUNCTION__); 435 return sc_vector_assembly<T, MT>(); 436} 437 438} // namespace sc_core 439 440#endif //__SYSTEMC_EXT_UTIL_SC_VECTOR_HH__ 441