source: libcfa/src/collections/string.hfa @ 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:46 2024
// Update Count     : 81
//

#pragma once

#include <fstream.hfa>


// in string_res.hfa
struct string_res;
struct charclass_res;

struct string {
    string_res * inner;
};

// Getters
size_t size(const string & s);
static inline size_t strlen(const string & s) { return size( s ); }

// RAII, assignment
void ?{}(string & s); // empty string
void ?{}(string & s, const string & s2);
void ?{}(string & s, const string & s2, size_t maxlen);
void ?{}(string & s, string & s2);

void ?{}(string & s, char);
void ?{}(string & s, const char * c); // copy from string literal (NULL-terminated)
void ?{}(string & s, const char * c, size_t size); // copy specific length from buffer

void ?{}( string & s, ssize_t rhs );
void ?{}( string & s, size_t rhs );
void ?{}( string & s, double rhs );
void ?{}( string & s, long double rhs );
void ?{}( string & s, double _Complex rhs );
void ?{}( string & s, long double _Complex rhs );

string & ?=?(string & s, const string & c);
string & ?=?(string & s, string & c);
string & ?=?(string & s, const char * c); // copy from "literal"
string & ?=?(string & s, char c);  // copy from 'l'
string & assign(string & s, const string & c, size_t n);
string & assign(string & s, const char * c, size_t n);

static inline string & strcpy(string & s, const char * c) { s = c; return s; }
static inline string & strncpy(string & s, const char * c, size_t n) { assign( s, c, n); return s; }
static inline string & strcpy(string & s, const string & c) { s = c; return s; }
static inline string & strncpy(string & s, const string & c, size_t n) { assign(s, c, n); return s; }

string & ?=?( string & s, ssize_t rhs );
string & ?=?( string & s, size_t rhs );
string & ?=?( string & s, double rhs );
string & ?=?( string & s, long double rhs );
string & ?=?( string & s, double _Complex rhs );
string & ?=?( string & s, long double _Complex rhs );

void ^?{}(string & s);

