Changeset b8e047a for libcfa/src/collections/array.hfa

Timestamp:

Jul 28, 2024, 10:12:28 PM (3 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

caa3e2c

Parents:

82ff201a

Message:

formatting

File:

• libcfa/src/collections/array.hfa (modified) (6 diffs)

libcfa/src/collections/array.hfa

@@ -45 +45 @@
 forall( [N], S & | sized(S), Timmed &, Tbase & ) {
         //
-        // Single-dim array sruct (with explicit packing and atom)
+        // Single-dim array struct (with explicit packing and atom)
         //
         struct arpk {
@@ -83 +83 @@
         // Mike is open to being shown a smaller set of overloads that still passes the test.
 
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, zero_t ) {
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, zero_t ) {
                 //assert( 0 < N );
                 subcheck( a, 0L, 0, N );
-                return (Timmed &) a.strides[0];
-        }
-
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, one_t ) {
+                return (Timmed &)a.strides[0];
+        }
+
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, one_t ) {
                 //assert( 1 < N );
                 subcheck( a, 1L, 0, N );
-                return (Timmed &) a.strides[1];
-        }
-
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, int i ) {
+                return (Timmed &)a.strides[1];
+        }
+
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, int i ) {
                 //assert( i < N );
                 subcheck( a, (long int)i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, int i ) {
                 //assert( i < N );
                 subcheck( a, (long int)i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, unsigned int i ) {
                 //assert( i < N );
                 subcheck( a, (long int)i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, unsigned int i ) {
                 //assert( i < N );
                 subcheck( a, (unsigned long int)i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, long int i ) {
                 //assert( i < N );
                 subcheck( a, i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, long int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, long int i ) {
                 //assert( i < N );
                 subcheck( a, i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline Timmed & ?[?]( arpk( N, S, Timmed, Tbase ) & a, unsigned long int i ) {
                 //assert( i < N );
                 subcheck( a, i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase ) & a, unsigned long int i ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline const Timmed & ?[?]( const arpk( N, S, Timmed, Tbase ) & a, unsigned long int i ) {
                 //assert( i < N );
                 subcheck( a, i, 0, N );
-                return (Timmed &) a.strides[i];
-        }
-
-        static inline size_t ?`len( arpk(N, S, Timmed, Tbase ) & a ) {
+                return (Timmed &)a.strides[i];
+        }
+
+        static inline size_t ?`len( arpk( N, S, Timmed, Tbase ) & a ) {
                 return N;
         }
 
-        static inline void __taglen( tag(arpk(N, S, Timmed, Tbase )), tag(N) ) {}
+        static inline void __taglen( tag(arpk( N, S, Timmed, Tbase )), tag(N) ) {}
 }
 
@@ -157 +157 @@
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ?{}( Timmed & ); } )
-static inline void ?{}( arpk(N, S, Timmed, Tbase ) & this ) {   
+static inline void ?{}( arpk( N, S, Timmed, Tbase ) & this ) {  
         void ?{}( S (&)[N] ) {}
         ?{}(this.strides);
 
-        for (i; N) ?{}( (Timmed &) this.strides[i] );
+        for (i; N) ?{}( (Timmed &)this.strides[i] );
 }
 
 forall( [N], S & | sized(S), Timmed &, Tbase & | { void ^?{}( Timmed & ); } )
-static inline void ^?{}( arpk(N, S, Timmed, Tbase ) & this ) {
+static inline void ^?{}( arpk( N, S, Timmed, Tbase ) & this ) {
         void ^?{}( S (&)[N] ) {}
         ^?{}(this.strides);
 
         for (i; N ) {
-                ^?{}( (Timmed &) this.strides[N-i-1] );
+                ^?{}( (Timmed &)this.strides[N-i-1] );
         }
 }
@@ -182 +182 @@
 
 forall( [N], ZTags ... , Trslt &, Tatom & | { Trslt mkar_( tag(Tatom), ZTags ); } )
-static inline arpk(N, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(N), ZTags ) {}
+static inline arpk( N, Trslt, Trslt, Tatom) mkar_( tag(Tatom), tag(N), ZTags ) {}
 
 // based on https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros
@@ -254 +254 @@
 // Base
 forall( [Nq], Sq & | sized(Sq), Tbase & )
-static inline tag(arpk(Nq, Sq, Tbase, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(Tbase ) ) {
-        tag(arpk(Nq, Sq, Tbase, Tbase )) ret;
+static inline tag(arpk( Nq, Sq, Tbase, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(Tbase ) ) {
+        tag(arpk( Nq, Sq, Tbase, Tbase )) ret;
         return ret;
 }
 
 // Rec
-forall( [Nq], Sq & | sized(Sq), [N], S & | sized(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(recq) ); } )
-static inline tag(arpk(N, S, recr, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(arpk(N, S, recq, Tbase )) ) {
-        tag(arpk(N, S, recr, Tbase )) ret;
+forall( [Nq], Sq & | sized(Sq), [N], S & | sized(S), recq &, recr &, Tbase & | { tag(recr) enq_( tag(Tbase), tag(Nq), tag(Sq), tag(recq) ); } )
+static inline tag(arpk( N, S, recr, Tbase )) enq_( tag(Tbase ), tag(Nq), tag(Sq), tag(arpk( N, S, recq, Tbase )) ) {
+        tag(arpk( N, S, recr, Tbase )) ret;
         return ret;
 }
@@ -268 +268 @@
 // Wrapper
 extern struct all_t {} all;
-forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase ), tag(N), tag(S), tag(Te) ); } )
-static inline result & ?[?]( arpk(N, S, Te, Tbase ) & this, all_t ) {
+forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(N), tag(S), tag(Te) ); } )
+static inline result & ?[?]( arpk( N, S, Te, Tbase ) & this, all_t ) {
         return (result&) this;
 }