aboutsummaryrefslogtreecommitdiffstats
path: root/Documentation
diff options
context:
space:
mode:
authorIvan Enderlin <ivan.enderlin@hoa-project.net>2015-05-29 12:24:23 +0200
committerIvan Enderlin <ivan.enderlin@hoa-project.net>2015-05-29 12:24:23 +0200
commit0278566a5fc6c26d9ef114ed18c2705a73e8635a (patch)
tree6e6ec677dd7bba40f7861c1cb348e9f8de3f87bd /Documentation
parentcedbbdb85a5897e48e276ada329242d48dd719d9 (diff)
downloadUstring-0278566a5fc6c26d9ef114ed18c2705a73e8635a.zip
Ustring-0278566a5fc6c26d9ef114ed18c2705a73e8635a.tar.gz
Ustring-0278566a5fc6c26d9ef114ed18c2705a73e8635a.tar.bz2
Rename `Hoa\String` to `Hoa\Ustring`.
Quoting https://github.com/php/php-src/blob/7dcfdbbee4/UPGRADING#L378-L387: > It is no longer possible to use the following class, interface and trait names > (case-insensitive): > > * bool > * int > * float > * string > * null > * false > * true
Diffstat (limited to 'Documentation')
-rw-r--r--Documentation/En/Index.xyl177
-rw-r--r--Documentation/Fr/Index.xyl164
2 files changed, 172 insertions, 169 deletions
diff --git a/Documentation/En/Index.xyl b/Documentation/En/Index.xyl
index 72182ac..217c852 100644
--- a/Documentation/En/Index.xyl
+++ b/Documentation/En/Index.xyl
@@ -4,7 +4,7 @@
<yield id="chapter">
<p>Strings can sometimes be <strong>complex</strong>, especially when they use
- the <code>Unicode</code> encoding format. The <code>Hoa\String</code> library
+ the <code>Unicode</code> encoding format. The <code>Hoa\Ustring</code> library
provides several operations on UTF-8 strings.</p>
<h2 id="Table_of_contents">Table of contents</h2>
@@ -26,7 +26,7 @@
Unicode. Unfortunately, sometimes we have to mix these extensions to achieve
our aims and at the cost of a certain <strong>complexity</strong> along with
a regrettable <strong>verbosity</strong>.</p>
- <p>The <code>Hoa\String</code> library answers to these issues by providing a
+ <p>The <code>Hoa\Ustring</code> library answers to these issues by providing a
<strong>simple</strong> way to manipulate strings with
<strong>performance</strong> and <strong>efficiency</strong> in minds. It
also provides some evoluated algorithms to perform <strong>search</strong>
@@ -34,7 +34,7 @@
<h2 id="Unicode_strings" for="main-toc">Unicode strings</h2>
- <p>The <code>Hoa\String\String</code> class represents a
+ <p>The <code>Hoa\Ustring\Ustring</code> class represents a
<strong>UTF-8</strong> Unicode strings and allows to manipulate it easily.
This class implements the
<a href="http://php.net/arrayaccess"><code>ArrayAccess</code></a>,
@@ -42,9 +42,9 @@
<a href="http://php.net/iteratoraggregate"><code>IteratorAggregate</code></a>
interfaces. We are going to use three examples in three different languages:
French, Arab and Japanese. Thus:</p>
- <pre><code class="language-php">$french = new Hoa\String\String('Je t\'aime');
-$arabic = new Hoa\String\String('أحبك');
-$japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
+ <pre><code class="language-php">$french = new Hoa\Ustring\Ustring('Je t\'aime');
+$arabic = new Hoa\Ustring\Ustring('أحبك');
+$japanese = new Hoa\Ustring\Ustring('私はあなたを愛して');</code></pre>
<p>Now, let's see what we can do on these three strings.</p>
<h3 id="String_manipulation" for="main-toc">String manipulation</h3>
@@ -68,19 +68,19 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
right or the left, but rather about a <strong>beginning</strong> or an
<strong>end</strong>, and based on the <strong>direction</strong> of writing.
We can know this direction thanks to the
- <code>Hoa\String\String::getDirection</code> method. It returns the value of
+ <code>Hoa\Ustring\Ustring::getDirection</code> method. It returns the value of
one of the following constants:</p>
<ul>
- <li><code>Hoa\String\String::LTR</code>, for left-to-right, if the text is
+ <li><code>Hoa\Ustring\Ustring::LTR</code>, for left-to-right, if the text is
written from the left to the right,</li>
- <li><code>Hoa\String\String::RTL</code>, for right-to-left, if the text is
+ <li><code>Hoa\Ustring\Ustring::RTL</code>, for right-to-left, if the text is
written from the right to the left.</li>
</ul>
<p>Let's observe the result with our examples:</p>
<pre><code class="language-php">var_dump(
- $french->getDirection() === Hoa\String\String::LTR, // is left-to-right?
- $arabic->getDirection() === Hoa\String\String::RTL, // is right-to-left?
- $japanese->getDirection() === Hoa\String\String::LTR // is left-to-right?
+ $french->getDirection() === Hoa\Ustring\Ustring::LTR, // is left-to-right?
+ $arabic->getDirection() === Hoa\Ustring\Ustring::RTL, // is right-to-left?
+ $japanese->getDirection() === Hoa\Ustring\Ustring::LTR // is left-to-right?
);
/**
@@ -90,12 +90,12 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
* bool(true)
*/</code></pre>
<p>The result of this method is computed thanks to the
- <code>Hoa\String\String::getCharDirection</code> static method which computes
+ <code>Hoa\Ustring\Ustring::getCharDirection</code> static method which computes
the direction of only one character.</p>
<p>If we would like to <strong>concatenate</strong> another string to the end
or to the beginning, we will respectively use the
- <code>Hoa\String\String::append</code> and
- <code>Hoa\String\String::prepend</code> methods. These methods, like most of
+ <code>Hoa\Ustring\Ustring::append</code> and
+ <code>Hoa\Ustring\Ustring::prepend</code> methods. These methods, like most of
the ones which modifies the string, return the object itself, in order to
chain the calls. For instance:</p>
<pre><code class="language-php">echo $french->append('… et toi, m\'aimes-tu ?')->prepend('Mam\'zelle ! ');
@@ -104,9 +104,9 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
* Will output:
* Mam'zelle ! Je t'aime… et toi, m'aimes-tu ?
*/</code></pre>
- <p>We also have the <code>Hoa\String\String::toLowerCase</code> and
- <code>Hoa\String\String::toUpperCase</code> methods to, respectively, set the
- case of the string to lower or upper. For instance:</p>
+ <p>We also have the <code>Hoa\Ustring\Ustring::toLowerCase</code> and
+ <code>Hoa\Ustring\Ustring::toUpperCase</code> methods to, respectively, set
+ the case of the string to lower or upper. For instance:</p>
<pre><code class="language-php">echo $french->toUpperCase();
/**
@@ -116,11 +116,11 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
<p>We can also add characters to the beginning or to the end of the string to
reach a <strong>minimum</strong> length. This operation is frequently called
the <em>padding</em> (for historical reasons dating back to typewriters).
- That's why we have the <code>Hoa\String\String::pad</code> method which takes
- three arguments: the minimum length, characters to add and a constant
+ That's why we have the <code>Hoa\Ustring\Ustring::pad</code> method which
+ takes three arguments: the minimum length, characters to add and a constant
indicating whether we have to add at the end or at the beginning of the string
- (respectively <code>Hoa\String\String::END</code>, by default, and
- <code>Hoa\String\String::BEGINNING</code>).</p>
+ (respectively <code>Hoa\Ustring\Ustring::END</code>, by default, and
+ <code>Hoa\Ustring\Ustring::BEGINNING</code>).</p>
<pre><code class="language-php">echo $arabic->pad(20, ' ');
/**
@@ -129,7 +129,7 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
*/</code></pre>
<p>A similar operation allows to remove, by default, <strong>spaces</strong>
at the beginning and at the end of the string thanks to the
- <code>Hoa\String\String::trim</code> method. For example, to retreive our
+ <code>Hoa\Ustring\Ustring::trim</code> method. For example, to retreive our
original Arabic string:</p>
<pre><code class="language-php">echo $arabic->trim();
@@ -140,22 +140,23 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
<p>If we would like to remove other characters, we can use its first argument
which must be a regular expression. Finally, its second argument allows to
specify from what side we would like to remove character: at the beginning, at
- the end or both, still by using the <code>Hoa\String\String::BEGINNING</code>
- and <code>Hoa\String\String::END</code> constants.</p>
+ the end or both, still by using the
+ <code>Hoa\Ustring\Ustring::BEGINNING</code> and
+ <code>Hoa\Ustring\Ustring::END</code> constants.</p>
<p>If we would like to remove other characters, we can use its first argument
which must be a regular expression. Finally, its second argument allows to
specify the side where to remove characters: at the beginning, at the end or
- both, still by using the <code>Hoa\String\String::BEGINNING</code> and
- <code>Hoa\String\String::END</code> constants. We can combine these constants
- to express “both sides”, which is the default value:
- <code class="language-php">Hoa\String\String::BEGINNING |
- Hoa\String\String::END</code>. For example, to remove all the numbers and the
- spaces only at the end, we will write:</p>
- <pre><code class="language-php">$arabic->trim('\s|\d', Hoa\String\String::END);</code></pre>
+ both, still by using the <code>Hoa\Ustring\Ustring::BEGINNING</code> and
+ <code>Hoa\Ustring\Ustring::END</code> constants. We can combine these
+ constants to express “both sides”, which is the default value:
+ <code class="language-php">Hoa\Ustring\Ustring::BEGINNING |
+ Hoa\Ustring\Ustring::END</code>. For example, to remove all the numbers and
+ the spaces only at the end, we will write:</p>
+ <pre><code class="language-php">$arabic->trim('\s|\d', Hoa\Ustring\Ustring::END);</code></pre>
<p>We can also <strong>reduce</strong> the string to a
<strong>sub-string</strong> by specifying the position of the first character
followed by the length of the sub-string to the
- <code>Hoa\String\String::reduce</code> method:</p>
+ <code>Hoa\Ustring\Ustring::reduce</code> method:</p>
<pre><code class="language-php">echo $french->reduce(3, 6)->reduce(2, 4);
/**
@@ -193,7 +194,7 @@ echo $french;
<p>Another very useful method is the <strong>ASCII</strong> transformation.
Be careful, this is not always possible, according to your settings. For
example:</p>
- <pre><code class="language-php">$title = new Hoa\String\String('Un été brûlant sur la côte');
+ <pre><code class="language-php">$title = new Hoa\Ustring\Ustring('Un été brûlant sur la côte');
echo $title->toAscii();
/**
@@ -202,8 +203,8 @@ echo $title->toAscii();
*/</code></pre>
<p>We can also transform from Arabic or Japanese to ASCII. Symbols, like
Mathemeticals symbols or emojis, are also transformed:</p>
- <pre><code class="language-php">$emoji = new Hoa\String\String('I ❤ Unicode');
-$maths = new Hoa\String\String('∀ i ∈ ℕ');
+ <pre><code class="language-php">$emoji = new Hoa\Ustring\Ustring('I ❤ Unicode');
+$maths = new Hoa\Ustring\Ustring('∀ i ∈ ℕ');
echo
$arabic->toAscii(), "\n",
@@ -225,10 +226,10 @@ echo
is present. If it does not exist, the
<a href="http://php.net/normalizer"><code>Normalizer</code></a> class must
exist. If this class does not exist neither, the
- <code>Hoa\String\String::toAscii</code> method can still try a transformation,
- but it is less efficient. To activate this last solution, <code>true</code>
- must be passed as a single argument. This <em lang="fr">tour de force</em> is
- not recommended in most cases.</p>
+ <code>Hoa\Ustring\Ustring::toAscii</code> method can still try a
+ transformation, but it is less efficient. To activate this last solution,
+ <code>true</code> must be passed as a single argument. This <em lang="fr">tour
+ de force</em> is not recommended in most cases.</p>
<p>We also find the <code>getTransliterator</code> method which returns a
<code>Transliterator</code> object, or <code>null</code> if this class does
not exist. This method takes a transliteration identifier as argument. We
@@ -240,18 +241,18 @@ echo
<a href="http://php.net/transliterator.transliterate"><code>Transliterator::transliterate</code></a>
method.</p>
<p>More generally, to change the <strong>encoding</strong> format, we can use
- the <code>Hoa\String\String::transcode</code> static method, with a string as
- first argument, the original encoding format as second argument and the
+ the <code>Hoa\Ustring\Ustring::transcode</code> static method, with a string
+ as first argument, the original encoding format as second argument and the
expected encoding format as third argument (UTF-8 by default). The get the
list of encoding formats, we have to refer to the
<a href="http://php.net/iconv"><code>iconv</code></a> extension or to use the
following command line in a terminal:</p>
<pre><code class="language-php">$ iconv --list</code></pre>
<p>To know if a string is encoded in UTF-8, we can use the
- <code>Hoa\String\String::isUtf8</code> static method; for instance:</p>
+ <code>Hoa\Ustring\Ustring::isUtf8</code> static method; for instance:</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::isUtf8('a'),
- Hoa\String\String::isUtf8(Hoa\String\String::transcode('a', 'UTF-8', 'UTF-16'))
+ Hoa\Ustring\Ustring::isUtf8('a'),
+ Hoa\Ustring\Ustring::isUtf8(Hoa\Ustring\Ustring::transcode('a', 'UTF-8', 'UTF-16'))
);
/**
@@ -260,8 +261,8 @@ echo
* bool(false)
*/</code></pre>
<p>We can <strong>split</strong> the string into several sub-strings by using
- the <code>Hoa\String\String::split</code> method. As first argument, we have a
- regular expression (of kind <a href="http://pcre.org/">PCRE</a>), then an
+ the <code>Hoa\Ustring\Ustring::split</code> method. As first argument, we have
+ a regular expression (of kind <a href="http://pcre.org/">PCRE</a>), then an
integer representing the maximum number of elements to return and finally a
combination of constants. These constants are the same as the ones of
<a href="http://php.net/preg_split"><code>preg_split</code></a>.</p>
@@ -285,7 +286,7 @@ echo
<p>If we would like to <strong>iterate</strong> over all the
<strong>characters</strong>, it is recommended to use the
<code>IteratorAggregate</code> method, being the
- <code>Hoa\String\String::getIterator</code> method. Let's see on the Arabic
+ <code>Hoa\Ustring\Ustring::getIterator</code> method. Let's see on the Arabic
example:</p>
<pre><code class="language-php">foreach ($arabic as $letter) {
echo $letter, "\n";
@@ -320,8 +321,8 @@ echo
<h3 id="Comparison_and_search" for="main-toc">Comparison and search</h3>
<p>Strings can also be <strong>compared</strong> thanks to the
- <code>Hoa\String\String::compare</code> method:</p>
- <pre><code class="language-php">$string = new Hoa\String\String('abc');
+ <code>Hoa\Ustring\Ustring::compare</code> method:</p>
+ <pre><code class="language-php">$string = new Hoa\Ustring\Ustring('abc');
var_dump(
$string->compare('wxyz')
);
@@ -333,13 +334,13 @@ var_dump(
<p>This methods returns -1 if the initial string comes before (in the
alphabetical order), 0 if it is identical and 1 if it comes after. If we
would like to use all the power of the underlying mechanism, we can call the
- <code>Hoa\String\String::getCollator</code> static method (if the
+ <code>Hoa\Ustring\Ustring::getCollator</code> static method (if the
<a href="http://php.net/Collator"><code>Collator</code></a> class exists, else
- <code>Hoa\String\String::compare</code> will use a simple byte to bytes
+ <code>Hoa\Ustring\Ustring::compare</code> will use a simple byte to bytes
comparison without taking care of the other parameters). Thus, if we would
like to sort an array of strings, we will write:</p>
<pre><code class="language-php">$strings = array('c', 'Σ', 'd', 'x', 'α', 'a');
-Hoa\String\String::getCollator()->sort($strings);
+Hoa\Ustring\Ustring::getCollator()->sort($strings);
print_r($strings);
/**
@@ -358,10 +359,10 @@ print_r($strings);
means of the localization of the system, like the language, the country, the
region etc. We can use the
<a href="@hack:chapter=Locale"><code>Hoa\Locale</code> library</a> to modify
- these data, but it's not a dependence of <code>Hoa\String</code>.</p>
+ these data, but it's not a dependence of <code>Hoa\Ustring</code>.</p>
<p>We can also know if a string <strong>matches</strong> a certain pattern,
still expressed with a regular expression. To achieve that, we will use the
- <code>Hoa\String\String::match</code> method. This method relies on the
+ <code>Hoa\Ustring\Ustring::match</code> method. This method relies on the
<a href="http://php.net/preg_match"><code>preg_match</code></a> and
<a href="http://php.net/preg_match_all"><code>preg_match_all</code></a> PHP
functions, but by modifying the pattern's options to ensure the Unicode
@@ -385,7 +386,7 @@ var_dump($matches['direct_object']);
<p>Similarly, we can <strong>search</strong> and <strong>replace</strong>
sub-strings by other sub-strings based on a pattern, still expressed with a
regular expression. To achieve that, we will use the
- <code>Hoa\String\String::replace</code> method. This method uses the
+ <code>Hoa\Ustring\Ustring::replace</code> method. This method uses the
<a href="http://php.net/preg_replace"><code>preg_replace</code></a> and
<a href="http://php.net/preg_replace_callback"><code>preg_replace_callback</code></a>
PHP functions, but still by modifying the pattern's options to ensure the
@@ -404,45 +405,45 @@ echo $french;
* Will output:
* Je vous aime
*/</code></pre>
- <p>The <code>Hoa\String\String</code> class provides constants which are
+ <p>The <code>Hoa\Ustring\Ustring</code> class provides constants which are
aliases of existing PHP constants and ensure a better readability of the
code:</p>
<ul>
- <li><code>Hoa\String\String::WITHOUT_EMPTY</code>, alias of
+ <li><code>Hoa\Ustring\Ustring::WITHOUT_EMPTY</code>, alias of
<code>PREG_SPLIT_NO_EMPTY</code>,</li>
- <li><code>Hoa\String\String::WITH_DELIMITERS</code>, alias of
+ <li><code>Hoa\Ustring\Ustring::WITH_DELIMITERS</code>, alias of
<code>PREG_SPLIT_DELIM_CAPTURE</code>,</li>
- <li><code>Hoa\String\String::WITH_OFFSET</code>, alias of
+ <li><code>Hoa\Ustring\Ustring::WITH_OFFSET</code>, alias of
<code>PREG_OFFSET_CAPTURE</code> and
<code>PREG_SPLIT_OFFSET_CAPTURE</code>,</li>
- <li><code>Hoa\String\String::GROUP_BY_PATTERN</code>, alias of
+ <li><code>Hoa\Ustring\Ustring::GROUP_BY_PATTERN</code>, alias of
<code>PREG_PATTERN_ORDER</code>,</li>
- <li><code>Hoa\String\String::GROUP_BY_TUPLE</code>, alias of
+ <li><code>Hoa\Ustring\Ustring::GROUP_BY_TUPLE</code>, alias of
<code>PREG_SET_ORDER</code>.</li>
</ul>
<p>Because they are strict aliases, we can write:</p>
- <pre><code class="language-php">$string = new Hoa\String\String('abc1 defg2 hikl3 xyz4');
+ <pre><code class="language-php">$string = new Hoa\Ustring\Ustring('abc1 defg2 hikl3 xyz4');
$string->match(
'#(\w+)(\d)#',
$matches,
- Hoa\String\String::WITH_OFFSET
- | Hoa\String\String::GROUP_BY_TUPLE,
+ Hoa\Ustring\Ustring::WITH_OFFSET
+ | Hoa\Ustring\Ustring::GROUP_BY_TUPLE,
0,
true
);</code></pre>
<h3 id="Characters" for="main-toc">Characters</h3>
- <p>The <code>Hoa\String\String</code> class offers static methods working on a
- single Unicode character. We have already mentionned the
+ <p>The <code>Hoa\Ustring\Ustring</code> class offers static methods working on
+ a single Unicode character. We have already mentionned the
<code>getCharDirection</code> method which allows to know the
<strong>direction</strong> of a character. We also have the
<code>getCharWidth</code> which counts the <strong>number of columns</strong>
necessary to print a single character. Thus:</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::getCharWidth(Hoa\String\String::fromCode(0x7f)),
- Hoa\String\String::getCharWidth('a'),
- Hoa\String\String::getCharWidth('㽠')
+ Hoa\Ustring\Ustring::getCharWidth(Hoa\Ustring\Ustring::fromCode(0x7f)),
+ Hoa\Ustring\Ustring::getCharWidth('a'),
+ Hoa\Ustring\Ustring::getCharWidth('㽠')
);
/**
@@ -457,10 +458,10 @@ $string->match(
is a character that can be printed. In our example, <code>㽠</code> requires
2 columns to be printed.</p>
<p>To get more semantics, we have the
- <code>Hoa\String\String::isCharPrintable</code> method which allows to know
+ <code>Hoa\Ustring\Ustring::isCharPrintable</code> method which allows to know
whether a character is printable or not.</p>
<p>If we would like to count the number of columns necessary for a whole
- string, we have to use the <code>Hoa\String\String::getWidth</code> method.
+ string, we have to use the <code>Hoa\Ustring\Ustring::getWidth</code> method.
Thus:</p>
<pre><code class="language-php">var_dump(
$french->getWidth(),
@@ -485,7 +486,7 @@ $string->match(
<p>Finally, if this time we are not interested by Unicode characters but
rather by <strong>machine</strong> characters <code>char</code> (being
1 byte), we have an extra operation. The
- <code>Hoa\String\String::getBytesLength</code> method will count the
+ <code>Hoa\Ustring\Ustring::getBytesLength</code> method will count the
<strong>length</strong> of the string in bytes:</p>
<pre><code class="language-php">var_dump(
$arabic->getBytesLength(),
@@ -498,25 +499,25 @@ $string->match(
* int(27)
*/</code></pre>
<p>If we compare these results with the ones of the
- <code>Hoa\String\String::count</code> method, we understand that the Arabic
+ <code>Hoa\Ustring\Ustring::count</code> method, we understand that the Arabic
characters are encoded with 2 bytes whereas Japanese characteres are encoded
with 3 bytes. We can also get a specific byte thanks to the
- <code>Hoa\String\String::getByteAt</code> method. Once again, the index is not
- bounded.</p>
+ <code>Hoa\Ustring\Ustring::getByteAt</code> method. Once again, the index is
+ not bounded.</p>
<h3 id="Code-point" for="main-toc">Code-point</h3>
<p>Each character is represented by an integer, called a
<strong>code-point</strong>. To get the code-point of a character, we can
- use the <code>Hoa\String\String::toCode</code> static method, and to get a
+ use the <code>Hoa\Ustring\Ustring::toCode</code> static method, and to get a
character based on its code-point, we can use the
- <code>Hoa\String\String::fromCode</code> static method. We also have the
- <code>Hoa\String\String::toBinaryCode</code> method which returns the binary
+ <code>Hoa\Ustring\Ustring::fromCode</code> static method. We also have the
+ <code>Hoa\Ustring\Ustring::toBinaryCode</code> method which returns the binary
representation of a character. Let's take an example:</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::toCode('Σ'),
- Hoa\String\String::toBinaryCode('Σ'),
- Hoa\String\String::fromCode(0x1a9)
+ Hoa\Ustring\Ustring::toCode('Σ'),
+ Hoa\Ustring\Ustring::toBinaryCode('Σ'),
+ Hoa\Ustring\Ustring::fromCode(0x1a9)
);
/**
@@ -528,10 +529,10 @@ $string->match(
<h2 id="Search_algorithms" for="main-toc">Search algorithms</h2>
- <p>The <code>Hoa\String</code> library provides sophisticated
+ <p>The <code>Hoa\Ustring</code> library provides sophisticated
<strong>search</strong> algorithms on strings through the
- <code>Hoa\String\Search</code> class.</p>
- <p>We will study the <code>Hoa\String\Search::approximated</code> algorithm
+ <code>Hoa\Ustring\Search</code> class.</p>
+ <p>We will study the <code>Hoa\Ustring\Search::approximated</code> algorithm
which searches a sub-string in a string up to <strong><em>k</em>
differences</strong> (a difference is an addition, a deletion or a
modification). Let's take the classical example of a DNA representation: We
@@ -540,7 +541,7 @@ $string->match(
<pre><code class="language-php">$x = 'GATAA';
$y = 'CAGATAAGAGAA';
$k = 1;
-$search = Hoa\String\Search::approximated($y, $x, $k);
+$search = Hoa\Ustring\Search::approximated($y, $x, $k);
$n = count($search);
echo 'Try to match ', $x, ' in ', $y, ' with at most ', $k, ' difference(s):', "\n";
@@ -585,7 +586,7 @@ foreach ($search as $position) {
<pre><code class="language-php">$x = 'testot';
$y = '--testIt --foobar --testThat --testAt';
$k = 1;
-$search = Hoa\String\Search::approximated($y, $x, $k);
+$search = Hoa\Ustring\Search::approximated($y, $x, $k);
$n = count($search);
// …
@@ -604,7 +605,7 @@ $n = count($search);
<h2 id="Conclusion" for="main-toc">Conclusion</h2>
- <p>The <code>Hoa\String</code> library provides facilities to manipulate
+ <p>The <code>Hoa\Ustring</code> library provides facilities to manipulate
strings encoded with the Unicode format, but also to make sophisticated search
on strings.</p>
diff --git a/Documentation/Fr/Index.xyl b/Documentation/Fr/Index.xyl
index e16ae52..33d1c3b 100644
--- a/Documentation/Fr/Index.xyl
+++ b/Documentation/Fr/Index.xyl
@@ -5,7 +5,7 @@
<p>Les chaînes de caractères peuvent parfois être <strong>complexes</strong>,
particulièrement lorsqu'elles utilisent l'encodage <strong>Unicode</strong>.
- La bibliothèque <code>Hoa\String</code> propose plusieurs opérations sur des
+ La bibliothèque <code>Hoa\Ustring</code> propose plusieurs opérations sur des
chaînes de caractères UTF-8.</p>
<h2 id="Table_of_contents">Table des matières</h2>
@@ -28,7 +28,7 @@
d'Unicode. Malheureusement, il faut parfois mélanger ces extensions pour
arriver à nos fins et au prix d'une certaine <strong>complexité</strong> et
d'une <strong>verbosité</strong> regrettable.</p>
- <p>La bibliothèque <code>Hoa\String</code> répond à ces problématiques en
+ <p>La bibliothèque <code>Hoa\Ustring</code> répond à ces problématiques en
proposant une façon <strong>simple</strong> de manipuler des chaînes de
caractères, de manière <strong>performante</strong> et
<strong>efficace</strong>. Elle propose également des algorithmes évolués pour
@@ -37,7 +37,7 @@
<h2 id="Unicode_strings" for="main-toc">Chaîne de caractères Unicode</h2>
- <p>La classe <code>Hoa\String\String</code> représente une chaîne de
+ <p>La classe <code>Hoa\Ustring\Ustring</code> représente une chaîne de
caractères Unicode <strong>UTF-8</strong> et permet de la manipuler
facilement. Elle implémente les interfaces
<a href="http://php.net/arrayaccess"><code>ArrayAccess</code></a>,
@@ -45,9 +45,9 @@
<a href="http://php.net/iteratoraggregate"><code>IteratorAggregate</code></a>.
Nous allons utiliser trois exemples dans trois langues différentes : français,
arabe et japonais. Ainsi :</p>
- <pre><code class="language-php">$french = new Hoa\String\String('Je t\'aime');
-$arabic = new Hoa\String\String('أحبك');
-$japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
+ <pre><code class="language-php">$french = new Hoa\Ustring\Ustring('Je t\'aime');
+$arabic = new Hoa\Ustring\Ustring('أحبك');
+$japanese = new Hoa\Ustring\Ustring('私はあなたを愛して');</code></pre>
<p>Maintenant, voyons les opérations possibles sur ces trois chaînes.</p>
<h3 id="String_manipulation" for="main-toc">Manipulation de la chaîne</h3>
@@ -72,21 +72,21 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
de droite ou de gauche, mais plutôt de <strong>début</strong> ou de
<strong>fin</strong>, et cela à partir de la <strong>direction</strong> (sens
d'écriture) du texte. Nous pouvons connaître cette direction grâce à la
- méthode <code>Hoa\String\String::getDirection</code>. Elle retourne la valeur
- d'une des constantes suivantes :</p>
+ méthode <code>Hoa\Ustring\Ustring::getDirection</code>. Elle retourne la
+ valeur d'une des constantes suivantes :</p>
<ul>
- <li><code>Hoa\String\String::LTR</code>, pour
+ <li><code>Hoa\Ustring\Ustring::LTR</code>, pour
<em lang="en">left-to-right</em>, si le texte s'écrit de gauche à
droite ;</li>
- <li><code>Hoa\String\String::RTL</code>, pour
+ <li><code>Hoa\Ustring\Ustring::RTL</code>, pour
<em lang="en">right-to-left</em>, si le texte s'écrit de droite à
gauche.</li>
</ul>
<p>Observons le résultat sur nos exemples :</p>
<pre><code class="language-php">var_dump(
- $french->getDirection() === Hoa\String\String::LTR, // is left-to-right?
- $arabic->getDirection() === Hoa\String\String::RTL, // is right-to-left?
- $japanese->getDirection() === Hoa\String\String::LTR // is left-to-right?
+ $french->getDirection() === Hoa\Ustring\Ustring::LTR, // is left-to-right?
+ $arabic->getDirection() === Hoa\Ustring\Ustring::RTL, // is right-to-left?
+ $japanese->getDirection() === Hoa\Ustring\Ustring::LTR // is left-to-right?
);
/**
@@ -96,12 +96,12 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
* bool(true)
*/</code></pre>
<p>Le résultat de cette méthode est calculé grâce à la méthode statique
- <code>Hoa\String\String::getCharDirection</code> qui calcule la direction d'un
- seul caractère.</p>
+ <code>Hoa\Ustring\Ustring::getCharDirection</code> qui calcule la direction
+ d'un seul caractère.</p>
<p>Si nous voulons <strong>concaténer</strong> une autre chaîne à la fin ou au
début, nous utiliserons respectivement les méthodes
- <code>Hoa\String\String::append</code> et
- <code>Hoa\String\String::prepend</code>. Ces méthodes, comme la plupart de
+ <code>Hoa\Ustring\Ustring::append</code> et
+ <code>Hoa\Ustring\Ustring::prepend</code>. Ces méthodes, comme la plupart de
celles qui modifient la chaîne, retournent l'objet lui-même, ce afin de
chaîner les appels. Par exemple :</p>
<pre><code class="language-php">echo $french->append('… et toi, m\'aimes-tu ?')->prepend('Mam\'zelle ! ');
@@ -111,8 +111,8 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
* Mam'zelle ! Je t'aime… et toi, m'aimes-tu ?
*/</code></pre>
<p>Nous avons également les méthodes
- <code>Hoa\String\String::toLowerCase</code> et
- <code>Hoa\String\String::toUpperCase</code> pour, respectivement, mettre la
+ <code>Hoa\Ustring\Ustring::toLowerCase</code> et
+ <code>Hoa\Ustring\Ustring::toUpperCase</code> pour, respectivement, mettre la
chaîne en <strong>minuscules</strong> ou en <strong>majuscules</strong>. Par
exemple :</p>
<pre><code class="language-php">echo $french->toUpperCase();
@@ -125,11 +125,11 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
atteindre une taille <strong>minimum</strong>. Cette opération est plus
couramment appelée le <em lang="en">padding</em> (pour des raisons historiques
remontant aux machines à écrire). C'est pourquoi nous trouvons la méthode
- <code>Hoa\String\String::pad</code> qui prend trois arguments : la taille
+ <code>Hoa\Ustring\Ustring::pad</code> qui prend trois arguments : la taille
minimum, les caractères à ajouter et une constante indiquant si nous devons
ajouter en fin ou en début de chaîne (respectivement
- <code>Hoa\String\String::END</code>, par défaut, et
- <code>Hoa\String\String::BEGINNING</code>).</p>
+ <code>Hoa\Ustring\Ustring::END</code>, par défaut, et
+ <code>Hoa\Ustring\Ustring::BEGINNING</code>).</p>
<pre><code class="language-php">echo $arabic->pad(20, ' ');
/**
@@ -138,8 +138,8 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
*/</code></pre>
<p>Une opération similairement inverse permet de supprimer, par défaut, les
<strong>espaces</strong> en début et en fin de chaîne grâce à la méthode
- <code>Hoa\String\String::trim</code>. Par exemple, pour revenir à notre chaîne
- arabe originale :</p>
+ <code>Hoa\Ustring\Ustring::trim</code>. Par exemple, pour revenir à notre
+ chaîne arabe originale :</p>
<pre><code class="language-php">echo $arabic->trim();
/**
@@ -150,17 +150,17 @@ $japanese = new Hoa\String\String('私はあなたを愛して');</code></pre>
premier argument qui doit être une expression régulière. Enfin, son second
argument permet de préciser de quel côté nous voulons supprimer les
caractères : en début, en fin ou les deux, toujours en utilisant les
- constantes <code>Hoa\String\String::BEGINNING</code> et
- <code>Hoa\String\String::END</code>. Nous pouvons combiner ces constantes
+ constantes <code>Hoa\Ustring\Ustring::BEGINNING</code> et
+ <code>Hoa\Ustring\Ustring::END</code>. Nous pouvons combiner ces constantes
pour exprimer « les deux côtés », ce qui est la valeur par défaut :
- <code class="language-php">Hoa\String\String::BEGINNING |
- Hoa\String\String::END</code>. Par exemple, pour supprimer tous les nombres et
- les espaces uniquement à la fin, nous écrirons :</p>
- <pre><code class="language-php">$arabic->trim('\s|\d', Hoa\String\String::END);</code></pre>
+ <code class="language-php">Hoa\Ustring\Ustring::BEGINNING |
+ Hoa\Ustring\Ustring::END</code>. Par exemple, pour supprimer tous les nombres
+ et les espaces uniquement à la fin, nous écrirons :</p>
+ <pre><code class="language-php">$arabic->trim('\s|\d', Hoa\Ustring\Ustring::END);</code></pre>
<p>Nous pouvons également <strong>réduire</strong> la chaîne à une
<strong>sous-chaîne</strong> en précisant la position du premier caractère
puis la taille de la sous-chaîne à la méthode
- <code>Hoa\String\String::reduce</code> :</p>
+ <code>Hoa\Ustring\Ustring::reduce</code> :</p>
<pre><code class="language-php">echo $french->reduce(3, 6)->reduce(2, 4);
/**
@@ -198,7 +198,7 @@ echo $french;
<p>Une autre méthode fort utile est la transformation en
<strong>ASCII</strong>. Attention, ce n'est pas toujours possible, selon votre
installation. Par exemple :</p>
- <pre><code class="language-php">$title = new Hoa\String\String('Un été brûlant sur la côte');
+ <pre><code class="language-php">$title = new Hoa\Ustring\Ustring('Un été brûlant sur la côte');
echo $title->toAscii();
/**
@@ -208,8 +208,8 @@ echo $title->toAscii();
<p>Nous pouvons aussi transformer de l'arabe ou du japonais vers de l'ASCII.
Les symboles, comme les symboles Mathématiques ou les emojis, sont aussi
transformés :</p>
- <pre><code class="language-php">$emoji = new Hoa\String\String('I ❤ Unicode');
-$maths = new Hoa\String\String('∀ i ∈ ℕ');
+ <pre><code class="language-php">$emoji = new Hoa\Ustring\Ustring('I ❤ Unicode');
+$maths = new Hoa\Ustring\Ustring('∀ i ∈ ℕ');
echo
$arabic->toAscii(), "\n",
@@ -230,7 +230,7 @@ echo
existe. Si elle n'existe pas, la classe
<a href="http://php.net/normalizer"><code>Normalizer</code></a> doit exister.
Si cette classe n'existe pas non plus, la méthode
- <code>Hoa\String\String::toAscii</code> peut quand même essayer une
+ <code>Hoa\Ustring\Ustring::toAscii</code> peut quand même essayer une
transformation mais moins efficace. Pour cela, il faut passer
<code>true</code> en seul argument. Ce tour de force est déconseillé dans la
plupart des cas.</p>
@@ -247,7 +247,7 @@ echo
<p>Plus généralement, pour des changements d'<strong>encodage</strong> brut,
nous pouvons utiliser la méthode statique
- <code>Hoa\String\String::transcode</code>, avec en premier argument une chaîne
+ <code>Hoa\Ustring\Ustring::transcode</code>, avec en premier argument une chaîne
de caractères, en deuxième argument l'encodage d'origine et en dernier
argument l'encodage final souhaité (par défaut UTF-8). Pour la liste des
encodages, il faut se reporter à l'extension
@@ -255,10 +255,10 @@ echo
suivante dans un terminal :</p>
<pre><code class="language-php">$ iconv --list</code></pre>
<p>Pour savoir si une chaîne est encodée en UTF-8, nous pouvons utiliser la
- méthode statique <code>Hoa\String\String::isUtf8</code> ; par exemple :</p>
+ méthode statique <code>Hoa\Ustring\Ustring::isUtf8</code> ; par exemple :</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::isUtf8('a'),
- Hoa\String\String::isUtf8(Hoa\String\String::transcode('a', 'UTF-8', 'UTF-16'))
+ Hoa\Ustring\Ustring::isUtf8('a'),
+ Hoa\Ustring\Ustring::isUtf8(Hoa\Ustring\Ustring::transcode('a', 'UTF-8', 'UTF-16'))
);
/**
@@ -267,7 +267,7 @@ echo
* bool(false)
*/</code></pre>
<p>Nous pouvons <strong>éclater</strong> la chaîne en plusieurs sous-chaînes
- en utilisant la méthode <code>Hoa\String\String::split</code>. En premier
+ en utilisant la méthode <code>Hoa\Ustring\Ustring::split</code>. En premier
argument, nous avons une expression régulière (type
<a href="http://pcre.org/">PCRE</a>), puis un entier représentant le nombre
maximum d'éléments à retourner et enfin une combinaison de constantes. Ces
@@ -293,7 +293,7 @@ echo
<p>Si nous voulons <strong>itérer</strong> sur tous les
<strong>caractères</strong>, il est préférable d'exploiter l'interface
<code>IteratorAggregate</code>, soit la méthode
- <code>Hoa\String\String::getIterator</code>. Voyons plutôt sur l'exemple en
+ <code>Hoa\Ustring\Ustring::getIterator</code>. Voyons plutôt sur l'exemple en
arabe :</p>
<pre><code class="language-php">foreach ($arabic as $letter) {
echo $letter, "\n";
@@ -329,8 +329,8 @@ echo
<h3 id="Comparison_and_search" for="main-toc">Comparaison et recherche</h3>
<p>Les chaînes peuvent également être <strong>comparées</strong> entre elles
- grâce à la méthode <code>Hoa\String\String::compare</code> :</p>
- <pre><code class="language-php">$string = new Hoa\String\String('abc');
+ grâce à la méthode <code>Hoa\Ustring\Ustring::compare</code> :</p>
+ <pre><code class="language-php">$string = new Hoa\Ustring\Ustring('abc');
var_dump(
$string->compare('wxyz')
);
@@ -343,13 +343,13 @@ var_dump(
alphabétique), 0 si elle est identique et 1 si elle vient après. Si nous
voulons utiliser la pleine
puissance du mécanisme sous-jacent, nous pouvons appeler la méthode statique
- <code>Hoa\String\String::getCollator</code> (si la classe
+ <code>Hoa\Ustring\Ustring::getCollator</code> (si la classe
<a href="http://php.net/Collator"><code>Collator</code></a> existe, sinon
- <code>Hoa\String\String::compare</code> utilisera une comparaison simple
+ <code>Hoa\Ustring\Ustring::compare</code> utilisera une comparaison simple
octet par octets sans tenir compte d'autres paramètres). Ainsi, si nous
voulons trier un tableau de chaînes, nous écrirons plutôt :</p>
<pre><code class="language-php">$strings = array('c', 'Σ', 'd', 'x', 'α', 'a');
-Hoa\String\String::getCollator()->sort($strings);
+Hoa\Ustring\Ustring::getCollator()->sort($strings);
print_r($strings);
/**
@@ -368,10 +368,10 @@ print_r($strings);
c'est à dire de la régionalisation du système, comme la langue, le pays, la
région etc. Nous pouvons utiliser <a href="@hack:chapter=Locale">la
bibliothèque <code>Hoa\Locale</code></a> pour modifier ces données, mais ce
- n'est pas une dépendance de <code>Hoa\String</code> pour autant.</p>
+ n'est pas une dépendance de <code>Hoa\Ustring</code> pour autant.</p>
<p>Nous pouvons également savoir si une chaîne <strong>correspond</strong> à
un certain motif, toujours exprimé avec une expression régulière. Pour cela,
- nous allons utiliser la méthode <code>Hoa\String\String::match</code>. Cette
+ nous allons utiliser la méthode <code>Hoa\Ustring\Ustring::match</code>. Cette
méthode repose sur les fonctions
<a href="http://php.net/preg_match"><code>preg_match</code></a> et
<a href="http://php.net/preg_match_all"><code>preg_match_all</code></a> de
@@ -397,7 +397,7 @@ var_dump($matches['direct_object']);
<p>Similairement, nous pouvons <strong>chercher</strong> et
<strong>remplacer</strong> des sous-chaînes par d'autres sous-chaînes suivant
un motif, toujours exprimé avec une expression régulière. Pour cela, nous
- allons utiliser la méthode <code>Hoa\String\String::replace</code>. Cette
+ allons utiliser la méthode <code>Hoa\Ustring\Ustring::replace</code>. Cette
méthode repose sur les fonctions
<a href="http://php.net/preg_replace"><code>preg_replace</code></a> et
<a href="http://php.net/preg_replace_callback"><code>preg_replace_callback</code></a>
@@ -418,44 +418,45 @@ echo $french;
* Will output:
* Je vous aime
*/</code></pre>
- <p>La classe <code>Hoa\String\String</code> propose des constantes qui sont des
- aliases de constantes PHP et qui permettent une meilleure lecture du code:</p>
+ <p>La classe <code>Hoa\Ustring\Ustring</code> propose des constantes qui sont
+ des aliases de constantes PHP et qui permettent une meilleure lecture du
+ code:</p>
<ul>
- <li><code>Hoa\String\String::WITHOUT_EMPTY</code>, alias de
+ <li><code>Hoa\Ustring\Ustring::WITHOUT_EMPTY</code>, alias de
<code>PREG_SPLIT_NO_EMPTY</code> ;</li>
- <li><code>Hoa\String\String::WITH_DELIMITERS</code>, alias de
+ <li><code>Hoa\Ustring\Ustring::WITH_DELIMITERS</code>, alias de
<code>PREG_SPLIT_DELIM_CAPTURE</code> ;</li>
- <li><code>Hoa\String\String::WITH_OFFSET</code>, alias de
+ <li><code>Hoa\Ustring\Ustring::WITH_OFFSET</code>, alias de
<code>PREG_OFFSET_CAPTURE</code> et
<code>PREG_SPLIT_OFFSET_CAPTURE</code> ;</li>
- <li><code>Hoa\String\String::GROUP_BY_PATTERN</code>, alias de
+ <li><code>Hoa\Ustring\Ustring::GROUP_BY_PATTERN</code>, alias de
<code>PREG_PATTERN_ORDER</code> ;</li>
- <li><code>Hoa\String\String::GROUP_BY_TUPLE</code>, alias de
+ <li><code>Hoa\Ustring\Ustring::GROUP_BY_TUPLE</code>, alias de
<code>PREG_SET_ORDER</code>.</li>
</ul>
<p>Comme ce sont des aliases stricts, nous pouvons écrire :</p>
- <pre><code class="language-php">$string = new Hoa\String\String('abc1 defg2 hikl3 xyz4');
+ <pre><code class="language-php">$string = new Hoa\Ustring\Ustring('abc1 defg2 hikl3 xyz4');
$string->match(
'#(\w+)(\d)#',
$matches,
- Hoa\String\String::WITH_OFFSET
- | Hoa\String\String::GROUP_BY_TUPLE,
+ Hoa\Ustring\Ustring::WITH_OFFSET
+ | Hoa\Ustring\Ustring::GROUP_BY_TUPLE,
0,
true
);</code></pre>
<h3 id="Characters" for="main-toc">Caractères</h3>
- <p>La classe <code>Hoa\String\String</code> offre des méthodes statiques
+ <p>La classe <code>Hoa\Ustring\Ustring</code> offre des méthodes statiques
travaillant sur un seul caractère Unicode. Nous avons déjà évoqué la méthode
<code>getCharDirection</code> qui permet de connaître la
<strong>direction</strong> d'un caractère. Nous trouvons aussi
<code>getCharWidth</code> qui calcule le <strong>nombre de colonnes</strong>
nécessaires pour l'affichage d'un seul caractère. Ainsi :</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::getCharWidth(Hoa\String\String::fromCode(0x7f)),
- Hoa\String\String::getCharWidth('a'),
- Hoa\String\String::getCharWidth('㽠')
+ Hoa\Ustring\Ustring::getCharWidth(Hoa\Ustring\Ustring::fromCode(0x7f)),
+ Hoa\Ustring\Ustring::getCharWidth('a'),
+ Hoa\Ustring\Ustring::getCharWidth('㽠')
);
/**
@@ -470,10 +471,10 @@ $string->match(
c'est un caractère qui peut être imprimé. Dans notre exemple, <code>㽠</code>
s'imprime sur 2 colonnes.</p>
<p>Pour plus de sémantique, nous avons accès à la méthode
- <code>Hoa\String\String::isCharPrintable</code> qui permet de savoir si un
+ <code>Hoa\Ustring\Ustring::isCharPrintable</code> qui permet de savoir si un
caractère est imprimable ou pas.</p>
<p>Si nous voulons calculer le nombre de colonnes pour tout une chaîne, il
- faut utiliser la méthode <code>Hoa\String\String::getWidth</code>.
+ faut utiliser la méthode <code>Hoa\Ustring\Ustring::getWidth</code>.
Ainsi :</p>
<pre><code class="language-php">var_dump(
$french->getWidth(),
@@ -499,7 +500,7 @@ $string->match(
<p>Enfin, si cette fois nous ne nous intéressons pas aux caractères Unicode
mais aux caractères <strong>machines</strong> <code>char</code> (soit 1
octet), nous avons une opération supplémentaire. La méthode
- <code>Hoa\String\String::getBytesLength</code> va compter la
+ <code>Hoa\Ustring\Ustring::getBytesLength</code> va compter la
<strong>taille</strong> de la chaîne en octets :</p>
<pre><code class="language-php">var_dump(
$arabic->getBytesLength(),
@@ -512,25 +513,26 @@ $string->match(
* int(27)
*/</code></pre>
<p>Si nous comparons ces résultats avec ceux de la méthode
- <code>Hoa\String\String::count</code>, nous comprenons que les caractères
+ <code>Hoa\Ustring\Ustring::count</code>, nous comprenons que les caractères
arabes sont encodés sur 2 octets alors que les caractères japonais sont
encodés sur 3 octets. Nous pouvons également obtenir un octet précis à l'aide
- de la méthode <code>Hoa\String\String::getByteAt</code>. Encore une fois,
+ de la méthode <code>Hoa\Ustring\Ustring::getByteAt</code>. Encore une fois,
l'index n'est pas borné.</p>
<h3 id="Code-point" for="main-toc">Code-point</h3>
<p>Chaque caractère est représenté en machine par un entier, appelé
<strong>code-point</strong>. Pour obtenir le code-point d'un caractère, nous
- pouvons utiliser la méthode statique <code>Hoa\String\String::toCode</code>,
+ pouvons utiliser la méthode statique <code>Hoa\Ustring\Ustring::toCode</code>,
et pour obtenir un caractère à partir d'un code, nous pouvons utiliser la
- méthode statique <code>Hoa\String\String::fromCode</code>. Nous avons aussi la
- méthode statique <code>Hoa\String\String::toBinaryCode</code> qui retourne la
- représentation sous forme binaire d'un caractère. Prenons un exemple :</p>
+ méthode statique <code>Hoa\Ustring\Ustring::fromCode</code>. Nous avons aussi
+ la méthode statique <code>Hoa\Ustring\Ustring::toBinaryCode</code> qui
+ retourne la représentation sous forme binaire d'un caractère. Prenons un
+ exemple :</p>
<pre><code class="language-php">var_dump(
- Hoa\String\String::toCode('Σ'),
- Hoa\String\String::toBinaryCode('Σ'),
- Hoa\String\String::fromCode(0x1a9)
+ Hoa\Ustring\Ustring::toCode('Σ'),
+ Hoa\Ustring\Ustring::toBinaryCode('Σ'),
+ Hoa\Ustring\Ustring::fromCode(0x1a9)
);
/**
@@ -542,11 +544,11 @@ $string->match(
<h2 id="Search_algorithms" for="main-toc">Algorithmes de recherche</h2>
- <p>La bibliothèque <code>Hoa\String</code> propose des algorithmes de
+ <p>La bibliothèque <code>Hoa\Ustring</code> propose des algorithmes de
<strong>recherches</strong> sophistiquées sur les chaînes de caractères à
- travers la classe <code>Hoa\String\Search</code>.</p>
+ travers la classe <code>Hoa\Ustring\Search</code>.</p>
<p>Nous allons étudier l'algorithme
- <code>Hoa\String\Search::approximated</code> qui fait une recherche d'une
+ <code>Hoa\Ustring\Search::approximated</code> qui fait une recherche d'une
sous-chaîne dans une chaîne avec au maximum <strong><em>k</em>
différences</strong> (une différence étant une insertion, une délétion ou une
modification). Prenons un exemple classique avec une représentation
@@ -556,7 +558,7 @@ $string->match(
<pre><code class="language-php">$x = 'GATAA';
$y = 'CAGATAAGAGAA';
$k = 1;
-$search = Hoa\String\Search::approximated($y, $x, $k);
+$search = Hoa\Ustring\Search::approximated($y, $x, $k);
$n = count($search);
echo 'Try to match ', $x, ' in ', $y, ' with at most ', $k, ' difference(s):', "\n";
@@ -604,7 +606,7 @@ foreach ($search as $position) {
<pre><code class="language-php">$x = 'testot';
$y = '--testIt --foobar --testThat --testAt';
$k = 1;
-$search = Hoa\String\Search::approximated($y, $x, $k);
+$search = Hoa\Ustring\Search::approximated($y, $x, $k);
$n = count($search);
// …
@@ -623,7 +625,7 @@ $n = count($search);
<h2 id="Conclusion" for="main-toc">Conclusion</h2>
- <p>La bibliothèque <code>Hoa\String</code> propose des facilités pour
+ <p>La bibliothèque <code>Hoa\Ustring</code> propose des facilités pour
manipuler des chaînes encodées au format Unicode, mais aussi pour effectuer
des recherches sophistiquées sur des chaînes.</p>