source: libcfa/src/collections/string.cfa @ 8ca60e4

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// string -- variable-length, mutable run of text, with value semantics
//
// Author           : Michael L. Brooks
// Created On       : Fri Sep 03 11:00:00 2021
// Last Modified By : Peter A. Buhr
// Last Modified On : Sun Jan 14 12:03:47 2024
// Update Count     : 240
//

#include "string.hfa"
#include "string_res.hfa"
#include <stdlib.hfa>

#pragma GCC visibility push(default)

/*
Implementation Principle: typical operation translates to the equivalent
operation on `inner`.  Exceptions are implementing new RAII pattern for value
semantics and some const-hell handling.
*/

////////////////////////////////////////////////////////
// string RAII

// private (not in header)
static void ?{}( string & s, string_res & src, size_t start, size_t len ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, src, SHARE_EDITS, start, len );
}

void ?{}( string & s ) {
    (s.inner) { malloc() };
    ?{}( *s.inner );
}

void ?{}( string & s, const string & c ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, *c.inner, COPY_VALUE );
}

void ?{}( string & s, const string & s2, size_t maxlen) {
    (s.inner) { malloc() };
    ?{}( *s.inner, *s2.inner, COPY_VALUE, maxlen );
}


void ?{}( string & s, string & c ) {
    ?{}( s, (const string &) c );
}

void ?{}( string & s, const char c ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, c );
}

void ?{}( string & s, const char * c ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, c );
}

void ?{}( string & s, const char * c, size_t size) {
    (s.inner) { malloc() };
    ?{}( *s.inner, c, size );
}

