Onestring

What is Onestring?

Onestring is a multi-sized, Unicode-compatible replacement for std::string. Onestring contains all the basic functions found in std::string while optimizing the use of dynamic allocation wherever possible. To handle Unicode, each Onestring is made of Onechars, which are enhanced characters.

Using a Onestring

Creating a Onestring

You can create a Onestring with characters initialized with the = operator or leave it blank.

// Empty Onestring
Onestring blankString;

// Containing Onechars
Onestring fullString = "these are Unicode Characters";

You can also use the = operator to create a new Onestring with an existing Onestring.

// Create the first Onestring
Onestring firstString = "copy me";

// Containing Onechars
Onestring secondString = firstString;

// secondString now contains "copy me".

Adding to a Onestring

+, +=

The += and + operators add additional Unicode characters at the end of the existing Onestring.

Using +=

//Declare a Onestring
Onestring more = "apple";

// Use += to append an "s"
more += "s";
// `more` is now "apples"

// Use + to append "!"
more = more + "!"
// `more` is now "apples!"

append(), push_back()

Alternatively, you can use the functions append() and push_back() to add additional Unicode characters at the end of the existing Onestring.

Using append()…

// Declare a Onestring
Onestring to_add = "apple";

// Add "s" to `to_add`
to_add.append('s');

// `to_add` is now "apples"

// add "!" to `to_add`
to_add.push_back('!');

// `to_add` is now "apples!"

insert()

insert() allows you to insert a Unicode character into an existing Onestring at a given position.

// Declare a Onestring
Onestring alphabet = "abcdf";

// Insert a value into `alphabet`
// The first value in the function refers to the index to be inserted
// The second value refers to the value to be inserted
alphabet.insert(4, 'E');

// `alphabet` is now "abcdEf"

Removing from a Onestring

clear()

clear() erases the contents of a Onestring.

// Declare a Onestring
Onestring sleeve = "something";

// Clear the contents of `sleeve`
sleeve.clear();

// `sleeve` is now empty

pop_back()

pop_back() removes the last Unicode character in the Onestring

// Declare a Onestring
Onestring alphabet = "abcdef";

// Remove the last element from `alphabet`
alphabet.pop_back();

// `alphabet` is now "abcde"

Accessing Elements of A Onestring

[]

The [] operator acceses a Unicode character at a given location in a Onestring.

// Declare a Onestring
Onestring test = "hello";

// Check what character is at position 1 in `test`
test[1];

// The operator returns 'e'

at()

The at() function can be used as an alternative to [].

// Declare a Onestring
Onestring alphabet = "abcdef";

// Find the Onechar at position 3 in `alphabet`
alphabet.at(3);

// The function returns "d"

Comparing Onestrings

==

The == operator checks for equivalence between two strings and returns a boolean with the result.

// Declare two Onestring
Onestring dogs = "fun";
Onestring cats = "mean";

// Check for equivalence
if (dogs == cats)
{
  return dogs;
}
else
{
  return cats;
}

// This statement would return `cats`

// Reassign `cats`
cats = "fun";

// Check for equivalence
if (dogs == cats)
{
  return dogs;
}
else
{
  return cats;
}

// The statement now returns `dogs`.

equals()

equals() can also be used to check for equality.

// Declare a Onestring
Onestring checker = "red";

// Compare with another Onestring
checker.equals("black");

// The function returns false

// Compare again
checker.equals("red");

// The function returns true

<, >, <=, >=

The <, >, <=, and >= operators compare string sizes, with the first relative to the second. < is less than, > is greater than, and <= and >= are less than or equal to, and greater than or equal to, respectively.

// Delcare three Onestrings
Onestring first = "one";
Onestring second = "two";
Onestring third = "three";

// Compare `first` to `second`
if (first < second)
{
  return first;
}
else
{
  return second;
}

// The statement returns `second`

if (first <= second)
{
  return first;
}
else
{
  return second;
}

// The statement now returns `first`

if (third > second)
{
  return third;
}
else
{
  return second;
}

// Finally, this statement returns `third`

Other Functions

empty()

empty() checks to see if a Onestring is empty. The function returns true if it is empty, and false if it is not.

// Declare a Onestring
Onestring toyBox;

// Check to see if `toybox` empty
toyBox.empty();

// The function returns true

// Assign values to `toyBox`
toyBox = "basketball"

// Check again to see if its empty
toyBox.empty();

// This time, the function returns false.

getType()

getType() returns a boolean that represents either a Onestring or a QuickString.

size()

size() returns the number of characters that make up the Onestring.

// Declare a Onestring
Onestring checker = "red";

// check the size of `checker`
checker.size();

// The function will return 3

substr()

substr() creates a new substring based on a range of characters in an exisiting Onestring

// Declare a Onestring
Onestring full = "monochromatic"

// Declare a new Onestring
// Using `full`
// and substr
Onestring partial = full.substr(0,3);

// The new Onestring `partial` contains the word "mono".
// The numbers in the function call refer to
// the range to be copied into the new string.

swap()

swap() switches the contents of the current Onestring with another. The two Onestrings must be of the same size.

// Declare two Onestrings
Onestring first = "primary";
Onestring second = "secondary";

// Swap `primary` and `secondary`
first.swap(second);

// `first` now reads "secondary".
// `second` now reads "primary"