sc_vector.hh revision 13271:f001f9287ba3 
1/*****************************************************************************
2
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements.  See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License.  You may obtain a copy of the License at
9
10    http://www.apache.org/licenses/LICENSE-2.0
11
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied.  See the License for the specific language governing
16  permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*
21 * Copyright 2018 Google, Inc.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions are
25 * met: redistributions of source code must retain the above copyright
26 * notice, this list of conditions and the following disclaimer;
27 * redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution;
30 * neither the name of the copyright holders nor the names of its
31 * contributors may be used to endorse or promote products derived from
32 * this software without specific prior written permission.
33 *
34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 *
46 * Authors: Gabe Black
47 */
48
49#ifndef __SYSTEMC_EXT_UTIL_SC_VECTOR_HH__
50#define __SYSTEMC_EXT_UTIL_SC_VECTOR_HH__
51
52#include <stdint.h>
53
54#include <exception>
55#include <iterator>
56#include <vector>
57
58#include "../core/sc_module.hh"
59#include "../core/sc_object.hh"
60
61namespace sc_gem5
62{
63
64// Goop for supporting sc_vector_iter, simplified from the Accellera version.
65
66#if __cplusplus >= 201103L
67
68using std::enable_if;
69using std::remove_const;
70using std::is_same;
71using std::is_const;
72
73#else
74
75template<bool Cond, typename T=void>
76struct enable_if
77{};
78
79template<typename T>
80struct enable_if<true, T>
81{
82    typedef T type;
83};
84
85template <typename T>
86struct remove_const
87{
88    typedef T type;
89};
90template <typename T>
91struct remove_const<const T>
92{
93    typedef T type;
94};
95
96template <typename T, typename U>
97struct is_same
98{
99    static const bool value = false;
100};
101template <typename T>
102struct is_same<T, T>
103{
104    static const bool value = true;
105};
106
107template <typename T>
108struct is_const
109{
110    static const bool value = false;
111};
112template <typename T>
113struct is_const<const T>
114{
115    static const bool value = true;
116};
117
118#endif
119
120template <typename CT, typename T>
121struct is_more_const
122{
123    static const bool value =
124        is_same<typename remove_const<CT>::type,
125                typename remove_const<T>::type>::value &&
126        is_const<CT>::value >= is_const<T>::value;
127};
128
129struct special_result
130{};
131
132template <typename T>
133struct remove_special_fptr
134{};
135
136template <typename T>
137struct remove_special_fptr<special_result & (*)(T)>
138{
139    typedef T type;
140};
141
142#define SC_RPTYPE_(Type) \
143    ::sc_gem5::remove_special_fptr< \
144        ::sc_gem5::special_result & (*) Type>::type::value
145
146#define SC_ENABLE_IF_(Cond) \
147    typename ::sc_gem5::enable_if<SC_RPTYPE_(Cond)>::type * = NULL
148
149} // namespace sc_gem5
150
151namespace sc_core
152{
153
154template <typename T, typename MT>
155class sc_vector_assembly;
156
157template <typename T>
158class sc_vector;
159
160template <typename T, typename MT>
161sc_vector_assembly<T, MT> sc_assemble_vector(
162        sc_vector<T> &, MT(T::* member_ptr));
163
164class sc_vector_base : public sc_object
165{
166  public:
167    typedef size_t size_type;
168
169    sc_vector_base(const char *_name) : sc_object(_name) {}
170
171    virtual const char *kind() const { return "sc_vector"; }
172    size_type size() const;
173    const std::vector<sc_object *> &get_elements() const;
174
175  protected:
176    std::vector<void *> objs;
177
178    // What's returned by get_elements, which really returns the elemenets
179    // which are also objects.
180    mutable std::vector<sc_object *> elements;
181
182    sc_object *implicitCast(sc_object *p) const { return p; }
183    sc_object *implicitCast(...) const
184    {
185        SC_REPORT_ERROR(
186                "(E808) sc_vector::get_elements called for element type "
187                "not derived from sc_object", name());
188        return nullptr;
189    }
190    virtual sc_object *objectCast(void *) const = 0;
191
192    void checkIndex(size_type index) const;
193    void forceParent() const;
194    void unforceParent() const;
195
196    void reportEmpty(const char *kind_, bool empty_dest) const;
197};
198
199
200/*
201 * Non-standard iterator access adapters. Without using these, the classes as
202 * defined in the standard won't compile because of redundant bind() overloads.
203 */
204
205template <typename Element>
206class sc_direct_access
207{
208  public:
209    typedef Element ElementType;
210    typedef ElementType Type;
211    typedef typename sc_gem5::remove_const<ElementType>::type PlainType;
212
213    typedef sc_direct_access<ElementType> Policy;
214    typedef sc_direct_access<PlainType> NonConstPolicy;
215    typedef sc_direct_access<const PlainType> ConstPolicy;
216
217    sc_direct_access() {}
218    sc_direct_access(const NonConstPolicy &) {}
219
220    template <typename U>
221    sc_direct_access(const U &,
222        SC_ENABLE_IF_((
223            sc_gem5::is_more_const<
224                    ElementType, typename U::Policy::ElementType>
225        ))
226    )
227    {}
228
229    ElementType *
230    get(ElementType *this_) const
231    {
232        return this_;
233    }
234};
235
236template <typename Element, typename Access>
237class sc_member_access
238{
239  public:
240    template <typename, typename>
241    friend class sc_member_access;
242
243    typedef Element ElementType;
244    typedef Access AccessType;
245    typedef AccessType (ElementType::*MemberType);
246    typedef AccessType Type;
247    typedef typename sc_gem5::remove_const<AccessType>::type PlainType;
248    typedef typename sc_gem5::remove_const<ElementType>::type PlainElemType;
249
250    typedef sc_member_access<ElementType, AccessType> Policy;
251    typedef sc_member_access<PlainElemType, PlainType> NonConstPolicy;
252    typedef sc_member_access<const PlainElemType, const PlainType> ConstPolicy;
253
254    sc_member_access(MemberType ptr) : ptr_(ptr) {}
255    sc_member_access(const NonConstPolicy &other) : ptr_(other.ptr_) {}
256
257    AccessType *get(ElementType *this_) const { return &(this_->*ptr_); }
258
259  private:
260    MemberType ptr_;
261};
262
263template <typename Element,
264          typename AccessPolicy=sc_direct_access<Element> >
265class sc_vector_iter :
266        public std::iterator<std::random_access_iterator_tag,
267                             typename AccessPolicy::Type>,
268        private AccessPolicy
269{
270  private:
271    typedef Element ElementType;
272    typedef typename AccessPolicy::Policy Policy;
273    typedef typename AccessPolicy::NonConstPolicy NonConstPolicy;
274    typedef typename AccessPolicy::ConstPolicy ConstPolicy;
275    typedef typename Policy::Type AccessType;
276
277    typedef typename sc_gem5::remove_const<ElementType>::type PlainType;
278    typedef const PlainType ConstPlainType;
279    typedef typename sc_direct_access<PlainType>::ConstPolicy
280        ConstDirectPolicy;
281
282    friend class sc_vector<PlainType>;
283    template <typename, typename>
284    friend class sc_vector_assembly;
285    template <typename, typename>
286    friend class sc_vector_iter;
287
288    typedef std::iterator<std::random_access_iterator_tag, AccessType>
289        BaseType;
290    typedef sc_vector_iter ThisType;
291    typedef sc_vector<PlainType> VectorType;
292    typedef std::vector<void *> StorageType;
293
294    template <typename U>
295    struct SelectIter
296    {
297        typedef typename std::vector<void *>::iterator type;
298    };
299    template <typename U>
300    struct SelectIter<const U>
301    {
302        typedef typename std::vector<void *>::const_iterator type;
303    };
304    typedef typename SelectIter<ElementType>::type RawIterator;
305    typedef sc_vector_iter<ConstPlainType, ConstPolicy> ConstIterator;
306    typedef sc_vector_iter<ConstPlainType, ConstDirectPolicy>
307        ConstDirectIterator;
308
309    RawIterator it_;
310
311    sc_vector_iter(RawIterator it, Policy acc=Policy()) :
312        Policy(acc), it_(it)
313    {}
314
315    Policy const &get_policy() const { return *this; }
316
317  public:
318    // Conforms to Random Access Iterator category.
319    // See ISO/IEC 14882:2003(E), 24.1 [lib.iterator.requirements]
320
321    typedef typename BaseType::difference_type difference_type;
322    typedef typename BaseType::reference reference;
323    typedef typename BaseType::pointer pointer;
324
325    sc_vector_iter() : Policy(), it_() {}
326
327    template <typename It>
328    sc_vector_iter(const It &it,
329        SC_ENABLE_IF_((
330            sc_gem5::is_more_const<
331                ElementType, typename It::Policy::ElementType>
332        ))
333    ) : Policy(it.get_policy()), it_(it.it_)
334    {}
335
336    ThisType &
337    operator ++ ()
338    {
339        ++it_;
340        return *this;
341    }
342    ThisType &
343    operator -- ()
344    {
345        --it_;
346        return *this;
347    }
348    ThisType
349    operator ++ (int)
350    {
351        ThisType old(*this);
352        ++it_;
353        return old;
354    }
355    ThisType
356    operator -- (int)
357    {
358        ThisType old(*this);
359        --it_;
360        return old;
361    }
362
363    ThisType
364    operator + (difference_type n) const
365    {
366        return ThisType(it_ + n, get_policy());
367    }
368    ThisType
369    operator - (difference_type n) const
370    {
371        return ThisType(it_ - n, get_policy());
372    }
373
374    ThisType &
375    operator += (difference_type n)
376    {
377        it_ += n;
378        return *this;
379    }
380
381    ThisType &
382    operator -= (difference_type n)
383    {
384        it_ -= n;
385        return *this;
386    }
387
388    bool
389    operator == (const ConstDirectIterator &other) const
390    {
391        return it_ == other.it_;
392    }
393    bool
394    operator != (const ConstDirectIterator &other) const
395    {
396        return it_ != other.it_;
397    }
398    bool
399    operator <= (const ConstDirectIterator &other) const
400    {
401        return it_ <= other.it_;
402    }
403    bool
404    operator >= (const ConstDirectIterator &other) const
405    {
406        return it_ >= other.it_;
407    }
408    bool
409    operator < (const ConstDirectIterator &other) const
410    {
411        return it_ < other.it_;
412    }
413    bool
414    operator > (const ConstDirectIterator &other) const
415    {
416        return it_ > other.it_;
417    }
418
419    reference
420    operator * () const
421    {
422        return *Policy::get(static_cast<ElementType *>((void *)*it_));
423    }
424    pointer
425    operator -> () const
426    {
427        return Policy::get(static_cast<ElementType *>((void *)*it_));
428    }
429    reference
430    operator [] (difference_type n) const
431    {
432        return *Policy::get(static_cast<ElementType *>((void *)it_[n]));
433    }
434
435    difference_type
436    operator - (ConstDirectIterator const &other) const
437    {
438        return it_ - other.it_;
439    }
440};
441
442template <typename T>
443class sc_vector : public sc_vector_base
444{
445  public:
446    using sc_vector_base::size_type;
447    typedef sc_vector_iter<T> iterator;
448    typedef sc_vector_iter<const T> const_iterator;
449
450    sc_vector() : sc_vector_base(::sc_core::sc_gen_unique_name("vector")) {}
451    explicit sc_vector(const char *_name) : sc_vector_base(_name) {}
452    sc_vector(const char *_name, size_type _size) : sc_vector_base(_name)
453    {
454        init(_size);
455    }
456    template <typename Creator>
457    sc_vector(const char *_name, size_type _size, Creator creator) :
458        sc_vector_base(_name)
459    {
460        init(_size, creator);
461    }
462    virtual ~sc_vector() { clear(); }
463
464    void
465    init(size_type _size)
466    {
467        init(_size, &sc_vector<T>::create_element);
468    }
469    static T *
470    create_element(const char *_name, size_type index)
471    {
472        return new T(_name);
473    }
474
475    template <typename Creator>
476    void
477    init(size_type _size, Creator creator)
478    {
479        forceParent();
480        try {
481            for (size_type i = 0; i < _size; i++) {
482                // XXX The name and scope of these objects needs to be handled
483                // specially.
484                T *p = creator(sc_gen_unique_name(basename()), i);
485                objs.push_back(p);
486            }
487        } catch (...) {
488            unforceParent();
489            clear();
490            throw;
491        }
492        unforceParent();
493    }
494
495    T &operator [] (size_type index) { return *static_cast<T *>(objs[index]); }
496    const T &
497    operator [] (size_type index) const
498    {
499        return *static_cast<const T *>(objs[index]);
500    }
501
502    T &
503    at(size_type index)
504    {
505        this->checkIndex(index);
506        return *static_cast<T *>(objs[index]);
507    }
508    const T &
509    at(size_type index) const
510    {
511        this->checkIndex(index);
512        return *static_cast<const T *>(objs[index]);
513    }
514
515    iterator begin() { return objs.begin(); }
516    iterator end() { return objs.end(); }
517    const_iterator begin() const { return objs.begin(); }
518    const_iterator end() const { return objs.end(); }
519    const_iterator cbegin() const { return objs.begin(); }
520    const_iterator cend() const { return objs.end(); }
521
522    template <typename ContainerType, typename ArgumentType>
523    iterator
524    bind(sc_vector_assembly<ContainerType, ArgumentType> c)
525    {
526        return bind(c.begin(), c.end());
527    }
528
529    template <typename BindableContainer>
530    iterator
531    bind(BindableContainer &c)
532    {
533        return bind(c.begin(), c.end());
534    }
535
536    template <typename BindableIterator>
537    iterator
538    bind(BindableIterator first, BindableIterator last)
539    {
540        return bind(first, last, this->begin());
541    }
542
543    template <typename BindableIterator>
544    iterator
545    bind(BindableIterator first, BindableIterator last, iterator from)
546    {
547        if (!size() || from == end() || first == last)
548            reportEmpty(kind(), from == end());
549
550        while (from != end() && first != last)
551            (*from++).bind(*first++);
552        return from;
553    }
554
555    template <typename ContainerType, typename ArgumentType>
556    iterator
557    operator () (sc_vector_assembly<ContainerType, ArgumentType> c)
558    {
559        return (*this)(c.begin(), c.end());
560    }
561
562    template <typename ArgumentContainer>
563    iterator
564    operator () (ArgumentContainer &c)
565    {
566        return (*this)(c.begin(), c.end());
567    }
568
569    template <typename ArgumentIterator>
570    iterator
571    operator () (ArgumentIterator first, ArgumentIterator last)
572    {
573        return (*this)(first, last, this->begin());
574    }
575
576    template <typename ArgumentIterator>
577    iterator
578    operator () (ArgumentIterator first, ArgumentIterator last, iterator from)
579    {
580        if (!size() || from == end() || first == last)
581            reportEmpty(kind(), from == end());
582
583        while (from != end() && first != last)
584            (*from++)(*first++);
585        return from;
586    }
587
588  private:
589    // Disabled
590    sc_vector(const sc_vector &) : sc_vector_base() {}
591    sc_vector &operator = (const sc_vector &) { return *this; }
592
593    void
594    clear()
595    {
596        for (auto obj: objs)
597            delete static_cast<T *>(obj);
598    }
599
600    template <typename, typename>
601    friend class sc_vector_assembly;
602
603    sc_object *
604    objectCast(void *ptr) const
605    {
606        return implicitCast(static_cast<T *>(ptr));
607    }
608};
609
610template <typename T, typename MT>
611class sc_vector_assembly
612{
613  public:
614    friend sc_vector_assembly<T, MT> sc_assemble_vector<>(
615            sc_vector<T> &, MT (T::*));
616
617    typedef size_t size_type;
618    typedef sc_vector_iter<T, sc_member_access<T, MT> > iterator;
619    typedef sc_vector_iter<
620        const T, sc_member_access<const T, const MT> > const_iterator;
621    typedef MT (T::*MemberType);
622
623    sc_vector_assembly(const sc_vector_assembly &other) :
624        vec_(other.vec_), ptr_(other.ptr_)
625    {}
626
627    iterator begin() { return iterator(vec_->begin().it_, ptr_); }
628    iterator end() { return iterator(vec_->end().it_, ptr_); }
629
630    const_iterator
631    cbegin() const
632    {
633        return const_iterator(vec_->begin().it_, ptr_);
634    }
635    const_iterator
636    cend() const
637    {
638        return const_iterator(vec_->end().it_, ptr_);
639    }
640
641    const_iterator
642    begin() const
643    {
644        return const_iterator(vec_->begin().it_, ptr_);
645    }
646    const_iterator
647    end() const
648    {
649        return const_iterator(vec_->end().it_, ptr_);
650    }
651
652    size_type size() const { return vec_->size(); }
653
654    std::vector<sc_object *>
655    get_elements() const
656    {
657        std::vector<sc_object *> ret;
658        for (const_iterator it = begin(); it != end(); it++) {
659            sc_object *obj_ptr = vec_->objectCast(const_cast<MT *>(&*it));
660
661            if (obj_ptr)
662                ret.push_back(obj_ptr);
663        }
664        return ret;
665    }
666
667    typename iterator::reference
668    operator [] (size_type i)
669    {
670        return (*vec_)[i].*ptr_;
671    }
672    typename const_iterator::reference
673    operator [] (size_type i) const
674    {
675        return (*vec_)[i].*ptr_;
676    }
677
678    typename iterator::reference
679    at(size_type i)
680    {
681        return vec_->at(i).*ptr_;
682    }
683    typename const_iterator::reference
684    at(size_type i) const
685    {
686        return vec_->at(i).*ptr_;
687    }
688
689    template <typename ContainerType, typename ArgumentType>
690    iterator
691    bind(sc_vector_assembly<ContainerType, ArgumentType> c)
692    {
693        return bind(c.begin(), c.end());
694    }
695
696    template <typename BindableContainer>
697    iterator
698    bind(BindableContainer &c)
699    {
700        return bind(c.begin(), c.end());
701    }
702
703    template <typename BindableIterator>
704    iterator
705    bind(BindableIterator first, BindableIterator last)
706    {
707        return bind(first, last, this->begin());
708    }
709
710    template <typename BindableIterator>
711    iterator
712    bind(BindableIterator first, BindableIterator last, iterator from)
713    {
714        if (!size() || from == end() || first == last)
715            vec_->reportEmpty("sc_vector_assembly", from == end());
716
717        while (from != end() && first != last)
718            (*from++).bind(*first++);
719        return from;
720    }
721
722    template <typename BindableIterator>
723    iterator
724    bind(BindableIterator first, BindableIterator last,
725            typename sc_vector<T>::iterator from)
726    {
727        return bind(first, last, iterator(from.it_, ptr_));
728    }
729
730    template <typename ContainerType, typename ArgumentType>
731    iterator
732    operator () (sc_vector_assembly<ContainerType, ArgumentType> c)
733    {
734        return (*this)(c.begin(), c.end());
735    }
736
737    template <typename ArgumentContainer>
738    iterator
739    operator () (ArgumentContainer &c)
740    {
741        return (*this)(c.begin(), c.end());
742    }
743
744    template <typename ArgumentIterator>
745    iterator
746    operator () (ArgumentIterator first, ArgumentIterator last)
747    {
748        return (*this)(first, last, this->begin());
749    }
750
751    template <typename ArgumentIterator>
752    iterator
753    operator () (ArgumentIterator first, ArgumentIterator last, iterator from)
754    {
755        if (!size() || from == end() || first == last)
756            vec_->reportEmpty("sc_vector_assembly", from == end());
757
758        while (from != end() && first != last)
759            (*from++)(*first++);
760        return from;
761    }
762
763    template <typename ArgumentIterator>
764    iterator
765    operator () (ArgumentIterator first, ArgumentIterator last,
766                 typename sc_vector<T>::iterator from)
767    {
768        return (*this)(first, last, iterator(from.it_, ptr_));
769    }
770
771  private:
772    sc_vector_assembly(sc_vector<T> &v, MemberType ptr) :
773        vec_(&v), ptr_(ptr)
774    {}
775
776    sc_vector<T> *vec_;
777    MemberType ptr_;
778};
779
780template <typename T, typename MT>
781sc_vector_assembly<T, MT>
782sc_assemble_vector(sc_vector<T> &v, MT (T::*ptr))
783{
784    return sc_vector_assembly<T, MT>(v, ptr);
785}
786
787} // namespace sc_core
788
789#endif  //__SYSTEMC_EXT_UTIL_SC_VECTOR_HH__
790