void ?{}( string & s, ssize_t rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ?{}( string & s, size_t rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ?{}( string & s, double rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ?{}( string & s, long double rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ?{}( string & s, double _Complex rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ?{}( string & s, long double _Complex rhs ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, rhs );
}

void ^?{}( string & s ) {
    ^(*s.inner){};
    free( s.inner );
    s.inner = 0p;
}

////////////////////////////////////////////////////////
// Alternate construction: request shared edits

string_WithSharedEdits ?`shareEdits( string & s ) {
    string_WithSharedEdits ret = { &s };
    return ret;
}

void ?{}( string & s, string_WithSharedEdits src ) {
    ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth);
}

////////////////////////////////////////////////////////
// Assignment

string & ?=?(string & s, const string & c) {
    (*s.inner) = (*c.inner);
    return s;
}

string & ?=?(string & s, string & c) {
    (*s.inner) = (*c.inner);
    return s;
}

string & ?=?( string & s, const char * val ) {
    (*s.inner) = val;
    return s;
}

string & ?=?( string & s, char val ) {
    (*s.inner) = val;
    return s;
}

string & assign(string & s, const string & c, size_t n) {
    assign(*s.inner, *c.inner, n);
    return s;
}

string & assign(string & s, const char * c, size_t n) {
    assign(*s.inner, c, n);
    return s;
}

string & ?=?( string & s, ssize_t rhs ) {
    (*s.inner) = rhs;
    return s;
}

string & ?=?( string & s, size_t rhs ) {
    (*s.inner) = rhs;
    return s;
}

string & ?=?( string & s, double rhs ) {
    (*s.inner) = rhs;
    return s;
}

string & ?=?( string & s, long double rhs ) {
    (*s.inner) = rhs;
    return s;
}

string & ?=?( string & s, double _Complex rhs ) {
    (*s.inner) = rhs;
    return s;
}

string & ?=?( string & s, long double _Complex rhs ) {
    (*s.inner) = rhs;
    return s;
}

////////////////////////////////////////////////////////
// Input-Output

ofstream & ?|?( ofstream & out, const string & s ) {
    return out | (*s.inner); // print internal string_res
}

void ?|?( ofstream & out, const string & s ) {
    (ofstream &)(out | (*s.inner)); ends( out );
}

ofstream & ?|?( ofstream & os, _Ostream_Manip(string) f ) {
        size_t len = size( f.val );
        char cstr[len + 1];                                                                     // room for null terminator
        for ( i; len ) cstr[i] = f.val[i];                                      // copy string
        cstr[len] = '\0';                                                                       // terminate
        _Ostream_Manip(const char *) cf @= { cstr, f.wd, f.pc, f.base, {f.all} };
        os | cf | nonl;
        return os;
} // ?|?

void ?|?( ofstream & os, _Ostream_Manip(string) f ) {
        (ofstream &)(os | f); ends( os );
}

ifstream & ?|?(ifstream & in, string & s) {
    return in | (*s.inner); // read to internal string_res
}

void ?|?( ifstream & in, string & s ) {
    in | (*s.inner);
}

ifstream & ?|?( ifstream & is, _Istream_Sstr f ) {
        _Istream_Rstr f2 = {f.s.inner, (_Istream_str_base)f};
    return is | f2;
} // ?|?

void ?|?( ifstream & in, _Istream_Sstr f ) {
    (ifstream &)(in | f);
}

////////////////////////////////////////////////////////
// Slicing

string ?()( string & s, size_t start, size_t len ) {
    string ret = { *s.inner, start, len };
    return ret`shareEdits;
}

string ?()( string & s, size_t start ) {
    string ret = { *s.inner, start, size( s ) - start };
    return ret`shareEdits;
}

////////////////////////////////////////////////////////
// Comparison

int  strcmp(const string & s1, const string & s2) { return strcmp(*s1.inner, *s2.inner); }
bool ?==?(const string & s1, const string & s2) { return *s1.inner == *s2.inner; }
bool ?!=?(const string & s1, const string & s2) { return *s1.inner != *s2.inner; }
bool ?>? (const string & s1, const string & s2) { return *s1.inner >  *s2.inner; }
bool ?>=?(const string & s1, const string & s2) { return *s1.inner >= *s2.inner; }
bool ?<=?(const string & s1, const string & s2) { return *s1.inner <= *s2.inner; }
bool ?<? (const string & s1, const string & s2) { return *s1.inner <  *s2.inner; }

int  strcmp(const string & s1, const char * s2) { return strcmp(*s1.inner, s2 ); }
bool ?==?(const string & s1, const char * s2) { return *s1.inner == s2; }
bool ?!=?(const string & s1, const char * s2) { return *s1.inner != s2; }
bool ?>? (const string & s1, const char * s2) { return *s1.inner >  s2; }
bool ?>=?(const string & s1, const char * s2) { return *s1.inner >= s2; }
bool ?<=?(const string & s1, const char * s2) { return *s1.inner <= s2; }
bool ?<? (const string & s1, const char * s2) { return *s1.inner <  s2; }

int  strcmp(const char * s1, const string & s2) { return strcmp( s1, *s2.inner); }
bool ?==?(const char * s1, const string & s2) { return s1 == *s2.inner; }
bool ?!=?(const char * s1, const string & s2) { return s1 != *s2.inner; }
bool ?>? (const char * s1, const string & s2) { return s1 >  *s2.inner; }
bool ?>=?(const char * s1, const string & s2) { return s1 >= *s2.inner; }
bool ?<=?(const char * s1, const string & s2) { return s1 <= *s2.inner; }
bool ?<? (const char * s1, const string & s2) { return s1 <  *s2.inner; }


////////////////////////////////////////////////////////
// Getter

size_t size(const string & s) {
    return size( *s.inner );
}

////////////////////////////////////////////////////////
// Concatenation

void ?+=?(string & s, char c) {
    (*s.inner) += c;
}

void ?+=?(string & s, const string & s2) {
    (*s.inner) += (*s2.inner);
}

void append(string & s, const string & s2, size_t maxlen) {
    append( (*s.inner), (*s2.inner), maxlen );
}

void ?+=?(string & s, const char * c) {
    (*s.inner) += c;
}

void append(string & s, const char * buffer, size_t bsize) {
    append( (*s.inner), buffer, bsize );
}

string ?+?(const string & s, char c) {
    string ret = s;
    ret += c;
    return ret;
}

string ?+?(const string & s, const string & s2) {
    string ret = s;
    ret += s2;
    return ret;
}

string ?+?(const char * s1, const char * s2) {
    string ret = s1;
    ret += s2;
    return ret;
}

string ?+?(const string & s, const char * c) {
    string ret = s;
    ret += c;
    return ret;
}

////////////////////////////////////////////////////////
// Repetition

void ?*=?(string & s, size_t factor) {
    (*s.inner) *= factor;
}

string ?*?(const string & s, size_t factor) {
    string ret = s;
    ret *= factor;
    return ret;
}

string ?*?(char c, size_t factor) {
    string ret = c;
    ret *= factor;
    return ret;
}

string ?*?(const char * s, size_t factor) {
    string ret = s;
    ret *= factor;
    return ret;
}

////////////////////////////////////////////////////////
// Character access

char ?[?](const string & s, size_t index) {
    return (*s.inner)[index];
}

string ?[?](string & s, size_t index) {
    string ret = { *s.inner, index, 1 };
    return ret`shareEdits;
}

////////////////////////////////////////////////////////
// Search

bool contains(const string & s, char ch) {
    return contains( *s.inner, ch );
}

int find(const string & s, char search) {
    return find( *s.inner, search );
}

int find(const string & s, const string & search) {
    return find( *s.inner, *search.inner );
}

int find(const string & s, const char * search) {
    return find( *s.inner, search);
}

int find(const string & s, const char * search, size_t searchsize) {
    return find( *s.inner, search, searchsize);
}

int findFrom(const string & s, size_t fromPos, char search) {
    return findFrom( *s.inner, fromPos, search );
}

int findFrom(const string & s, size_t fromPos, const string & search) {
    return findFrom( *s.inner, fromPos, *search.inner );
}

int findFrom(const string & s, size_t fromPos, const char * search) {
    return findFrom( *s.inner, fromPos, search );
}

int findFrom(const string & s, size_t fromPos, const char * search, size_t searchsize) {
    return findFrom( *s.inner, fromPos, search, searchsize );
}

bool includes(const string & s, const string & search) {
    return includes( *s.inner, *search.inner );
}

bool includes(const string & s, const char * search) {
    return includes( *s.inner, search );
}

bool includes(const string & s, const char * search, size_t searchsize) {
    return includes( *s.inner, search, searchsize );
}

bool startsWith(const string & s, const string & prefix) {
    return startsWith( *s.inner, *prefix.inner );
}

bool startsWith(const string & s, const char * prefix) {
    return startsWith( *s.inner, prefix );
}

bool startsWith(const string & s, const char * prefix, size_t prefixsize) {
    return startsWith( *s.inner, prefix, prefixsize );
}

bool endsWith(const string & s, const string & suffix) {
    return endsWith( *s.inner, *suffix.inner );
}

bool endsWith(const string & s, const char * suffix) {
    return endsWith( *s.inner, suffix );
}

bool endsWith(const string & s, const char * suffix, size_t suffixsize) {
    return endsWith( *s.inner, suffix, suffixsize );
}


///////////////////////////////////////////////////////////////////////////
// charclass, include, exclude

void ?{}( charclass & s, const string & chars) {
    (s.inner) { malloc() };
    ?{}( *s.inner, *(const string_res *)chars.inner );
}

void ?{}( charclass & s, const char * chars ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, chars );
}

void ?{}( charclass & s, const char * chars, size_t charssize ) {
    (s.inner) { malloc() };
    ?{}( *s.inner, chars, charssize );
}

void ^?{}( charclass & s ) {
    ^(*s.inner){};
    free( s.inner );
    s.inner = 0p;
}


int exclude(const string & s, const charclass & mask) {
    return exclude( *s.inner, *mask.inner );
}
/*
StrSlice exclude(string & s, const charclass & mask) {
}
*/

int include(const string & s, const charclass & mask) {
    return include( *s.inner, *mask.inner );
}

/*
StrSlice include(string & s, const charclass & mask) {
}
*/