source: src/Common/utility.h @ 1cb2282

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 1cb2282 was e04ef3a, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

add gcc extension, first attempt, not done yet

  • Property mode set to 100644
File size: 5.3 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// utility.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Jun  8 17:33:59 2016
13// Update Count     : 22
14//
15
16#ifndef _UTILITY_H
17#define _UTILITY_H
18
19#include <iostream>
20#include <sstream>
21#include <iterator>
22#include <string>
23#include <cctype>
24#include <list>
25
26template< typename T >
27static inline T * maybeClone( const T *orig ) {
28        if ( orig ) {
29                return orig->clone();
30        } else {
31                return 0;
32        } // if
33}
34
35template<typename T, typename U>
36struct maybeBuild_t {
37        static T * doit( const U *orig ) {
38                if ( orig ) {
39                        return orig->build();
40                } else {
41                        return 0;
42                } // if
43        }
44};
45
46template< typename T, typename U >
47static inline T * maybeBuild( const U *orig ) {
48        return maybeBuild_t<T,U>::doit(orig);
49}
50
51template< typename Input_iterator >
52void printEnums( Input_iterator begin, Input_iterator end, const char * const *name_array, std::ostream &os ) {
53        for ( Input_iterator i = begin; i != end; ++i ) {
54                os << name_array[ *i ] << ' ';
55        } // for
56}
57
58template< typename Container >
59void deleteAll( Container &container ) {
60        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
61                delete *i;
62        } // for
63}
64
65template< typename Container >
66void printAll( const Container &container, std::ostream &os, int indent = 0 ) {
67        for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
68                if ( *i ) {
69                        os << std::string( indent,  ' ' );
70                        (*i)->print( os, indent + 2 );
71                        // need an endl after each element because it's not easy to know when each individual item should end
72                        os << std::endl;
73                } // if
74        } // for
75}
76
77template< typename SrcContainer, typename DestContainer >
78void cloneAll( const SrcContainer &src, DestContainer &dest ) {
79        typename SrcContainer::const_iterator in = src.begin();
80        std::back_insert_iterator< DestContainer > out( dest );
81        while ( in != src.end() ) {
82                *out++ = (*in++)->clone();
83        } // while
84}
85
86template< typename Container >
87void assertAll( const Container &container ) {
88        int count = 0;
89        for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
90                if ( !(*i) ) {
91                        std::cerr << count << " is null" << std::endl;
92                } // if
93        } // for
94}
95
96static inline std::string assign_strptr( const std::string *str ) {
97        if ( str == 0 ) {
98                return "";
99        } else {
100                std::string tmp;
101                tmp = *str;
102                delete str;
103                return tmp;
104        } // if
105}
106
107template< class T, typename ResultType, ResultType( T::* memfunc )() >
108ResultType dispatch( T *pT ) {
109        return (pT->*memfunc)();
110}
111
112template < typename T >
113std::list<T> tail( std::list<T> l ) {
114        if ( ! l.empty() ) {
115                std::list<T> ret(++(l.begin()), l.end());
116                return ret;
117        } // if
118}
119
120template < typename T >
121std::list<T> flatten( std::list < std::list<T> > l) {
122        typedef std::list <T> Ts;
123
124        Ts ret;
125
126        switch ( l.size() ) {
127          case 0:
128                return ret;
129          case 1:
130                return l.front();
131          default:
132                ret = flatten(tail(l));
133                ret.insert(ret.begin(), l.front().begin(), l.front().end());
134                return ret;
135        } // switch
136}
137
138template < typename T >
139std::string toString ( T value ) {
140        std::ostringstream os;
141        os << value; // << std::ends;
142        return os.str();
143}
144
145template< class Constructed, typename Arg >
146Constructed *ctor( Arg arg ) {
147        Constructed *c = new Constructed( arg );
148        return c;
149}
150
151template< class Constructed, typename Arg >
152Constructed ctor_noptr( Arg arg ) {
153        return Constructed( arg );
154}
155
156template< typename T >
157void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
158        typename std::list< T >::iterator next = pos; advance( next, 1 );
159
160        //if ( next != org.end() ) {
161        org.erase( pos );
162        org.splice( next, with );
163        //}
164
165        return;
166}
167
168template< typename T1, typename T2 >
169T2 *cast_ptr( T1 *from ) {
170        return dynamic_cast< T2 * >( from );
171}
172
173template< class Exception, typename Arg >
174void inline assert_throw( bool pred, Arg arg ) {
175        if (pred) throw Exception( arg );
176}
177
178template< typename T >
179struct is_null_pointer {
180        bool operator()( const T *ptr ) { return ( ptr == 0 ); }
181};
182
183template< class InputIterator, class OutputIterator, class Predicate >
184void filter(InputIterator begin, InputIterator end, OutputIterator out, Predicate pred) {
185        while ( begin++ != end )
186                if ( pred(*begin) ) *out++ = *begin;
187
188        return;
189}
190
191template< class InputIterator1, class InputIterator2, class OutputIterator >
192void zip( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out ) {
193        while ( b1 != e1 && b2 != e2 )
194                *out++ = std::pair<typename InputIterator1::value_type, typename InputIterator2::value_type>(*b1++, *b2++);
195}
196
197template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
198void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
199        while ( b1 != e1 && b2 != e2 )
200                *out++ = func(*b1++, *b2++);
201}
202
203// it's nice to actually be able to increment iterators by an arbitrary amount
204template< typename Iterator >
205Iterator operator+(Iterator i, int inc) {
206        while ( inc > 0 ) {
207                ++i;
208                --inc;
209        }
210        return i;
211}
212
213#endif // _UTILITY_H
214
215// Local Variables: //
216// tab-width: 4 //
217// mode: c++ //
218// compile-command: "make install" //
219// End: //
Note: See TracBrowser for help on using the repository browser.