123 lines
2.9 KiB
Plaintext
123 lines
2.9 KiB
Plaintext
import vector
|
|
import util
|
|
import mem
|
|
|
|
fun string(in:*char):string {
|
|
var out:string = in
|
|
return out
|
|
}
|
|
|
|
obj string (Object) {
|
|
var data: vector::vector<char>;
|
|
fun construct(): *string {
|
|
data.construct();
|
|
return this;
|
|
}
|
|
fun construct(str: *char): *string {
|
|
data.construct();
|
|
while(*str) {
|
|
data.addEnd(*str);
|
|
str += 1;
|
|
}
|
|
// no null terminator
|
|
return this;
|
|
}
|
|
fun construct(vec: vector::vector<char>): *string {
|
|
data.copy_construct(&vec);
|
|
return this;
|
|
}
|
|
fun construct(str: string): *string {
|
|
return construct(str.data);
|
|
}
|
|
|
|
fun copy_construct(old: *string): void {
|
|
data.copy_construct(&old->data)
|
|
}
|
|
|
|
fun copy_construct(old: **char): void {
|
|
construct(*old)
|
|
}
|
|
|
|
fun operator=(str: *char): void {
|
|
destruct();
|
|
construct(str)
|
|
}
|
|
|
|
fun operator=(str: string): void {
|
|
destruct();
|
|
data.copy_construct(&str.data)
|
|
}
|
|
|
|
fun destruct():void {
|
|
data.destruct()
|
|
}
|
|
|
|
fun operator[](index: int): char { return data[index]; }
|
|
fun slice(first: int, second: int): string {
|
|
var new.construct(data.slice(first,second)): string
|
|
return new
|
|
}
|
|
fun operator[]=(index: int, toSet: char) {
|
|
data[index] = toSet
|
|
}
|
|
fun set(index: int, toSet: char) {
|
|
data.set(index, toSet)
|
|
}
|
|
fun length():int { return data.size; }
|
|
|
|
fun operator==(other: string): bool {
|
|
return length() == other.length() && !util::range(length()).any_true(fun(i: int):bool { return data[i] != other[i]; } )
|
|
}
|
|
|
|
fun operator+(str: *char): string {
|
|
var newStr.construct(str):string
|
|
var ret.construct(data + newStr.data):string
|
|
return ret
|
|
}
|
|
|
|
fun operator+(str: string): string {
|
|
var newStr.construct(str):string
|
|
var ret.construct(data + newStr.data):string
|
|
return ret
|
|
}
|
|
|
|
fun operator+=(character: char): void {
|
|
data += character
|
|
}
|
|
|
|
fun operator+=(str: *char): void {
|
|
var newStr.construct(str):string
|
|
data += newStr.data
|
|
}
|
|
|
|
fun operator+=(str: string): void {
|
|
var newStr.construct(str):string
|
|
data += newStr.data
|
|
}
|
|
|
|
fun toCharArray(): *char {
|
|
var out: *char = mem::new<char>(data.size+1);
|
|
for (var i: int = 0; i < data.size; i++;)
|
|
out[i] = data.get(i);
|
|
// null terminator
|
|
out[data.size] = 0
|
|
return out;
|
|
}
|
|
|
|
fun lines(): vector::vector<string> {
|
|
var out.construct(): vector::vector<string>
|
|
var current = string("")
|
|
for (var i = 0; i < data.size; i++;) {
|
|
if (data[i] == '\n') {
|
|
out.add(current)
|
|
current = string("")
|
|
} else {
|
|
current += data[i]
|
|
}
|
|
}
|
|
out.add(current)
|
|
return out
|
|
}
|
|
};
|
|
|