Changeset 8c2723f for libcfa/src

Timestamp:

Mar 14, 2025, 4:22:42 PM (4 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

3d9831b

Parents:

a21aaff

Message:

change name shareEdit to share

Location:

libcfa/src/collections

Files:

• string.cfa (modified) (4 diffs)
• string.hfa (modified) (2 diffs)
• string_res.cfa (modified) (17 diffs)
• string_res.hfa (modified) (2 diffs)

libcfa/src/collections/string.cfa ¶

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug  5 23:12:05 2024
-// Update Count     : 273
+// Last Modified On : Fri Mar 14 15:41:33 2025
+// Update Count     : 275
 //
 
@@ -139 +139 @@
 // Alternate construction: request shared edits
 
-string_WithSharedEdits ?`shareEdits( string & s ) {
-    string_WithSharedEdits ret = { &s };
-    return ret;
-}
-
-void ?{}( string & s, string_WithSharedEdits src ) {
+string_Share ?`share( string & s ) {
+    string_Share ret = { &s };
+    return ret;
+}
+
+void ?{}( string & s, string_Share src ) {
     ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth );
 }
@@ -255 +255 @@
 string ?()( string & s, size_t start, size_t len ) {
     string ret = { *s.inner, start, len };
-    return ret`shareEdits;
+    return ret`share;
 }
 
 string ?()( string & s, size_t start ) {
     string ret = { *s.inner, start, size( s ) - start };
-    return ret`shareEdits;
+    return ret`share;
 }
 
@@ -403 +403 @@
 string ?[?]( string & s, size_t index ) {
     string ret = { *s.inner, index, 1 };
-    return ret`shareEdits;
+    return ret`share;
 }
 

libcfa/src/collections/string.hfa ¶

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 13 10:50:30 2024
-// Update Count     : 131
+// Last Modified On : Fri Mar 14 15:33:38 2025
+// Update Count     : 132
 //
 
@@ -77 +77 @@
 
 // Alternate construction: request shared edits
-struct string_WithSharedEdits {
+struct string_Share {
     string * s;
 };
-string_WithSharedEdits ?`shareEdits( string & s );
-void ?{}( string & s, string_WithSharedEdits src );
+string_Share ?`share( string & s );
+void ?{}( string & s, string_Share src );
 
 // IO Operator

libcfa/src/collections/string_res.cfa ¶

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 17 14:08:01 2024
-// Update Count     : 86
+// Last Modified On : Fri Mar 14 15:45:24 2025
+// Update Count     : 88
 //
 
@@ -319 +319 @@
         if( ambient_string_sharectx->activeHeap ) {
                 (Handle){ * ambient_string_sharectx->activeHeap };
-                (shareEditSet_owns_ulink){ false };
+                (shareSet_owns_ulink){ false };
                 verify( Handle.s == 0p && Handle.lnth == 0 );
         } else {
                 (Handle){ * new( (size_t) 10 ) };  // TODO: can I lazily avoid allocating for empty string
-                (shareEditSet_owns_ulink){ true };
+                (shareSet_owns_ulink){ true };
                 Handle.s = Handle.ulink->StartVbyte;
                 verify( Handle.lnth == 0 );
         }
-        s.shareEditSet_prev = &s;
-        s.shareEditSet_next = &s;
+        s.shareSet_prev = &s;
+        s.shareSet_next = &s;
                 }
 
@@ -334 +334 @@
         if( ambient_string_sharectx->activeHeap ) {
                 (Handle){ * ambient_string_sharectx->activeHeap };
-                (shareEditSet_owns_ulink){ false };
+                (shareSet_owns_ulink){ false };
         } else {
                 (Handle){ * new( rhslnth ) };
-                (shareEditSet_owns_ulink){ true };
+                (shareSet_owns_ulink){ true };
         }
         Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
         Handle.lnth = rhslnth;
         memmove( Handle.s, rhs, rhslnth );
-        s.shareEditSet_prev = &s;
-        s.shareEditSet_next = &s;
+        s.shareSet_prev = &s;
+        s.shareSet_next = &s;
 }
 
@@ -393 +393 @@
         Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
         Handle.lnth = rhslnth;
-        (s.shareEditSet_owns_ulink){ false };
+        (s.shareSet_owns_ulink){ false };
         memmove( Handle.s, rhs, rhslnth );
-        s.shareEditSet_prev = &s;
-        s.shareEditSet_next = &s;
+        s.shareSet_prev = &s;
+        s.shareSet_next = &s;
 }
 
@@ -408 +408 @@
                 // crossing heaps (including private): copy eagerly
                 eagerCopyCtorHelper(s, s2.Handle.s + start, end - start);
