Changes in src/Common/utility.h [9feb34b:7491f97]

File:

• src/Common/utility.h (modified) (7 diffs)

src/Common/utility.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// utility.h -- General utilities used across the compiler.
+// utility.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Feb 17 15:25:00 2023
-// Update Count     : 53
+// Last Modified On : Mon Apr 25 14:26:00 2022
+// Update Count     : 51
 //
 
@@ -19 +19 @@
 #include <cctype>
 #include <algorithm>
+#include <functional>
 #include <iostream>
+#include <iterator>
 #include <list>
 #include <memory>
+#include <sstream>
 #include <string>
 #include <type_traits>
+#include <utility>
 #include <vector>
 #include <cstring>                                                                              // memcmp
@@ -45 +49 @@
                 return 0;
         } // if
+}
+
+template< typename T, typename U >
+struct maybeBuild_t {
+        static T * doit( const U *orig ) {
+                if ( orig ) {
+                        return orig->build();
+                } else {
+                        return 0;
+                } // if
+        }
+};
+
+template< typename T, typename U >
+static inline T * maybeBuild( const U *orig ) {
+        return maybeBuild_t<T,U>::doit(orig);
+}
+
+template< typename T, typename U >
+static inline T * maybeMoveBuild( const U *orig ) {
+        T* ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
 }
 
@@ -141 +168 @@
         splice( src, dst );
         dst.swap( src );
+}
+
+template < typename T >
+void toString_single( std::ostream & os, const T & value ) {
+        os << value;
+}
+
+template < typename T, typename... Params >
+void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
+        os << value;
+        toString_single( os, params ... );
+}
+
+template < typename ... Params >
+std::string toString( const Params & ... params ) {
+        std::ostringstream os;
+        toString_single( os, params... );
+        return os.str();
+}
+
+#define toCString( ... ) toString( __VA_ARGS__ ).c_str()
+
+// replace element of list with all elements of another list
+template< typename T >
+void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
+        typename std::list< T >::iterator next = pos; advance( next, 1 );
+
+        //if ( next != org.end() ) {
+        org.erase( pos );
+        org.splice( next, with );
+        //}
+
+        return;
+}
+
+// replace range of a list with a single element
+template< typename T >
+void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
+        org.insert( begin, with );
+        org.erase( begin, end );
 }
 
@@ -169 +236 @@
 }
 
+template< typename... Args >
+auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
+  return zipWith(std::forward<Args>(args)..., std::make_pair);
+}
+
+template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
+void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
+        while ( b1 != e1 && b2 != e2 )
+                *out++ = func(*b1++, *b2++);
+}
+
+// it's nice to actually be able to increment iterators by an arbitrary amount
+template< class InputIt, class Distance >
+InputIt operator+( InputIt it, Distance n ) {
+        advance(it, n);
+        return it;
+}
+
+template< typename T >
+void warn_single( const T & arg ) {
+        std::cerr << arg << std::endl;
+}
+
+template< typename T, typename... Params >
+void warn_single(const T & arg, const Params & ... params ) {
+        std::cerr << arg;
+        warn_single( params... );
+}
+
+template< typename... Params >
+void warn( const Params & ... params ) {
+        std::cerr << "Warning: ";
+        warn_single( params... );
+}
+
 // determines if pref is a prefix of str
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
         if ( pref.size() > str.size() ) return false;
-        return pref == str.substr(start, pref.size());
-}
+    return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
+        // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
+}
+
+// -----------------------------------------------------------------------------
+// Ref Counted Singleton class
+// Objects that inherit from this class will have at most one reference to it
+// but if all references die, the object will be deleted.
+
+template< typename ThisType >
+class RefCountSingleton {
+  public:
+        static std::shared_ptr<ThisType> get() {
+                if( global_instance.expired() ) {
+                        std::shared_ptr<ThisType> new_instance = std::make_shared<ThisType>();
+                        global_instance = new_instance;
+                        return std::move(new_instance);
+                }
+                return global_instance.lock();
+        }
+  private:
+        static std::weak_ptr<ThisType> global_instance;
+};
+
+template< typename ThisType >
+std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
 
 // -----------------------------------------------------------------------------
@@ -230 +356 @@
         ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
 };
