sc_vector.hh revision 12852:300397457d0b 
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