-                verify(s.shareEditSet_prev == &s);
-                verify(s.shareEditSet_next == &s);
+                verify(s.shareSet_prev == &s);
+                verify(s.shareSet_next == &s);
         } else {
                 (s.Handle){};
@@ -423 +423 @@
                         // requested logical copy in same heap: defer copy until write
 
-                        (s.shareEditSet_owns_ulink){ false };
-
-                        // make s alone in its shareEditSet
-                        s.shareEditSet_prev = &s;
-                        s.shareEditSet_next = &s;
+                        (s.shareSet_owns_ulink){ false };
+
+                        // make s alone in its shareSet
+                        s.shareSet_prev = &s;
+                        s.shareSet_next = &s;
                 } else {
                         verify( mode == SHARE_EDITS );
                         // sharing edits with source forces same heap as source (ignore context)
 
-                        (s.shareEditSet_owns_ulink){ s2.shareEditSet_owns_ulink };
+                        (s.shareSet_owns_ulink){ s2.shareSet_owns_ulink };
 
                         // s2 is logically const but not implementation const
                         string_res & s2mod = (string_res &) s2;
 
-                        // insert s after s2 on shareEditSet
-                        s.shareEditSet_next = s2mod.shareEditSet_next;
-                        s.shareEditSet_prev = &s2mod;
-                        s.shareEditSet_next->shareEditSet_prev = &s;
-                        s.shareEditSet_prev->shareEditSet_next = &s;
+                        // insert s after s2 on shareSet
+                        s.shareSet_next = s2mod.shareSet_next;
+                        s.shareSet_prev = &s2mod;
+                        s.shareSet_next->shareSet_prev = &s;
+                        s.shareSet_prev->shareSet_next = &s;
                 }
         }
 }
 