// Alternate construction: request shared edits
struct string_WithSharedEdits {
    string * s;
};
string_WithSharedEdits ?`shareEdits( string & s );
void ?{}( string & s, string_WithSharedEdits src );

// IO Operator
ofstream & ?|?(ofstream & out, const string & s);
void ?|?(ofstream & out, const string & s);
ifstream & ?|?(ifstream & in, string & s);
void ?|?( ifstream & in, string & s );

static inline {
        _Ostream_Manip(string) bin( string s ) { return (_Ostream_Manip(string))@{ s, 1, 0, 'b', { .all : 0 } }; }
        _Ostream_Manip(string) oct( string s ) { return (_Ostream_Manip(string))@{ s, 1, 0, 'o', { .all : 0 } }; }
        _Ostream_Manip(string) hex( string s ) { return (_Ostream_Manip(string))@{ s, 1, 0, 'x', { .all : 0 } }; }
        _Ostream_Manip(string) wd( unsigned int w, string s ) { return (_Ostream_Manip(string))@{ s, w, 0, 's', { .all : 0 } }; }
        _Ostream_Manip(string) wd( unsigned int w, unsigned int pc, string s ) { return (_Ostream_Manip(string))@{ s, w, pc, 's', { .flags.pc : true } }; }
        _Ostream_Manip(string) & wd( unsigned int w, _Ostream_Manip(string) & fmt ) { fmt.wd = w; return fmt; }
        _Ostream_Manip(string) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(string) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
        _Ostream_Manip(string) & left( _Ostream_Manip(string) & fmt ) { fmt.flags.left = true; return fmt; }
        _Ostream_Manip(string) & nobase( _Ostream_Manip(string) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
} // distribution
ofstream & ?|?( ofstream & os, _Ostream_Manip(string) f );
void ?|?( ofstream & os, _Ostream_Manip(string) );

struct _Istream_Sstr {
        string & s;
        inline _Istream_str_base;
}; // _Istream_Sstr

static inline {
        // read width does not include null terminator
        _Istream_Sstr wdi( unsigned int rwd, string & s ) { return (_Istream_Sstr)@{ s, {{0p}, rwd, {.flags.rwd : true}} }; }
        _Istream_Sstr getline( string & s, const char delimiter = '\n' ) {
                return (_Istream_Sstr)@{ s, {{.delimiters : { delimiter, '\0' } }, -1, {.flags.delimiter : true, .flags.inex : true}} };
        }
        _Istream_Sstr & getline( _Istream_Sstr & fmt, const char delimiter = '\n' ) {
                fmt.delimiters[0] = delimiter; fmt.delimiters[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
        }
        _Istream_Sstr incl( const char scanset[], string & s ) { return (_Istream_Sstr)@{ s, {{scanset}, -1, {.flags.inex : false}} }; }
        _Istream_Sstr & incl( const char scanset[], _Istream_Sstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
        _Istream_Sstr excl( const char scanset[], string & s ) { return (_Istream_Sstr)@{ s, {{scanset}, -1, {.flags.inex : true}} }; }
        _Istream_Sstr & excl( const char scanset[], _Istream_Sstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
        _Istream_Sstr ignore( string & s ) { return (_Istream_Sstr)@{ s, {{0p}, -1, {.flags.ignore : true}} }; }
        _Istream_Sstr & ignore( _Istream_Sstr & fmt ) { fmt.flags.ignore = true; return fmt; }
} // distribution
ifstream & ?|?( ifstream & is, _Istream_Sstr f );
void ?|?( ifstream & is, _Istream_Sstr t );

// Concatenation
void ?+=?(string & s, char c); // append a character
void ?+=?(string & s, const string & s2); // append-concatenate to first string
void append(string & s, const string & s2, size_t maxlen);  // append-concatenate to first string, up to maxlen
void ?+=?(string & s, const char * s2); // append-concatenate NULL-terminated string to first string
void append(string & s, const char * buffer, size_t bsize);  // append-concatenate given range to first string

string ?+?(const string & s, char c); // add a character to a copy of the string
string ?+?(const string & s, const string & s2); // copy and concatenate both strings
string ?+?(const char * s1, const char * s2); // copy and concatenate both strings
string ?+?(const string & s, const char * c); // copy and concatenate with NULL-terminated string

static inline string & strcat(string & s, const string & s2) { s += s2; return s; }
static inline string & strcat(string & s, const char * c) { s += c; return s; }
static inline string & strncat(string & s, const string & s2, size_t maxlen) { append(s, s2, maxlen); return s; }
static inline string & strncat(string & s, const char * buffer, size_t bsize) { append(s, buffer, bsize); return s; }

// Repetition
string ?*?(const string & s, size_t factor);
void ?*=?(string & s, size_t factor);
string ?*?(char c, size_t factor);
string ?*?(const char *s, size_t factor);

// Character access
char ?[?](const string & s, size_t index);
string ?[?](string & s, size_t index);  // mutable length-1 slice of original
//char codePointAt(const string & s, size_t index);  // to revisit under Unicode

// Comparisons
int  strcmp (const string &, const string &);
bool ?==?(const string &, const string &);
bool ?!=?(const string &, const string &);
bool ?>? (const string &, const string &);
bool ?>=?(const string &, const string &);
bool ?<=?(const string &, const string &);
bool ?<? (const string &, const string &);

int  strcmp (const string &, const char *);
bool ?==?(const string &, const char *);
bool ?!=?(const string &, const char *);
bool ?>? (const string &, const char *);
bool ?>=?(const string &, const char *);
bool ?<=?(const string &, const char *);
bool ?<? (const string &, const char *);

int  strcmp (const char *, const string &);
bool ?==?(const char *, const string &);
bool ?!=?(const char *, const string &);
bool ?>? (const char *, const string &);
bool ?>=?(const char *, const string &);
bool ?<=?(const char *, const string &);
bool ?<? (const char *, const string &);


// Slicing
string ?()( string & s, size_t start, size_t len );  // TODO const?
string ?()( string & s, size_t start);

// String search
bool contains(const string & s, char ch); // single character

int find(const string & s, char search);
int find(const string & s, const string & search);
int find(const string & s, const char * search);
int find(const string & s, const char * search, size_t searchsize);

int findFrom(const string & s, size_t fromPos, char search);
int findFrom(const string & s, size_t fromPos, const string & search);
int findFrom(const string & s, size_t fromPos, const char * search);
int findFrom(const string & s, size_t fromPos, const char * search, size_t searchsize);

bool includes(const string & s, const string & search);
bool includes(const string & s, const char * search);
bool includes(const string & s, const char * search, size_t searchsize);

bool startsWith(const string & s, const string & prefix);
bool startsWith(const string & s, const char * prefix);
bool startsWith(const string & s, const char * prefix, size_t prefixsize);

bool endsWith(const string & s, const string & suffix);
bool endsWith(const string & s, const char * suffix);
bool endsWith(const string & s, const char * suffix, size_t suffixsize);

// Modifiers
void padStart(string & s, size_t n);
void padStart(string & s, size_t n, char padding);
void padEnd(string & s, size_t n);
void padEnd(string & s, size_t n, char padding);


struct charclass {
    charclass_res * inner;
};

void ?{}( charclass & ) = void;
void ?{}( charclass &, charclass) = void;
charclass ?=?( charclass &, charclass) = void;

void ?{}( charclass &, const string & chars);
void ?{}( charclass &, const char * chars );
void ?{}( charclass &, const char * chars, size_t charssize );
void ^?{}( charclass & );

int include(const string & s, const charclass & mask);

int exclude(const string & s, const charclass & mask);

/*
What to do with?
StrRet include(string & s, const charclass & mask);
StrRet exclude(string & s, const charclass & mask);
*/