nephele
/
haiku-website
0
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
haiku-website/static/legacy-docs/bebook/BString.html

560 lines
83 KiB
HTML
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>The Be Book - Classes And Methods - The Support Kit</title><link rel="stylesheet" href="be_book.css" type="text/css" media="all" /><link rel="shortcut icon" type="image/vnd.microsoft.icon" href="./images/favicon.ico" /><!--[if IE]>
<link rel="stylesheet" type="text/css" href="be_book_ie.css" />
<![endif]--><meta name="generator" content="DocBook XSL Stylesheets V1.73.2" /><meta name="keywords" content="Access, BeOS, BeBook, API" /><link rel="start" href="index.html" title="The Be Book" /><link rel="up" href="TheSupportKit.html" title="The Support Kit" /><link rel="prev" href="BStopWatch.html" title="BStopWatch" /><link rel="next" href="TheSupportKit_Functions.html" title="Functions and Macros" /></head><body><div id="header"><div id="headerT"><div id="headerTL"><a accesskey="p" href="BStopWatch.html" title="BStopWatch"><img src="./images/navigation/prev.png" alt="Prev" /></a> <a accesskey="u" href="TheSupportKit.html" title="The Support Kit"><img src="./images/navigation/up.png" alt="Up" /></a> <a accesskey="n" href="TheSupportKit_Functions.html" title="Functions and Macros"><img src="./images/navigation/next.png" alt="Next" /></a></div><div id="headerTR"><div id="navigpeople"><a href="http://www.haiku-os.org"><img src="./images/People_24.png" alt="haiku-os.org" title="Visit The Haiku Website" /></a></div><div class="navighome" title="Home"><a accesskey="h" href="index.html"><img src="./images/navigation/home.png" alt="Home" /></a></div><div class="navigboxed" id="navigindex"><a accesskey="i" href="ClassIndex.html" title="Index">I</a></div><div class="navigboxed" id="naviglang" title="English">en</div></div><div id="headerTC">The Be Book - Classes And Methods - The Support Kit</div></div><div id="headerB">Prev: <a href="BStopWatch.html">BStopWatch</a>  Up: <a href="TheSupportKit.html">The Support Kit</a>  Next: <a href="TheSupportKit_Functions.html">Functions and Macros</a></div><hr /></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h2 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString"></a>BString</h2></div></div></div><a id="id1275253" class="indexterm"></a><div class="classheader"><table border="0"><colgroup><col /><col /></colgroup><tbody><tr><td><table width="100%" border="0"><colgroup><col /><col /></colgroup><tbody><tr><td>Derived From:</td><td>–</td></tr><tr><td>Mix-in Classes:</td><td>–</td></tr><tr><td>Declared In:</td><td><code class="filename">support/String.h</code></td></tr><tr><td>Library:</td><td><code class="filename">libbe.so</code></td></tr><tr><td>Allocation:</td><td>Constructor or on the stack</td></tr></tbody></table></td><td>
<a class="link overview" href="BString_Overview.html" title="BString">Class Overview</a>
<div class="toc"><ul><li><span class="section"><a href="BString.html#BString_ConstructorDestructor">Constructor and Destructor</a></span></li><li><span class="section"><a href="BString.html#BString_MemberFunctions">Member Functions</a></span></li><li><span class="section"><a href="BString.html#BString_Operators">Operators</a></span></li></ul></div>
</td></tr></tbody></table></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><hr /><div xmlns:d="http://docbook.org/ns/docbook"><h3 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_ConstructorDestructor"></a>Constructor and Destructor</h3></div></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Constructor"></a>BString()</h4></div></div></div><div class="synopsisgroup">
<code class="constructorsynopsis cpp"><span class="methodname">BString</span>();</code>
<code class="constructorsynopsis cpp"><span class="methodname">BString</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
<code class="constructorsynopsis cpp"><span class="methodname">BString</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />        <span class="methodparam"><span class="type">int32 </span><span class="parameter">maxLength</span></span>);</code>
<code class="constructorsynopsis cpp"><span class="methodname">BString</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
</div><p>
Creates a new <code class="classname">BString</code> object that allocates enough storage to accommodate
<code class="parameter">string</code> (or
<code class="parameter">string</code>-&gt;<a class="link" href="BString.html#BString_String" title="String(), ByteAt()"><code class="methodname">String()</code></a>,
or up to <code class="parameter">maxLength</code> bytes), and then copies
the string into the storage. Without an argument, the new <code class="classname">BString</code> is
empty. You can also set a <code class="classname">BString</code>'s data by using
<a class="link" href="BString.html#BString_SetTo" title="SetTo(), Adopt()"><code class="methodname">SetTo()</code></a>,
<a class="link" href="BString.html#BString_Adopt"><code class="methodname">Adopt()</code></a>, or
the <a class="link" href="BString.html#BString_Adopt"><code class="methodname">= operator</code></a>.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Destructor"></a>~BString()</h4></div></div></div><code class="destructorsynopsis cpp"><span class="methodname">~BString</span>();</code><p>
Frees the object's allocated memory, and destroys the object.
</p></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><hr /><div xmlns:d="http://docbook.org/ns/docbook"><h3 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_MemberFunctions"></a>Member Functions</h3></div></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Append"></a><a id="BString_Insert"></a>
<a id="BString_Prepend"></a>
Append(), Prepend(), Insert()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">BString&amp; </span><span class="methodname">Append</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Append</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">BString&amp; </span><span class="methodname">Append</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Append</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Append</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Prepend</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Prepend</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Prepend</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Prepend</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Prepend</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Insert</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">insertAt</span></span>);</code>
</div><p>
These functions add characters to the end (append), beginning (prepend),
or middle (insert) of the <code class="classname">BString</code>'s string. In
each case, the <code class="classname">BString</code>
automatically reallocates to accommodate the new data. All of these
functions return *this.
</p><p>
<code class="methodname">Append()</code> copies <code class="parameter">charCount</code>
characters from <code class="parameter">source</code> and adds them to the end
of this <code class="classname">BString</code>. If <code class="parameter">charCount</code>
isn't specified, the entire string is
copied; this is the same as the
<a class="link" href="BString.html#BString_operator_addition_assignment" title="+= (append)"><code class="methodname">+= operator</code></a>.
The single character version
of <code class="methodname">Append()</code> adds <code class="parameter">count</code>
copies of the character <code class="parameter">c</code> to the end of the object.
</p><p>
<code class="methodname">Prepend()</code> does the same as <code class="methodname">Append()</code>,
except it adds the characters to the
beginning of this <code class="classname">BString</code>,
shifting the existing data "to the right" to
make room.
</p><p>
<code class="methodname">Insert()</code> adds the designated characters at
<code class="parameter">insertAt</code> (zero-based) in this
<code class="classname">BString</code>. The <code class="classname">BString</code>'s
existing data (at location <code class="parameter">insertAt</code> and higher) is
shifted right to make room for the new data. The <code class="parameter">sourceOffset</code> argument is
an offset (zero-based) into the source string.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_CharacterEscape"></a><a id="BString_CharacterDeescape"></a>
CharacterEscape(), CharacterDeescape()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CharacterEscape</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">original</span></span>,<br />                         <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">setOfCharsToEscape</span></span>,<br />                         <span class="methodparam"><span class="type">char </span><span class="parameter">escapeWithChar</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CharacterEscape</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">setOfCharsToEscape</span></span>,<br />                         <span class="methodparam"><span class="type">char </span><span class="parameter">escapeWithChar</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CharacterDeescape</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">original</span></span>,<br />                           <span class="methodparam"><span class="type">char </span><span class="parameter">escapeWithChar</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CharacterDeescape</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">escapeWithChar</span></span>);</code>
</div><p>
<code class="methodname">CharacterEscape</code> scans a string for occurrences of the individual
characters in the string <code class="parameter">setOfCharsToEscape</code> and inserts into the string
the byte indicated by <code class="parameter">escapeWithChar</code> before each such occurrence. The
first form copies the original string into the <code class="classname">BString</code>; the second form
operates on the existing <code class="classname">BString</code>.
</p><p>
<code class="methodname">CharacterDeescape()</code> undoes this operation by scanning the string and
removing all occurrences of the byte <code class="parameter">escapeWithChar</code>. The first form
copies the <code class="parameter">original</code> string into the
<code class="classname">BString</code>, while the second form
operates on the existing <code class="classname">BString</code>.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Compare"></a><a id="BString_ICompare"></a>
Compare() , ICompare()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />            <span class="methodparam"><span class="type">int32 </span><span class="parameter">range</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />            <span class="methodparam"><span class="type">int32 </span><span class="parameter">range</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">astring</span></span>,<br />            <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">bstring</span></span>) <span class="modifier">global</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">Compare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString* </span><span class="parameter">astring</span></span>,<br />            <span class="methodparam"><span class="modifier">const </span><span class="type">BString* </span><span class="parameter">bstring</span></span>) <span class="modifier">global</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />             <span class="methodparam"><span class="type">int32 </span><span class="parameter">range</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />             <span class="methodparam"><span class="type">int32 </span><span class="parameter">range</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">astring</span></span>,<br />             <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">bstring</span></span>) <span class="modifier">global</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int </span><span class="methodname">ICompare</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString* </span><span class="parameter">astring</span></span>,<br />             <span class="methodparam"><span class="modifier">const </span><span class="type">BString* </span><span class="parameter">bstring</span></span>) <span class="modifier">global</span>;</code>
</div><p>
These functions compare this <code class="classname">BString</code> with the argument
string (<code class="methodname">Compare()</code>
is case-sensitive, <code class="methodname">ICompare()</code> is case-insensitive); they return 0 if the
two strings are the same, 1 if this <code class="classname">BString</code> is "greater than" the
argument, and -1 if the argument is greater than this <code class="classname">BString</code>. Two
strings are compared by comparing the ASCII or UTF-8 values of their
respective characters. A longer string is greater than a shorter (but
otherwise similar) string—"abcdef" is greater than "abcde".
</p><p>
Given a <code class="parameter">range</code> argument, the functions only compare the first <code class="parameter">range</code>
characters.
</p><p>
The <span class="code">global</span> functions return 0 if the arguments are equal, 1 if
<code class="parameter">astring</code> is
greater than <code class="parameter">bstring</code>, and -1 if <code class="parameter">bstring</code> is greater than <code class="parameter">astring</code>.
</p><p>
You can also compare two strings through the comparison operators ==,
!=, &lt;, &lt;=, &gt;, and &gt;=.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_CopyInto"></a><a id="BString_MoveInto"></a>
CopyInto(), MoveInto()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CopyInto</span>(<span class="methodparam"><span class="type">BString&amp; </span><span class="parameter">destination</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="void">void </span><span class="methodname">CopyInto</span>(<span class="methodparam"><span class="type">char* </span><span class="parameter">destination</span></span>,<br />              <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />              <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">MoveInto</span>(<span class="methodparam"><span class="type">BString&amp; </span><span class="parameter">destination</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="void">void </span><span class="methodname">MoveInto</span>(<span class="methodparam"><span class="type">char* </span><span class="parameter">destination</span></span>,<br />              <span class="methodparam"><span class="type">int32 </span><span class="parameter">sourceOffset</span></span>,<br />              <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
</div><p>
<code class="methodname">CopyInto()</code> copies a substring from this
<code class="classname">BString</code> into <code class="parameter">destination</code>.
<code class="methodname">MoveTo()</code> does the same, but it removes the original substring (from this
<code class="classname">BString</code>). If <code class="parameter">destination</code> is a
<code class="classname">BString</code>, storage for the substring is
automatically allocated; if the <code class="parameter">destination</code> is a <span class="type">char*</span>, the caller is
responsible for allocating sufficient storage.
</p><p>
The substring comprises <code class="parameter">charCount</code> characters starting at character
<code class="parameter">sourceOffset</code> (zero-based). After the substring is removed, the remaining
characters move (to the left) to fill in the gap (<code class="methodname">MoveTo()</code> only). For
example:
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">source</code>, <code class="varname">destination</code>;
<code class="varname">source</code>.<code class="methodname">SetTo</code>("abcdefg");
<code class="varname">source</code>.<code class="methodname">MoveInto</code>(&amp;<code class="varname">destination</code>, 2, 3);
<span class="comment">/* source.String() == "abfg" */</span>
<span class="comment">/* destination.String() == "cde" */</span></pre><p>
The functions return destination (or <span class="type">void</span>).
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_CountChars"></a><a id="BString_Length"></a>
CountChars(), Length()</h4></div></div></div><code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">CountChars</span>() <span class="modifier">const</span>;</code><code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">int32 </span><span class="methodname">Length</span>() <span class="modifier">const</span>;</code><p>
<code class="methodname">CountChars()</code> returns the length of the object's string measured in
characters; <code class="methodname">Length()</code> returns the length measured in bytes.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_FindFirst"></a><a id="BString_IFindFirst"></a>
<a id="BString_FindLast"></a>
<a id="BString_IFindLast"></a>
FindFirst(), IFindFirst(), FindLast(), IFindLast()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindFirst</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">FindLast</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">int32 </span><span class="methodname">IFindLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span></span>) <span class="modifier">const</span>;</code>
</div><p>
These functions return the index of the first or last occurrence (within
this <code class="classname">BString</code>) of a substring or character.
<code class="methodname">FindFirst()</code> and <code class="methodname">FindLast()</code> are
case-sensitive; <code class="methodname">IFindFirst()</code> and <code class="methodname">IFindLast()</code> are case-insensitive. The
functions return <code class="constant">B_ERROR</code> if the character isn't found.
</p><p>
The <code class="parameter">offset</code> versions only look in the portion of this
<code class="classname">BString</code> that starts at character
<code class="parameter">offset</code> (for
<code class="methodname">[I]FindFirst()</code>), or that ends at character
<code class="parameter">offset</code> (for <code class="methodname">[I]FindLast()</code>).
For example, in this example…
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">astring</code>("AbcAbcAbc");
<code class="varname">astring</code>.<code class="methodname">FindLast</code>("Abc", 7);</pre><p>
…the <code class="methodname">FindLast()</code> call returns 3, the index of the last complete instance
of "Abc" that occurs before character 7.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_LockBuffer"></a><a id="BString_UnlockBuffer"></a>
LockBuffer(), UnlockBuffer()</h4></div></div></div><code class="methodsynopsis cpp"><span class="type">char* </span><span class="methodname">LockBuffer</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">maxLength</span></span>);</code><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">UnlockBuffer</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">length</span><span class="initializer"> = -1</span></span>);</code><p>
<code class="methodname">LockBuffer()</code> returns a pointer to the object's string; you're allowed to
manipulate this pointer directly. The <code class="parameter">maxLength</code> argument lets you ask the
object to allocate some extra space at the end of the string before
passing you the pointer. If <code class="parameter">maxLength</code> is less than the string's current
length, the argument is ignored (pass 0 if you want to lock the buffer
but don't need to pre-allocate extra space).
</p><p>
<code class="methodname">UnlockBuffer()</code> tells the object that you're done manipulating the string
pointer. <code class="parameter">length</code> is the string's new length; if you pass -1, the <code class="classname">BString</code>
gets the length by calling <code class="function">strlen()</code> on the string. The functions returns
<span class="code">*this</span>.
</p><p>
Every <code class="methodname">LockBuffer()</code> must be balanced by a
subsequent <code class="methodname">UnlockBuffer()</code>. In
between the two calls, you may not call any <code class="classname">BString</code> functions. Many of
the <code class="classname">BString</code> functions assert an error if they're called while the buffer
is locked.
</p><p>
See "Direct Data Access" for an example.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Remove"></a><a id="BString_RemoveFirst"></a>
<a id="BString_RemoveLast"></a>
<a id="BString_RemoveAll"></a>
<a id="BString_RemoveSet"></a>
Remove(), RemoveFirst(), RemoveLast(), RemoveAll() , RemoveSet()</h4></div></div></div><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Remove</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">startingAt</span></span>,<br />                <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveAll</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveAll</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
</div><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">RemoveSet</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">charSet</span></span>);</code><p>
These functions remove characters from the <code class="classname">BString</code> and reallocate the
object's storage so it fits the new (smaller) data. The functions return
<span class="code">*this</span>.
</p><p>
<code class="methodname">Remove()</code> removes <code class="parameter">charCount</code>
characters, starting with character <code class="parameter">startingAt</code>
(zero-based).
</p><p>
<code class="methodname">RemoveFirst()</code>, <code class="methodname">RemoveLast()</code>,
and <code class="methodname">RemoveAll()</code> remove, respectively, the
first, last and every occurrence of string within the object.
</p><p>
<code class="methodname">RemoveSet()</code> removes all occurrences of every
character in the <code class="parameter">charSet</code>
string. For example:
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">string</code>("ab abc abcd");
<code class="varname">string</code>.<code class="methodname">RemoveSet</code>("db");
<span class="comment">/* 'string' now contains "a ac ac" */</span></pre></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Replace"></a><a id="BString_ReplaceFirst"></a>
<a id="BString_ReplaceLast"></a>
<a id="BString_ReplaceSet"></a>
<a id="BString_IReplace"></a>
<a id="BString_IReplaceFirst"></a>
<a id="BString_IReplaceLast"></a>
Replace(), ReplaceFirst(), ReplaceLast(), ReplaceSet(), IReplace() ,
IReplaceFirst(), IReplaceLast(), IReplaceAll()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Replace</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                 <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">count</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Replace</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                 <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">count</span></span>,<br />                 <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                      <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceFirst</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                      <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                     <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceLast</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                     <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceAll</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                    <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>,<br />                    <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceAll</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                    <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>,<br />                    <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceSet</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">oldSet</span></span>,<br />                    <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ReplaceSet</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">oldSet</span></span>,<br />                    <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplace</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                  <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">count</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplace</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                  <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">count</span></span>,<br />                  <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceFirst</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                       <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceFirst</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                       <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceLast</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                      <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceLast</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                      <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceAll</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">old</span></span>,<br />                     <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>,<br />                     <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceAll</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">old</span></span>,<br />                     <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>,<br />                     <span class="methodparam"><span class="type">int32 </span><span class="parameter">offset</span><span class="initializer"> = 0</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceSet</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">oldSet</span></span>,<br />                     <span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">new</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">IReplaceSet</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">oldSet</span></span>,<br />                     <span class="methodparam"><span class="type">char </span><span class="parameter">new</span></span>);</code>
</div><p>
These functions find occurrences of <code class="parameter">old</code>
within the <code class="classname">BString</code>, and replace
them with <code class="parameter">new</code>. In the <code class="methodname">Replace…()</code>
functions, the search for <code class="parameter">old</code> is
case-insensitive; in the <code class="methodname">IReplace…()</code> functions, the search is
case-insensitive. The functions return <span class="code">*this</span>.
</p><p>
<code class="methodname">[I]Replace()</code> replaces the first
<code class="parameter">count</code> occurrences that start on or after
the character at <code class="parameter">offset</code>.
</p><p>
<code class="methodname">[I]ReplaceFirst()</code> and <code class="methodname">[I]ReplaceLast()</code>
replace only the first and last
occurrence (respectively).
</p><p>
<code class="methodname">[I]ReplaceAll()</code> replaces all occurrence that start on or after the
character at <code class="parameter">offset</code>.
</p><p>
<code class="methodname">[I]ReplaceSet()</code> is slightly different from the others: It replaces each
occurrence of any character in <code class="parameter">oldSet</code> with the character or the entire
string given by new. For example:
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">astring</code>("a-b-c");
<code class="varname">astring</code>.<code class="methodname">ReplaceSet</code>("abc", "ABC");
<span class="comment">/* astring is now "ABC-ABC-ABC" */</span></pre></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_SetTo"></a><a id="BString_Adopt"></a>
SetTo(), Adopt()</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">BString&amp; </span><span class="methodname">SetTo</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">SetTo</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">source</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">SetTo</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">SetTo</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">SetTo</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Adopt</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Adopt</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">source</span></span>,<br />               <span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>);</code>
</div><p>
These functions initialize a <code class="classname">BString</code>'s string data. Storage for the data
is automatically allocated by the functions. The object's current data is
wholly replaced by the new data. The functions return <span class="code">*this</span>.
</p><p>
<code class="methodname">SetTo()</code> copies <code class="parameter">charCount</code>
characters from <code class="parameter">source</code> into this object. If
<code class="parameter">charCount</code> isn't given, the entire string is copied; this form is
equivalent to the = operator. The single character version of <code class="methodname">SetTo()</code>
sets the object's data to a <code class="parameter">charCount</code>-length string that consists
entirely of the character <code class="parameter">c</code>.
</p><p>
<code class="methodname">Adopt()</code> moves <code class="parameter">charCount</code>
characters from <code class="parameter">source</code> into this object, and then
clears <code class="parameter">source</code>'s data (pointer). Note that source will be empty after you
call <code class="methodname">Adopt()</code>, even if <code class="parameter">charCount</code>
is less than source's full length.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_String"></a><a id="BString_ByteAt"></a>
String(), ByteAt()</h4></div></div></div><code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="modifier">const </span><span class="type">char* </span><span class="methodname">String</span>() <span class="modifier">const</span>;</code><code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">char </span><span class="methodname">ByteAt</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">index</span></span>) <span class="modifier">const</span>;</code><p>
<code class="methodname">String()</code> returns a pointer to the object's
string, guaranteed to be <code class="constant">NULL</code>
terminated. You may not modify or free the pointer. If the <code class="classname">BString</code> is
deleted, the pointer becomes invalid.
</p><p>
<code class="methodname">ByteAt()</code> returns the <code class="parameter">index</code>'th
character in the string. If <code class="parameter">index</code> is out of
bounds, the function returns 0. Except for the boundary check, this
function is the same as the [] operator.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_ToLower"></a><a id="BString_ToUpper"></a>
<a id="BString_Capitalize"></a>
<a id="BString_CapitalizeEachWord"></a>
ToLower(), ToUpper(), Capitalize(), CapitalizeEachWord()</h4></div></div></div><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ToLower</span>();</code><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">ToUpper</span>();</code><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Capitalize</span>();</code><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">CapitalizeEachWord</span>();</code><p>
<code class="methodname">ToLower()</code> converts every character in the string to lower case;
<code class="methodname">ToUpper()</code>
converts them all to upper case. Non-alphabetic characters aren't
affected.
</p><p>
<code class="methodname">Capitalize()</code> converts the first alphabetic character in the word to upper
case, and the rest to lower case. <code class="methodname">CapitalizeEachWord()</code> converts the first
alphabetic character in each "word" to upper case, and the rest to lower
case. A word is a group of alphabetic characters delimited by
non-alphabetic characters.
</p><p>
The functions return <span class="code">*this</span>.
</p><div class="admonition warning"><div class="title">Warning</div><div class="graphic"><img class="icon" alt="Warning" width="32" src="./images/admonitions/Stop_32.png" /><div class="text"><p><code class="methodname">Capitalize()</code> and
<code class="methodname">CapitalizeEachWord()</code> are broken in Release 4.0.</p></div></div></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Truncate"></a>Truncate()</h4></div></div></div><code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">Truncate</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">charCount</span></span>,<br />                  <span class="methodparam"><span class="type">bool </span><span class="parameter">lazy</span><span class="initializer"> = <span class="constant">true</span></span></span>);</code><p>
<code class="methodname">Truncate()</code> shrinks the object's string so
that it's <code class="parameter">charCount</code> characters
long. This function will not lengthen the string: If <code class="parameter">charCount</code> is equal
to or greater than the string's current character count, the function
does nothing.
</p><p>
If <code class="parameter">lazy</code> is <code class="constant">false</code>, the string
is immediately reallocated to trim it to the
new size (and the excess is immediately freed). If it's <code class="constant">true</code>, the string
is set to the new size, but the excess isn't freed until the next storage
manipulating function is called. It's slightly more efficient to be lazy;
otherwise, the two forms of the function are identical.
</p><p>
The function return <span class="code">*this</span>.
</p></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><hr /><div xmlns:d="http://docbook.org/ns/docbook"><h3 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_Operators"></a>Operators</h3></div></div></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_operator_assignment"></a>= (assignment)</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char </span><span class="parameter">character</span></span>);</code>
</div><p>
Sets the contents of the <code class="classname">BString</code> to
<code class="parameter">string</code> or <code class="parameter">character</code>, and returns
<span class="code">*this-&gt;<a class="link" href="BString.html#BString_LockBuffer" title="LockBuffer(), UnlockBuffer()"><code class="methodname">LockBuffer()</code></a></span>.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_operator_addition_assignment"></a>+= (append)</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">BString&amp; </span><span class="methodname">operator+=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator+=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator+=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char </span><span class="parameter">character</span></span>);</code>
</div><p>
Appends <code class="parameter">string</code> or <code class="parameter">character</code>
to this <code class="classname">BString</code>, and returns <span class="code">*this</span>.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_operator_formatted_append"></a>&lt;&lt; (formatted append)</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">char </span><span class="parameter">c</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">uint32 </span><span class="parameter">val</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">val</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">uint64 </span><span class="parameter">val</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">int64 </span><span class="parameter">val</span></span>);</code>
<code class="methodsynopsis cpp"><span class="type">BString&amp; </span><span class="methodname">operator&lt;&lt;</span>(<span class="methodparam"><span class="type">float </span><span class="parameter">val</span></span>);</code>
</div><p>
Converts the right operand to a string (if necessary), and appends it to
the left operand. Floating point values are always written with two
decimal digits:
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">astring</code>("The result is: "), <code class="varname">bstring</code>(" bps");
<span class="type">float</span> <code class="varname">result</code> = 12.5;
<code class="varname">astring</code> &lt;&lt; result &lt;&lt; <code class="varname">bstring</code>;</pre><p>
Here, <code class="varname">astring</code> becomes "The result is: 12.50 bps".
</p><p>
Multiple append operations are evaluated from left to right, so that only
the leftmost operand is modified. For example:
</p><pre class="programlisting example cpp"><code class="classname">BString</code> <code class="varname">astring</code>("a"), <code class="varname">bstring</code>("b"), <code class="varname">cstring</code>("c");
<code class="varname">astring</code> &lt;&lt; <code class="varname">bstring</code> &lt;&lt; <code class="varname">cstring</code>;</pre><p>
Here, <code class="varname">bstring</code> is appended to <code class="varname">astring</code>,
and then <code class="varname">cstring</code> is appended to the
result; thus, <code class="varname">astring</code> is "abc", and
<code class="varname">bstring</code> is still "b".
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_operator_indexing"></a>[] (indexing)</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="type">char </span><span class="methodname">operator[]</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">index</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">char&amp; </span><span class="methodname">operator[]</span>(<span class="methodparam"><span class="type">int32 </span><span class="parameter">index</span></span>);</code>
</div><p>
Returns the character at <code class="parameter">index</code> in the string. No boundary checking is
done—it's up to the caller to ensure that <code class="parameter">index</code> is in
bounds.
</p></div><div class="section"><div xmlns="" xmlns:d="http://docbook.org/ns/docbook" class="titlepage"><div><div xmlns:d="http://docbook.org/ns/docbook"><h4 xmlns="http://www.w3.org/1999/xhtml" class="title"><a id="BString_operator_equality"></a><a id="BString_operator_inequality"></a>
<a id="BString_operator_less_than"></a>
<a id="BString_operator_greater_than"></a>
<a id="BString_operator_less_than_or_equals"></a>
<a id="BString_operator_greater_than_or_equals"></a>
==, !=, &lt;, &gt;, &lt;=, &gt;= (comparison)</h4></div></div></div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator==</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">bool </span><span class="methodname">operator==</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">global </span><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator==</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                              <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator!=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator!=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">global </span><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator!=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                              <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&lt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">bool </span><span class="methodname">operator&lt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">global </span><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&lt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                             <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
</div><div class="synopsisgroup">
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&gt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">bool </span><span class="methodname">operator&gt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">global </span><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&gt;</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                             <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&gt;=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="type">bool </span><span class="methodname">operator&gt;=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
<code class="methodsynopsis cpp"><span class="modifier">global </span><span class="modifier">inline </span><span class="type">bool </span><span class="methodname">operator&gt;=</span>(<span class="methodparam"><span class="modifier">const </span><span class="type">char* </span><span class="parameter">string</span></span>,<br />                              <span class="methodparam"><span class="modifier">const </span><span class="type">BString&amp; </span><span class="parameter">string</span></span>) <span class="modifier">const</span>;</code>
</div><p>
Case-sensitive comparison of two strings. Two strings are compared by
comparing the ASCII or UTF-8 values of their respective characters. A
longer string is greater than a shorter (but otherwise similar)
string—"abcdef" is greater than "abcde".
</p><p>
The global versions of these operators are provided so you don't have to
worry about the order of the operands; for example:
</p><pre class="programlisting example cpp">if (<code class="varname">astring</code> == "Okay")
<span class="comment">/* ...is equivalent to... */</span>
if ("Okay" == <code class="varname">astring</code>)</pre></div></div></div><div id="footer"><hr /><div id="footerT">Prev: <a href="BStopWatch.html">BStopWatch</a>  Up: <a href="TheSupportKit.html">The Support Kit</a>  Next: <a href="TheSupportKit_Functions.html">Functions and Macros</a> </div><div id="footerB"><div id="footerBL"><a href="BStopWatch.html" title="BStopWatch"><img src="./images/navigation/prev.png" alt="Prev" /></a> <a href="TheSupportKit.html" title="The Support Kit"><img src="./images/navigation/up.png" alt="Up" /></a> <a href="TheSupportKit_Functions.html" title="Functions and Macros"><img src="./images/navigation/next.png" alt="Next" /></a></div><div id="footerBR"><div><a href="http://www.haiku-os.org"><img src="./images/People_24.png" alt="haiku-os.org" title="Visit The Haiku Website" /></a></div><div class="navighome" title="Home"><a accesskey="h" href="index.html"><img src="./images/navigation/home.png" alt="Home" /></a></div></div><div id="footerBC"><a href="http://www.access-company.com/home.html" title="ACCESS Co."><img alt="Access Company" src="./images/access_logo.png" /></a></div></div></div><div id="licenseFooter"><div id="licenseFooterBL"><a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/" title="Creative Commons License"><img alt="Creative Commons License" style="border-width:0" src="https://licensebuttons.net/l/by-nc-nd/3.0/88x31.png" /></a></div><div id="licenseFooterBR"><a href="./LegalNotice.html">Legal Notice</a></div><div id="licenseFooterBC"><span id="licenseText">This work is licensed under a
<a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/">Creative
Commons Attribution-Non commercial-No Derivative Works 3.0 License</a>.</span></div></div></body></html>
Reference in New Issue View Git Blame Copy Permalink