-static void assignEditSet(string_res & s, string_res * shareEditSetStartPeer, string_res * shareEditSetEndPeer,
+static void assignEditSet(string_res & s, string_res * shareSetStartPeer, string_res * shareSetEndPeer,
                                                   char * resultSesStart,
                                                   size_t resultSesLnth,
                                                   HandleNode * resultPadPosition, size_t bsize ) {
 
-        char * beforeBegin = shareEditSetStartPeer->Handle.s;
+        char * beforeBegin = shareSetStartPeer->Handle.s;
         size_t beforeLen = s.Handle.s - beforeBegin;
 
         char * afterBegin = s.Handle.s + s.Handle.lnth;
-        size_t afterLen = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - afterBegin;
+        size_t afterLen = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - afterBegin;
 
         size_t oldLnth = s.Handle.lnth;
@@ -466 +466 @@
         // adjust all substring string and handle locations, and check if any substring strings are outside the new base string
         char *limit = resultSesStart + resultSesLnth;
-        for ( string_res * p = s.shareEditSet_next; p != &s; p = p->shareEditSet_next ) {
+        for ( string_res * p = s.shareSet_next; p != &s; p = p->shareSet_next ) {
                 verify (p->Handle.s >= beforeBegin);
                 if ( p->Handle.s >= afterBegin ) {
@@ -520 +520 @@
 
 // traverse the share-edit set (SES) to recover the range of a base string to which `s` belongs
-static void locateInShareEditSet( string_res & s, string_res *& shareEditSetStartPeer, string_res *& shareEditSetEndPeer ) {
-        shareEditSetStartPeer = & s;
-        shareEditSetEndPeer = & s;
-        for (string_res * editPeer = s.shareEditSet_next; editPeer != &s; editPeer = editPeer->shareEditSet_next) {
-                if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
-                        shareEditSetStartPeer = editPeer;
+static void locateInShareSet( string_res & s, string_res *& shareSetStartPeer, string_res *& shareSetEndPeer ) {
+        shareSetStartPeer = & s;
+        shareSetEndPeer = & s;
+        for (string_res * editPeer = s.shareSet_next; editPeer != &s; editPeer = editPeer->shareSet_next) {
+                if ( editPeer->Handle.s < shareSetStartPeer->Handle.s ) {
+                        shareSetStartPeer = editPeer;
                 }
-                if ( shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) {
-                        shareEditSetEndPeer = editPeer;
+                if ( shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) {
+                        shareSetEndPeer = editPeer;
                 }
         }
@@ -534 +534 @@
 
 static string_res & assign_(string_res & s, const char * buffer, size_t bsize, const string_res & valSrc) {
-        string_res * shareEditSetStartPeer;
-        string_res * shareEditSetEndPeer;
-        locateInShareEditSet( s, shareEditSetStartPeer, shareEditSetEndPeer );
-
-        verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s );
-        size_t origEditSetLength = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - shareEditSetStartPeer->Handle.s;
+        string_res * shareSetStartPeer;
+        string_res * shareSetEndPeer;
+        locateInShareSet( s, shareSetStartPeer, shareSetEndPeer );
+
+        verify( shareSetEndPeer->Handle.s >= shareSetStartPeer->Handle.s );
+        size_t origEditSetLength = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - shareSetStartPeer->Handle.s;
         verify( origEditSetLength >= s.Handle.lnth );
 
-        if ( s.shareEditSet_owns_ulink ) {                               // assigning to private context
+        if ( s.shareSet_owns_ulink ) {                           // assigning to private context
                 // ok to overwrite old value within LHS
-                char * prefixStartOrig = shareEditSetStartPeer->Handle.s;
+                char * prefixStartOrig = shareSetStartPeer->Handle.s;
                 int prefixLen = s.Handle.s - prefixStartOrig;
                 char * suffixStartOrig = s.Handle.s + s.Handle.lnth;
-                int suffixLen = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - suffixStartOrig;
+                int suffixLen = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - suffixStartOrig;
 
                 int delta = bsize - s.Handle.lnth;
@@ -556 +556 @@
                         destCursor += prefixLen;  memcpy(destCursor, buffer              , bsize        );
                         destCursor += bsize;      memcpy(destCursor, suffixStartOrig, suffixLen);
-                        assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
+                        assignEditSet(s, shareSetStartPeer, shareSetEndPeer, 
                                                   dest,
                                                   origEditSetLength + delta,
@@ -566 +566 @@
                         memcpy( s.Handle.s, buffer, bsize );
 
-                        assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
-                                                  shareEditSetStartPeer->Handle.s,
+                        assignEditSet(s, shareSetStartPeer, shareSetEndPeer, 
+                                                  shareSetStartPeer->Handle.s,
                                                   origEditSetLength + delta,
                                                   0p, bsize);
@@ -578 +578 @@
 
                 // SES's result will only use characters from the source string => reuse source
-                assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
+                assignEditSet(s, shareSetStartPeer, shareSetEndPeer, 
                                           valSrc.Handle.s,
                                           valSrc.Handle.lnth,
@@ -587 +587 @@
                 // OR we are importing characters: need to copy eagerly (can't refer to source)
 
-                // full string is from start of shareEditSetStartPeer thru end of shareEditSetEndPeer
+                // full string is from start of shareSetStartPeer thru end of shareSetEndPeer
                 // `s` occurs in the middle of it, to be replaced
                 // build up the new text in `pasting`
@@ -593 +593 @@
                 string_res pasting = {
                         * s.Handle.ulink,                                                          // maintain same heap, regardless of context
-                        shareEditSetStartPeer->Handle.s,                                   // start of SES
-                        s.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before s
+                        shareSetStartPeer->Handle.s,                               // start of SES
+                        s.Handle.s - shareSetStartPeer->Handle.s }; // length of SES, before s
                 append( pasting,
                                 buffer,                                                                                 // start of replacement for s
@@ -600 +600 @@
                 append( pasting,
                                 s.Handle.s + s.Handle.lnth,                               // start of SES after s
-                                shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth -
+                                shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth -
                                 (s.Handle.s + s.Handle.lnth) );                   // length of SES, after s
 
@@ -607 +607 @@
                 // From s point on, they are stable.
 
-                assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
+                assignEditSet(s, shareSetStartPeer, shareSetEndPeer, 
                                           pasting.Handle.s,
                                           pasting.Handle.lnth,
@@ -675 +675 @@
 
         // sever s from its share-edit peers, if any (four no-ops when already solo)
-        s.shareEditSet_prev->shareEditSet_next = s.shareEditSet_next;
-        s.shareEditSet_next->shareEditSet_prev = s.shareEditSet_prev;
-        // s.shareEditSet_next = &s;
-        // s.shareEditSet_prev = &s;
-
-        if (shareEditSet_owns_ulink && s.shareEditSet_next == &s) { // last one out
+        s.shareSet_prev->shareSet_next = s.shareSet_next;
+        s.shareSet_next->shareSet_prev = s.shareSet_prev;
+        // s.shareSet_next = &s;
+        // s.shareSet_prev = &s;
+
+        if (shareSet_owns_ulink && s.shareSet_next == &s) { // last one out
                 delete( s.Handle.ulink );
         }

libcfa/src/collections/string_res.hfa ¶

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 13 10:51:11 2024
-// Update Count     : 60
+// Last Modified On : Fri Mar 14 15:44:01 2025
+// Update Count     : 61
 //
 
@@ -46 +46 @@
 struct string_res {
     HandleNode Handle; // chars, start, end, global neighbours
-    bool shareEditSet_owns_ulink;
-    string_res * shareEditSet_prev;
-    string_res * shareEditSet_next;
+    bool shareSet_owns_ulink;
+    string_res * shareSet_prev;
+    string_res * shareSet_next;
 };