+
+// -----------------------------------------------------------------------------
+// Helper struct and function to support
+// for ( val : reverseIterate( container ) ) {}
+// syntax to have a for each that iterates backwards
+
+template< typename T >
+struct reverse_iterate_t {
+        T& ref;
+
+        reverse_iterate_t( T & ref ) : ref(ref) {}
+
+        // this does NOT work on const T!!!
+        // typedef typename T::reverse_iterator iterator;
+        auto begin() { return ref.rbegin(); }
+        auto end() { return ref.rend(); }
+};
+
+template< typename T >
+reverse_iterate_t< T > reverseIterate( T & ref ) {
+        return reverse_iterate_t< T >( ref );
+}
+
+template< typename T >
+struct enumerate_t {
+        template<typename val_t>
+        struct value_t {
+                val_t & val;
+                size_t idx;
+        };
+
+        template< typename iter_t, typename val_t >
+        struct iterator_t {
+                iter_t it;
+                size_t idx;
+
+                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
+
+                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
+
+                bool operator==(const iterator_t & o) const { return o.it == it; }
+                bool operator!=(const iterator_t & o) const { return o.it != it; }
+
+                iterator_t & operator++() {
+                        it++;
+                        idx++;
+                        return *this;
+                }
+
+                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
+                using value_type        = value_t<val_t>;
+                using pointer           = value_t<val_t> *;
+                using reference         = value_t<val_t> &;
+                using iterator_category = std::forward_iterator_tag;
+        };
+
+        T & ref;
+
+        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
+        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
+
+        iterator begin() { return iterator( ref.begin(), 0 ); }
+        iterator end()   { return iterator( ref.end(), ref.size() ); }
+
+        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
+        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
+
+        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
+        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
+};
+
+template< typename T >
+enumerate_t<T> enumerate( T & ref ) {
+        return enumerate_t< T >{ ref };
+}
+
+template< typename T >
+const enumerate_t< const T > enumerate( const T & ref ) {
+        return enumerate_t< const T >{ ref };
+}
+
+template< typename OutType, typename Range, typename Functor >
+OutType map_range( const Range& range, Functor&& functor ) {
+        OutType out;
+
+        std::transform(
+                begin( range ),
+                end( range ),
+                std::back_inserter( out ),
+                std::forward< Functor >( functor )
+        );
+
+        return out;
+}
+
+// -----------------------------------------------------------------------------
+// Helper struct and function to support:
+// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
+// This iteraters through multiple containers of the same size.
+
+template<typename... Args>
+class group_iterate_t {
+        using Iterables = std::tuple<Args...>;
+        Iterables iterables;
+
+        // Getting the iterator and value types this way preserves const.
+        template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
+        template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
+        template<typename> struct base_iterator;
+
+        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
+        // into a pack. These are the indexes into the tuples, so unpacking can
+        // go over each element of the tuple.
+        // The std::integer_sequence is just used to build that sequence.
+        // A library reference will probably explain it better than I can.
+        template<std::size_t... Indices>
+        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
+                using value_type = std::tuple< Data<Indices>... >;
+                std::tuple<Iter<Indices>...> iterators;
+
+                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
+                base_iterator operator++() {
+                        return base_iterator( ++std::get<Indices>( iterators )... );
+                }
+                bool operator!=( const base_iterator& other ) const {
+                        return iterators != other.iterators;
+                }
+                value_type operator*() const {
+                        return std::tie( *std::get<Indices>( iterators )... );
+                }
+
+                static base_iterator make_begin( Iterables & data ) {
+                        return base_iterator( std::get<Indices>( data ).begin()... );
+                }
+                static base_iterator make_end( Iterables & data ) {
+                        return base_iterator( std::get<Indices>( data ).end()... );
+                }
+        };
+
+public:
+        group_iterate_t( const Args &... args ) : iterables( args... ) {}
+
+        using iterator = base_iterator<decltype(
+                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
+
+        iterator begin() { return iterator::make_begin( iterables ); }
+        iterator end() { return iterator::make_end( iterables ); }
+};
+
+// Helpers for the bounds checks (the non-varatic part of group_iterate):
+static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
+        assertf( size0 == size1,
+                "group iteration requires containers of the same size: <%zd, %zd>.",
+                size0, size1 );
+}
+
+static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
+        assertf( size0 == size1 && size1 == size2,
+                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
+                size0, size1, size2 );
+}
+
+/// Performs bounds check to ensure that all arguments are of the same length.
+template< typename... Args >
+group_iterate_t<Args...> group_iterate( Args &&... args ) {
+        runGroupBoundsCheck( args.size()... );
+        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
+
+/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
+template< typename... Args >
+group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
+        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
+
+// -----------------------------------------------------------------------------
+// Helper struct and function to support
+// for ( val : lazy_map( container1, f ) ) {}
+// syntax to have a for each that iterates a container, mapping each element by applying f
+template< typename T, typename Func >
+struct lambda_iterate_t {
+        const T & ref;
+        std::function<Func> f;
+
+        struct iterator {
+                typedef decltype(begin(ref)) Iter;
+                Iter it;
+                std::function<Func> f;
+                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
+                iterator & operator++() {
+                        ++it; return *this;
+                }
+                bool operator!=( const iterator &other ) const { return it != other.it; }
+                auto operator*() const -> decltype(f(*it)) { return f(*it); }
+        };
+
+        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
+
+        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
+        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
+};
+
+template< typename... Args >
+lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
+        return lambda_iterate_t<Args...>( args...);
+}
 
 // -----------------------------------------------------------------------------
@@ -251 +583 @@
 } // ilog2
 
+// -----------------------------------------------------------------------------
+/// evaluates expr as a long long int. If second is false, expr could not be evaluated
+std::pair<long long int, bool> eval(const Expression * expr);
+
+namespace ast {
+        class Expr;
+}
+
+std::pair<long long int, bool> eval(const ast::Expr * expr);
+
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the
+/// comparator are in front;
+/// returns the iterator after the last minimal-value element.
+template<typename Iter, typename Compare>
+Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
+        if ( begin == end ) return end;
+
+        Iter min_pos = begin;
+        for ( Iter i = begin + 1; i != end; ++i ) {
+                if ( lt( *i, *min_pos ) ) {
+                        // new minimum cost; swap into first position
+                        min_pos = begin;
+                        std::iter_swap( min_pos, i );
+                } else if ( ! lt( *min_pos, *i ) ) {
+                        // duplicate minimum cost; swap into next minimum position
+                        ++min_pos;
+                        std::iter_swap( min_pos, i );
+                }
+        }
+        return ++min_pos;
+}
+
+template<typename Iter, typename Compare>
+inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
+        return sort_mins( begin, end, lt );
+}
+
+/// sort_mins defaulted to use std::less
+template<typename Iter>
+inline Iter sort_mins( Iter begin, Iter end ) {
+        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
+
 // Local Variables: //
 // tab-width: 4 //