CascadiaDigitalCollective/gxg-framework
CascadiaDigitalCollective/gxg-framework
2
0
Fork 0
mirror of https://github.com/mistergibson/gxg-framework.git synced 2026-08-15 03:46:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions
gxg-framework/doc/GxG/ByteArray.html
G. Gibson 4bb9f2f2ea Initial Commit
2021-11-16 08:41:53 -08:00

5768 lines
314 KiB
HTML
Raw Blame History

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class GxG::ByteArray - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "../";
var index_rel_prefix = "../";
</script>
<script src="../js/navigation.js" defer></script>
<script src="../js/search.js" defer></script>
<script src="../js/search_index.js" defer></script>
<script src="../js/searcher.js" defer></script>
<script src="../js/darkfish.js" defer></script>
<link href="../css/fonts.css" rel="stylesheet">
<link href="../css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="../index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="../table_of_contents.html#pages">Pages</a>
<a href="../table_of_contents.html#classes">Classes</a>
<a href="../table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="../Object.html">Object</a>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-5B-5D">::[]</a>
<li class="calls-super" ><a href="#method-c-new">::new</a>
<li ><a href="#method-c-process">::process</a>
<li ><a href="#method-c-search">::search</a>
<li ><a href="#method-c-try_convert">::try_convert</a>
<li ><a href="#method-i-26">#&amp;</a>
<li ><a href="#method-i-2A">#*</a>
<li ><a href="#method-i-2B">#+</a>
<li ><a href="#method-i-2D">#-</a>
<li ><a href="#method-i-3C-3C">#&lt;&lt;</a>
<li ><a href="#method-i-3C-3D-3E">#&lt;=&gt;</a>
<li ><a href="#method-i-3D-3D">#==</a>
<li ><a href="#method-i-5B-5D">#[]</a>
<li ><a href="#method-i-5B-5D-3D">#[]=</a>
<li ><a href="#method-i-assoc">#assoc</a>
<li ><a href="#method-i-at">#at</a>
<li ><a href="#method-i-clear">#clear</a>
<li ><a href="#method-i-clone">#clone</a>
<li ><a href="#method-i-collect">#collect</a>
<li ><a href="#method-i-collect-21">#collect!</a>
<li ><a href="#method-i-combination">#combination</a>
<li ><a href="#method-i-compact">#compact</a>
<li ><a href="#method-i-compact-21">#compact!</a>
<li ><a href="#method-i-concat">#concat</a>
<li ><a href="#method-i-count">#count</a>
<li ><a href="#method-i-cycle">#cycle</a>
<li ><a href="#method-i-data">#data</a>
<li ><a href="#method-i-dclone">#dclone</a>
<li ><a href="#method-i-delete">#delete</a>
<li ><a href="#method-i-delete_at">#delete_at</a>
<li ><a href="#method-i-delete_if">#delete_if</a>
<li ><a href="#method-i-drop">#drop</a>
<li ><a href="#method-i-drop_while">#drop_while</a>
<li ><a href="#method-i-dup">#dup</a>
<li ><a href="#method-i-each">#each</a>
<li ><a href="#method-i-each_index">#each_index</a>
<li ><a href="#method-i-each_with_index">#each_with_index</a>
<li ><a href="#method-i-empty-3F">#empty?</a>
<li ><a href="#method-i-eql-3F">#eql?</a>
<li ><a href="#method-i-fetch">#fetch</a>
<li ><a href="#method-i-fill">#fill</a>
<li ><a href="#method-i-filter_data">#filter_data</a>
<li ><a href="#method-i-filter_parameters">#filter_parameters</a>
<li ><a href="#method-i-find_index">#find_index</a>
<li ><a href="#method-i-first">#first</a>
<li ><a href="#method-i-flatten">#flatten</a>
<li ><a href="#method-i-flatten-21">#flatten!</a>
<li class="calls-super" ><a href="#method-i-freeze">#freeze</a>
<li ><a href="#method-i-get_at_path">#get_at_path</a>
<li ><a href="#method-i-hash">#hash</a>
<li ><a href="#method-i-include-3F">#include?</a>
<li ><a href="#method-i-index">#index</a>
<li ><a href="#method-i-indexes">#indexes</a>
<li ><a href="#method-i-indices">#indices</a>
<li ><a href="#method-i-initialize_clone">#initialize_clone</a>
<li ><a href="#method-i-initialize_copy">#initialize_copy</a>
<li ><a href="#method-i-initialize_dup">#initialize_dup</a>
<li ><a href="#method-i-insert">#insert</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-join">#join</a>
<li ><a href="#method-i-keep_if">#keep_if</a>
<li ><a href="#method-i-last">#last</a>
<li ><a href="#method-i-length">#length</a>
<li ><a href="#method-i-map">#map</a>
<li ><a href="#method-i-map-21">#map!</a>
<li ><a href="#method-i-match">#match</a>
<li ><a href="#method-i-maxsize">#maxsize</a>
<li ><a href="#method-i-maxsize-3D">#maxsize=</a>
<li ><a href="#method-i-mime_type">#mime_type</a>
<li ><a href="#method-i-nitems">#nitems</a>
<li ><a href="#method-i-outervalue">#outervalue</a>
<li ><a href="#method-i-outervalue-3D">#outervalue=</a>
<li ><a href="#method-i-pack">#pack</a>
<li ><a href="#method-i-padvalue">#padvalue</a>
<li ><a href="#method-i-padvalue-3D">#padvalue=</a>
<li ><a href="#method-i-paths_to">#paths_to</a>
<li ><a href="#method-i-pattern_range">#pattern_range</a>
<li ><a href="#method-i-pattern_ranges">#pattern_ranges</a>
<li ><a href="#method-i-permutation">#permutation</a>
<li ><a href="#method-i-pop">#pop</a>
<li ><a href="#method-i-process">#process</a>
<li ><a href="#method-i-process-21">#process!</a>
<li ><a href="#method-i-product">#product</a>
<li ><a href="#method-i-push">#push</a>
<li ><a href="#method-i-rassoc">#rassoc</a>
<li ><a href="#method-i-reject">#reject</a>
<li ><a href="#method-i-reject-21">#reject!</a>
<li ><a href="#method-i-repeated_combination">#repeated_combination</a>
<li ><a href="#method-i-repeated_permutation">#repeated_permutation</a>
<li ><a href="#method-i-replace">#replace</a>
<li ><a href="#method-i-reverse">#reverse</a>
<li ><a href="#method-i-reverse-21">#reverse!</a>
<li ><a href="#method-i-reverse_each">#reverse_each</a>
<li ><a href="#method-i-rindex">#rindex</a>
<li ><a href="#method-i-rotate">#rotate</a>
<li ><a href="#method-i-rotate-21">#rotate!</a>
<li ><a href="#method-i-sample">#sample</a>
<li ><a href="#method-i-search">#search</a>
<li ><a href="#method-i-select">#select</a>
<li ><a href="#method-i-select-21">#select!</a>
<li ><a href="#method-i-set_at_path">#set_at_path</a>
<li ><a href="#method-i-shift">#shift</a>
<li ><a href="#method-i-shuffle">#shuffle</a>
<li ><a href="#method-i-shuffle-21">#shuffle!</a>
<li ><a href="#method-i-size">#size</a>
<li ><a href="#method-i-slice">#slice</a>
<li ><a href="#method-i-slice-21">#slice!</a>
<li ><a href="#method-i-sort">#sort</a>
<li ><a href="#method-i-sort-21">#sort!</a>
<li ><a href="#method-i-sort_by-21">#sort_by!</a>
<li ><a href="#method-i-take">#take</a>
<li ><a href="#method-i-take_while">#take_while</a>
<li ><a href="#method-i-to_a">#to_a</a>
<li ><a href="#method-i-to_ary">#to_ary</a>
<li ><a href="#method-i-to_json">#to_json</a>
<li ><a href="#method-i-to_s">#to_s</a>
<li ><a href="#method-i-transpose">#transpose</a>
<li ><a href="#method-i-uniq">#uniq</a>
<li ><a href="#method-i-uniq-21">#uniq!</a>
<li ><a href="#method-i-unshift">#unshift</a>
<li ><a href="#method-i-values_at">#values_at</a>
<li ><a href="#method-i-zip">#zip</a>
<li ><a href="#method-i-7C">#|</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-GxG::ByteArray">
<h1 id="class-GxG::ByteArray" class="class">
class GxG::ByteArray
</h1>
<section class="description">
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-5B-5D" class="method-detail ">
<div class="method-heading">
<span class="method-name">[]</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="5B-5D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 538</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">[]</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-new" class="method-detail ">
<div class="method-heading">
<span class="method-name">new</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>instance methods:</p>
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="new-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 571</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># Integer(how_many), &lt;Acceptable-data-type&gt;, &lt;Max-size&gt;, &lt;Pad-value&gt;, &lt;Outer-value&gt;</span>
<span class="ruby-comment"># --OR--</span>
<span class="ruby-comment"># Integer(how_many), &lt;Max-size&gt;, &lt;Pad-value&gt;, &lt;Outer-value&gt; &amp;block</span>
<span class="ruby-ivar">@data</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-comment">#</span>
<span class="ruby-identifier">memory_limits</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">SYSTEM</span>.<span class="ruby-identifier">memory_limits</span>()
<span class="ruby-ivar">@max_size</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-ivar">@pad_value</span> = <span class="ruby-value">0</span>
<span class="ruby-ivar">@outer</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-comment"># *should* create a &#39;self&#39; to call upon.</span>
<span class="ruby-keyword">super</span>()
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;=</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">memory_limits</span>[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">memory_limits</span>[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">maxsize</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">padvalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">3</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">outervalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">raw_data_array</span> = [(<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">index</span>))].<span class="ruby-identifier">flatten</span>
<span class="ruby-identifier">raw_data_array</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">raw_data</span><span class="ruby-operator">|</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">raw_data</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">raw_data</span>) <span class="ruby-operator">||</span> <span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">raw_data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">*</span> <span class="ruby-identifier">raw_data</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">memory_limits</span>[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-comment"># Attempts to project whether or not maximum memory limits will be exceeded.</span>
<span class="ruby-comment"># LATER: ByteArray.new: Might get false positives on variable return data from block (re-think this)</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">NoMemoryError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;This operation will exceed available per-process memory limits&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@data</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">raw_data</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">how_many</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]
<span class="ruby-identifier">raw_data_array</span> = [(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])].<span class="ruby-identifier">flatten</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raw_data_array</span> = [(<span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">to_i</span>.<span class="ruby-identifier">chr</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">maxsize</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">3</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">padvalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">3</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">4</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">outervalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">4</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">how_many</span> = <span class="ruby-value">1</span>
<span class="ruby-identifier">raw_data_array</span> = [(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])].<span class="ruby-identifier">flatten</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">maxsize</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">padvalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">3</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">outervalue</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">3</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">new_data</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">new_data</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-identifier">raw_data_array</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">raw_data</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">new_data</span> <span class="ruby-operator">&lt;&lt;</span> (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">raw_data</span>) <span class="ruby-operator">||</span> <span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">new_data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">how_many</span> <span class="ruby-operator">*</span> <span class="ruby-identifier">new_data</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">memory_limits</span>[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">NoMemoryError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;This operation will exceed available per-process memory limits&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">how_many</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span>
<span class="ruby-ivar">@data</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">new_data</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-process" class="method-detail ">
<div class="method-heading">
<span class="method-name">process</span><span
class="method-args">(the_array=GxG::ByteArray.new,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="process-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 542</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">process</span>(<span class="ruby-identifier">the_array</span>=<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">new_array</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_array</span>.<span class="ruby-identifier">is_any?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Array</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Hash</span>, <span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Set</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Struct</span>)
<span class="ruby-identifier">new_array</span> = <span class="ruby-identifier">the_array</span>.<span class="ruby-identifier">process</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">&quot;you must pass an Array, a ByteArray, or a Hash&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">new_array</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-search" class="method-detail ">
<div class="method-heading">
<span class="method-name">search</span><span
class="method-args">(the_array=GxG::ByteArray.new,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="search-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 554</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">search</span>(<span class="ruby-identifier">the_array</span>=<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">new_array</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_array</span>.<span class="ruby-identifier">is_any?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Array</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Hash</span>, <span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Set</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Struct</span>)
<span class="ruby-identifier">new_array</span> = <span class="ruby-identifier">the_array</span>.<span class="ruby-identifier">search</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">&quot;you must pass an Array, a ByteArray, or a Hash&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">new_array</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-c-try_convert" class="method-detail ">
<div class="method-heading">
<span class="method-name">try_convert</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="try_convert-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 530</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">try_convert</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">begin</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">1</span>,[(<span class="ruby-identifier">args</span>)])
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">Exception</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-26" class="method-detail ">
<div class="method-heading">
<span class="method-name">&amp;</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="26-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 994</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">&amp;</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">other</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-2A" class="method-detail ">
<div class="method-heading">
<span class="method-name">*</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="2A-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1012</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">*</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">String</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">join</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">scrap_size</span> = ((<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_f</span> <span class="ruby-operator">%</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>.<span class="ruby-identifier">to_f</span>) <span class="ruby-operator">*</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>.<span class="ruby-identifier">to_f</span>).<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">*</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>) <span class="ruby-operator">&lt;=</span> <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">SYSTEM</span>.<span class="ruby-identifier">memory_limits</span>()[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>().<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap_size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>()[<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">scrap_size</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">NoMemoryError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;This operation will exceed per-process memory limits&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;a String or Numeric is required, you provied #{args[0].inspect}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;Can&#39;t convert nil to ByteArray&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-2B" class="method-detail ">
<div class="method-heading">
<span class="method-name">+</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="2B-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1043</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">+</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">other</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">1</span>,[(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>().<span class="ruby-identifier">clone</span>),(<span class="ruby-identifier">other</span>.<span class="ruby-identifier">data</span>())])
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;Can&#39;t convert nil to ByteArray&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-2D" class="method-detail ">
<div class="method-heading">
<span class="method-name">-</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="2D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1058</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">-</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">scrap</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span>
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-3C-3C" class="method-detail ">
<div class="method-heading">
<span class="method-name">&lt;&lt;</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="3C-3C-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1076</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">&lt;&lt;</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">value</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> (<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">size</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Operation exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@data</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-3C-3D-3E" class="method-detail ">
<div class="method-heading">
<span class="method-name">&lt;=&gt;</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="3C-3D-3E-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1091</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">&lt;=&gt;</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-value">1</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">result</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>() <span class="ruby-operator">&lt;=&gt;</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># Allows sorting against std. Array or String that *would* sort normal if it were a ByteArray (byte comparison)</span>
<span class="ruby-identifier">other</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>
<span class="ruby-identifier">result</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>() <span class="ruby-operator">&lt;=&gt;</span> <span class="ruby-identifier">other</span>.<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">==</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="3D-3D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1107</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">==</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">false</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">result</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">data</span>() <span class="ruby-operator">==</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># kinda cool, but might be a bridge too far for strict equivalence.</span>
<span class="ruby-comment"># other = GxG::ByteArray::try_convert(args)</span>
<span class="ruby-comment"># if other</span>
<span class="ruby-comment"># result = (self.data() == other.data())</span>
<span class="ruby-comment">#end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-5B-5D" class="method-detail ">
<div class="method-heading">
<span class="method-name">[]</span><span
class="method-args">(indexer=0, length=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="5B-5D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 886</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">[]</span>(<span class="ruby-identifier">indexer</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">length</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice</span>(<span class="ruby-identifier">indexer</span>,<span class="ruby-identifier">length</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-5B-5D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">[]=</span><span
class="method-args">(indexer=0, length=nil, value=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="5B-5D-3D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 890</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">[]=</span>(<span class="ruby-identifier">indexer</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">length</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">value</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">length</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">value</span>
<span class="ruby-identifier">value</span> = <span class="ruby-identifier">length</span>
<span class="ruby-identifier">length</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">value</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">the_range</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">indexer</span>,<span class="ruby-identifier">length</span>)
<span class="ruby-comment">#</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">the_range</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">length</span>
<span class="ruby-identifier">error</span> = <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{indexer.inspect},#{length.inspect} could not be fashioned into a valid Indexer&quot;</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">error</span> = <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{indexer.inspect} could not be fashioned into a valid Indexer&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">error</span>
<span class="ruby-identifier">raise</span> <span class="ruby-identifier">error</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment"># check overall compliance with maxsize</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">||</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">last</span> <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
<span class="ruby-identifier">error</span> = <span class="ruby-constant">IndexError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Index exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)) <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Data size at specified Index exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">indexer</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">length</span>
<span class="ruby-comment"># replace operation</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)) <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Range exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-keyword">and</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">+</span> ((<span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">-</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))) <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Value size exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># insert operation</span>
<span class="ruby-keyword">if</span> (<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Operation exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)) <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Value size exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Range exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-keyword">and</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">+</span> ((<span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">-</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))) <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">error</span> = <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Value size exceeds #{@max_size} limit. You might need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">error</span>
<span class="ruby-identifier">raise</span> <span class="ruby-identifier">error</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">-</span> (<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span>
<span class="ruby-ivar">@data</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">length</span>
<span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span>),(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span>)] = <span class="ruby-identifier">value</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">indexer</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span>)] = <span class="ruby-identifier">value</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">the_range</span>)] = <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-assoc" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">assoc</span><span
class="method-args">(key=nil)</span>
</div>
<div class="method-description">
<p>Method Aliases</p>
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-rassoc">rassoc</a>
</div>
</div>
<div id="method-i-at" class="method-detail ">
<div class="method-heading">
<span class="method-name">at</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="at-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1123</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">self</span>[(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])]
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer or Float. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-clear" class="method-detail ">
<div class="method-heading">
<span class="method-name">clear</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="clear-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1134</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">clear</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-clone" class="method-detail ">
<div class="method-heading">
<span class="method-name">clone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="clone-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 882</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">clone</span>()
<span class="ruby-identifier">initialize_dup</span>()
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-collect" class="method-detail ">
<div class="method-heading">
<span class="method-name">collect</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="collect-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1139</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">collect</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-map">map</a>
</div>
</div>
<div id="method-i-collect-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">collect!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="collect-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1154</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">collect!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">collect</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>).<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-map-21">map!</a>
</div>
</div>
<div id="method-i-combination" class="method-detail ">
<div class="method-heading">
<span class="method-name">combination</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="combination-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1163</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">combination</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># TODO: port c code to ruby (true-enumeration-as-bytearray support)</span>
<span class="ruby-identifier">enumerator</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:combination</span>,<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">enumerator</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_combination</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">the_combination</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># Note: this form does not put bytearrays of each combination into the block, just arrays (please fix)</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Enumerator</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">enumerator</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-compact" class="method-detail ">
<div class="method-heading">
<span class="method-name">compact</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="compact-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1190</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">compact</span>()
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-compact-21">compact!</a>
</div>
</div>
<div id="method-i-compact-21" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">compact!</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-compact">compact</a>
</div>
</div>
<div id="method-i-concat" class="method-detail ">
<div class="method-heading">
<span class="method-name">concat</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="concat-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1194</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">concat</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">other</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">other</span>
<span class="ruby-identifier">result</span> = (<span class="ruby-keyword">self</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">other</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">Exception</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Could not convert #{args.inspect} to ByteArray&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-count" class="method-detail ">
<div class="method-heading">
<span class="method-name">count</span><span
class="method-args">(match_value=nil,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="count-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1207</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">count</span>(<span class="ruby-identifier">match_value</span>=<span class="ruby-keyword">nil</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">match_value</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_byte</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">match_value</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>) <span class="ruby-operator">==</span> <span class="ruby-keyword">true</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cycle" class="method-detail ">
<div class="method-heading">
<span class="method-name">cycle</span><span
class="method-args">(iterations=nil,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="cycle-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1229</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cycle</span>(<span class="ruby-identifier">iterations</span>=<span class="ruby-keyword">nil</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">iterations</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">iterations</span>
<span class="ruby-identifier">iterations</span>.<span class="ruby-identifier">to_i</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">while</span> <span class="ruby-keyword">true</span> <span class="ruby-keyword">do</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:cycle</span>,<span class="ruby-identifier">iterations</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-data" class="method-detail ">
<div class="method-heading">
<span class="method-name">data</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="data-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 566</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">data</span>()
<span class="ruby-ivar">@data</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-dclone" class="method-detail ">
<div class="method-heading">
<span class="method-name">dclone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="dclone-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 860</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">dclone</span>()
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">clone</span>)
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">padvalue</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">padvalue</span>())
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">maxsize</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">maxsize</span>())
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">outervalue</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">outervalue</span>())
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="delete-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1254</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">comparitor</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">comparitor</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">comparitor</span> = <span class="ruby-identifier">comparitor</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">scrap</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-identifier">comparitor</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span> <span class="ruby-operator">==</span> <span class="ruby-ivar">@data</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">scrap</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete_at" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete_at</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="delete_at-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1274</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">the_range</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">last</span> <span class="ruby-operator">&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">slice!</span>(<span class="ruby-identifier">the_range</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete_if" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete_if</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="delete_if-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1285</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete_if</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">reject!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-drop" class="method-detail ">
<div class="method-heading">
<span class="method-name">drop</span><span
class="method-args">(length)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="drop-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1289</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">drop</span>(<span class="ruby-identifier">length</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice</span>((<span class="ruby-identifier">length</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)<span class="ruby-operator">..</span><span class="ruby-value">-1</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-drop_while" class="method-detail ">
<div class="method-heading">
<span class="method-name">drop_while</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="drop_while-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1293</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">drop_while</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">accumulator</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">accumulator</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">accumulator</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># TODO: 5xMem efficiency fix for various engine run conditions</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Enumeratior</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:drop_while</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-dup" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">dup</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-initialize_dup">initialize_dup</a>
</div>
</div>
<div id="method-i-each" class="method-detail ">
<div class="method-heading">
<span class="method-name">each</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>TODO: <a href="ByteArray.html#method-i-each_index"><code>GxG::ByteArray.each_index</code></a>/each_with_index: improve memory efficiency and speed significantly (!)</p>
<div class="method-source-code" id="each-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1311</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)}
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_index" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_index</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="each_index-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1322</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_index</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">index</span>)}
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each_index</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_with_index" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_with_index</span><span
class="method-args">(offset=0,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="each_with_index-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1333</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_with_index</span>(<span class="ruby-identifier">offset</span>=<span class="ruby-value">0</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-comment"># bulky, but required to support self.reject!, etc :</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">with_index</span>(<span class="ruby-identifier">offset</span>).<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">value</span>,<span class="ruby-identifier">index</span><span class="ruby-operator">|</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>,<span class="ruby-identifier">index</span>)}
<span class="ruby-comment">#old : (0..(@data.bytesize - 1)).to_enum.each {|index| block.call(@data[(index)].ord,index)}</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each_with_index</span>,<span class="ruby-identifier">offset</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-empty-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">empty?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="empty-3F-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1346</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">empty?</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-eql-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">eql?</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="eql-3F-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1350</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">eql?</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">self</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">false</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-fetch" class="method-detail ">
<div class="method-heading">
<span class="method-name">fetch</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="fetch-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1358</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">fetch</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment">#fetch(index) → obj click to toggle source</span>
<span class="ruby-comment">#fetch(index, default ) → obj</span>
<span class="ruby-comment">#fetch(index) {|index| block } → obj</span>
<span class="ruby-comment">#</span>
<span class="ruby-comment">#Tries to return the element at position index. If the index lies outside the array, the first form throws an IndexError exception,</span>
<span class="ruby-comment"># the second form returns default, and the third form returns the value of invoking the block, passing in the index.</span>
<span class="ruby-comment"># Negative values of index count from the end of the array.</span>
<span class="ruby-comment"># LATER: ByteArray.fetch: check how to incorporate &#39;padded-edges&#39; feature</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>).<span class="ruby-identifier">first</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;=</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">IndexError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;Index specified lies outside the ByteArray&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">at</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-fill" class="method-detail ">
<div class="method-heading">
<span class="method-name">fill</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="fill-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1387</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">fill</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment">#fill(obj) → ary click to toggle source</span>
<span class="ruby-comment">#fill(obj, start [, length]) → ary</span>
<span class="ruby-comment">#fill(obj, range ) → ary</span>
<span class="ruby-comment">#fill {|index| block } → ary</span>
<span class="ruby-comment">#fill(start [, length] ) {|index| block } → ary</span>
<span class="ruby-comment">#fill(range) {|index| block } → ary</span>
<span class="ruby-comment">#</span>
<span class="ruby-comment">#The first three forms set the selected elements of self (which may be the entire array) to obj. A start of nil is equivalent to zero.</span>
<span class="ruby-comment">#A length of nil is equivalent to self.length. The last three forms fill the array with the value of the block.</span>
<span class="ruby-comment">#The block is passed the absolute index of each element to be filled. Negative values of start count from the end of the array.</span>
<span class="ruby-comment">#a = [ &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; ]</span>
<span class="ruby-comment">#a.fill(&quot;x&quot;) #=&gt; [&quot;x&quot;, &quot;x&quot;, &quot;x&quot;, &quot;x&quot;]</span>
<span class="ruby-comment">#a.fill(&quot;z&quot;, 2, 2) #=&gt; [&quot;x&quot;, &quot;x&quot;, &quot;z&quot;, &quot;z&quot;]</span>
<span class="ruby-comment">#a.fill(&quot;y&quot;, 0..1) #=&gt; [&quot;y&quot;, &quot;y&quot;, &quot;z&quot;, &quot;z&quot;]</span>
<span class="ruby-comment">#a.fill {|i| i*i} #=&gt; [0, 1, 4, 9]</span>
<span class="ruby-comment">#a.fill(-2) {|i| i*i*i} #=&gt; [0, 1, 8, 27]</span>
<span class="ruby-comment"># Note: if ByteArray is empty, it will be filled to @max_size, otherwise only the used portion or specified range.</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">args</span> = [((<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])<span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)))]
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;length specified should be a positive Integer for Float&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">args</span> = [((<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])<span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">fillrange</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">fillrange</span> = (<span class="ruby-value">0</span><span class="ruby-operator">..</span>((<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
<span class="ruby-keyword">end</span>
(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">fillrange</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">index</span>)
<span class="ruby-identifier">raw_value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">index</span>))
<span class="ruby-keyword">if</span> <span class="ruby-identifier">raw_value</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-comment"># Allow only single byte results to merge into fill</span>
<span class="ruby-comment"># since the concept is &#39;per-item&#39; which in this case is a single byte only.</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">raw_value</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">index</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">case</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span>
<span class="ruby-keyword">when</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">fillrange</span> = (<span class="ruby-value">0</span><span class="ruby-operator">..</span>((<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">when</span> <span class="ruby-value">2</span>
<span class="ruby-identifier">fillrange</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">when</span> <span class="ruby-value">3</span>
<span class="ruby-identifier">fillrange</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>],<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>])
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">fillrange</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>],<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>])
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">value</span> = (<span class="ruby-identifier">value</span> <span class="ruby-operator">||</span> <span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">chr</span>)
<span class="ruby-comment">#</span>
(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">fillrange</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">index</span>)
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">index</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;wrong number of arguments (0 for 1..3)&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-find_index" class="method-detail ">
<div class="method-heading">
<span class="method-name">find_index</span><span
class="method-args">(*args, &amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="find_index-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1542</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">find_index</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">found_at</span> = <span class="ruby-value">0</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>) <span class="ruby-operator">==</span> <span class="ruby-keyword">true</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">found_at</span>
<span class="ruby-keyword">break</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">found_at</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> (<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">255</span>).<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]
<span class="ruby-comment"># offset specified (addtional option vs standard Array)</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">chr</span>,<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">chr</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer or Float. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-rindex">rindex</a>, <a href="ByteArray.html#method-i-index">index</a>
</div>
</div>
<div id="method-i-first" class="method-detail ">
<div class="method-heading">
<span class="method-name">first</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="first-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1479</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">first</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{args[0]} is out of range (1 - #{@max_size}).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>[(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-flatten" class="method-detail ">
<div class="method-heading">
<span class="method-name">flatten</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="flatten-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1501</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">flatten</span>()
<span class="ruby-comment"># ByteArray is always flat anyhow</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-flatten-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">flatten!</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="flatten-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1506</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">flatten!</span>()
<span class="ruby-comment"># ByteArray is always flat anyhow</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-freeze" class="method-detail ">
<div class="method-heading">
<span class="method-name">freeze</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="freeze-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1511</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">freeze</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-ivar">@outer</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">super</span>()
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-get_at_path" class="method-detail ">
<div class="method-heading">
<span class="method-name">get_at_path</span><span
class="method-args">(the_path=&quot;/&quot;)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="get_at_path-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2191</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get_at_path</span>(<span class="ruby-identifier">the_path</span>=<span class="ruby-string">&quot;/&quot;</span>)
<span class="ruby-comment"># TODO: question: would it serve much to allow ranges as structure-path specifier? What would that involve?</span>
<span class="ruby-comment"># /^(?:[0-9])*[0-9](?:[0-9])*$/ = nil if an alpha present there, else 0 only numeric</span>
<span class="ruby-comment"># Attribution : http://stackoverflow.com/questions/1240674/regex-match-a-string-containing-numbers-and-letters-but-not-a-string-of-just-nu</span>
<span class="ruby-comment">#</span>
<span class="ruby-comment"># if &quot;:&quot; detected do: (str.gsub(&quot;%2f&quot;,&quot;/&quot;).to_sym) as key else (str.gsub(&quot;%2f&quot;,&quot;/&quot;))</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_path</span> <span class="ruby-operator">==</span> <span class="ruby-string">&quot;/&quot;</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">object_stack</span> = [(<span class="ruby-keyword">self</span>)]
<span class="ruby-identifier">path_stack</span> = <span class="ruby-identifier">the_path</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">&quot;/&quot;</span>)
<span class="ruby-identifier">path_stack</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">path_element</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">element</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">path_element</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">path_element</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/^(?:[0-9])*[0-9](?:[0-9])*$/</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">element</span> = <span class="ruby-identifier">path_element</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">element</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">object_stack</span>.<span class="ruby-identifier">first</span>[(<span class="ruby-identifier">element</span>)]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">NilClass</span>)
<span class="ruby-keyword">break</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">object_stack</span>.<span class="ruby-identifier">unshift</span>(<span class="ruby-identifier">result</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># ignore double slashes? &#39;//&#39;</span>
<span class="ruby-comment"># break</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-hash" class="method-detail ">
<div class="method-heading">
<span class="method-name">hash</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="hash-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1519</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hash</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">hash</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-include-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">include?</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="include-3F-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1523</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">include?</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> (<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">255</span>).<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">chr</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Value out of range: range is 0 to 255. You provided #{args[0]}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer or Float. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Wrong number of arguments (#{args.size} for 1).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-index" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">index</span><span
class="method-args">(*args, &amp;block)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-find_index">find_index</a>
</div>
</div>
<div id="method-i-indexes" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">indexes</span><span
class="method-args">(*args)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-values_at">values_at</a>
</div>
</div>
<div id="method-i-indices" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">indices</span><span
class="method-args">(*args)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-values_at">values_at</a>
</div>
</div>
<div id="method-i-initialize_clone" class="method-detail ">
<div class="method-heading">
<span class="method-name">initialize_clone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="initialize_clone-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 868</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize_clone</span>()
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">frozen?</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-initialize_copy" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">initialize_copy</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-initialize_dup">initialize_dup</a>
</div>
</div>
<div id="method-i-initialize_dup" class="method-detail ">
<div class="method-heading">
<span class="method-name">initialize_dup</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="initialize_dup-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 876</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize_dup</span>()
<span class="ruby-comment"># ByteArry is one-dimensional anyhow</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-dup">dup</a>, <a href="ByteArray.html#method-i-initialize_copy">initialize_copy</a>
</div>
</div>
<div id="method-i-insert" class="method-detail ">
<div class="method-heading">
<span class="method-name">insert</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="insert-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1577</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">insert</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-identifier">value</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">args</span>[(<span class="ruby-value">1</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))])
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">unless</span> (<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bytesize</span>) <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Operation exceeds #{@max_size} limit. You need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>],<span class="ruby-identifier">value</span>)
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">Exception</span> <span class="ruby-operator">=&gt;</span> <span class="ruby-identifier">error</span>
<span class="ruby-identifier">raise</span> <span class="ruby-identifier">error</span>.<span class="ruby-identifier">exception</span>(<span class="ruby-identifier">error</span>.<span class="ruby-identifier">message</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-string">&quot;string&quot;</span>,(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">to_s</span>)))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer or Float. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Wrong number of arguments (#{args.size} for 2).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-name">inspect</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="inspect-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1603</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">inspect</span>()
<span class="ruby-identifier">result</span> = <span class="ruby-string">&quot;[&quot;</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-string">&quot;, &quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_byte</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">10</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;0x#{the_byte.to_s(16).upcase}&quot;</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-node">&quot;0x0#{the_byte.to_s(16).upcase}&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-string">&quot;]&quot;</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-join" class="method-detail ">
<div class="method-heading">
<span class="method-name">join</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="join-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1619</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">join</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Encoding</span>)
<span class="ruby-comment"># Extra optional encoding vs standard Array</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">String</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>)
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> <span class="ruby-identifier">the_byte</span>.<span class="ruby-identifier">chr</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-keep_if" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">keep_if</span><span
class="method-args">(&amp;block)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-select-21">select!</a>
</div>
</div>
<div id="method-i-last" class="method-detail ">
<div class="method-heading">
<span class="method-name">last</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="last-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1637</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">last</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">the_range</span> = ((<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-operator">-</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))<span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{args[0]} is out of range (1 - #{@max_size}).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>[(<span class="ruby-identifier">the_range</span>)]
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">RangeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{args[0]} is out of range (1 - #{@max_size}).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>[(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-length" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">length</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-size">size</a>
</div>
</div>
<div id="method-i-map" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">map</span><span
class="method-args">(&amp;block)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-collect">collect</a>
</div>
</div>
<div id="method-i-map-21" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">map!</span><span
class="method-args">(&amp;block)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-collect-21">collect!</a>
</div>
</div>
<div id="method-i-match" class="method-detail ">
<div class="method-heading">
<span class="method-name">match</span><span
class="method-args">(regular_expression)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="match-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 791</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">match</span>(<span class="ruby-identifier">regular_expression</span>)
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">regular_expression</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-maxsize" class="method-detail ">
<div class="method-heading">
<span class="method-name">maxsize</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="maxsize-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 795</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">maxsize</span>()
<span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-maxsize-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">maxsize=</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="maxsize-3D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 799</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">maxsize=</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-comment"># Set @maxsize: Warning: setting @maxsize lower than the @data.bytesize will truncate the data</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;</span> <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">SYSTEM</span>.<span class="ruby-identifier">memory_limits</span>()[<span class="ruby-value">:process</span>].<span class="ruby-identifier">first</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">NoMemoryError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">&quot;Setting maxsize this high exceeds per-process memory limits&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-comment"># truncate data if @max_size lowered below @data.bytesize</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-ivar">@data</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)])
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected NilClass or Numeric class. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@max_size</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-mime_type" class="method-detail ">
<div class="method-heading">
<span class="method-name">mime_type</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="mime_type-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 687</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">mime_type</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">mime_type</span>()
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-nitems" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">nitems</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-size">size</a>
</div>
</div>
<div id="method-i-outervalue" class="method-detail ">
<div class="method-heading">
<span class="method-name">outervalue</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="outervalue-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 834</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">outervalue</span>()
<span class="ruby-ivar">@outer</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-outervalue-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">outervalue=</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="outervalue-3D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 838</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">outervalue=</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> (<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">255</span>).<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-ivar">@outer</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected a NilClass, a Float, or a Integer. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@outer</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@outer</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">outervalue</span>()
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-pack" class="method-detail ">
<div class="method-heading">
<span class="method-name">pack</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="pack-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1662</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">pack</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = (<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">||</span> <span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">String</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Encoding</span>)
<span class="ruby-comment"># Extra optional encoding vs standard Array</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])
<span class="ruby-keyword">end</span>
<span class="ruby-comment"># LATER: ByteArray.pack: a more memory-efficient method is needed here long term. For now: leverage Array.pack.</span>
<span class="ruby-comment"># Each byte will take up 4 to 8 bytes depending just to get packed into a string ... gotta fix this.</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">pack</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected String. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Wrong number of arguments (#{args.size} for 1+).&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-padvalue" class="method-detail ">
<div class="method-heading">
<span class="method-name">padvalue</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="padvalue-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 771</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">padvalue</span>()
<span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-padvalue-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">padvalue=</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="padvalue-3D-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 775</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">padvalue=</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Float</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> (<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">255</span>).<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])
<span class="ruby-ivar">@pad_value</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Value type: expected Float or Integer. You provided #{args[0].class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-paths_to" class="method-detail ">
<div class="method-heading">
<span class="method-name">paths_to</span><span
class="method-args">(object=nil,base_path=&quot;&quot;)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p><a href="../GxG.html"><code>GxG</code></a> Convenience Methods:</p>
<div class="method-source-code" id="paths_to-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2177</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">paths_to</span>(<span class="ruby-identifier">object</span>=<span class="ruby-keyword">nil</span>,<span class="ruby-identifier">base_path</span>=<span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-comment"># new idea here:</span>
<span class="ruby-identifier">search_results</span> = []
<span class="ruby-comment"># TODO: if paths can use ranges, expand to use string or byte or int byte or byte-pattern matching to define returned valid path for get/set.</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">object</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">entry</span>,<span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">entry</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">object</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-identifier">search_results</span> <span class="ruby-operator">&lt;&lt;</span> (<span class="ruby-identifier">base_path</span> <span class="ruby-operator">+</span> <span class="ruby-string">&quot;/&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">index</span>.<span class="ruby-identifier">to_s</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">search_results</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-pattern_range" class="method-detail ">
<div class="method-heading">
<span class="method-name">pattern_range</span><span
class="method-args">(the_pattern=&quot;&quot;, initial_offset=0)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="pattern_range-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 721</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">pattern_range</span>(<span class="ruby-identifier">the_pattern</span>=<span class="ruby-string">&quot;&quot;</span>, <span class="ruby-identifier">initial_offset</span>=<span class="ruby-value">0</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">the_pattern</span> = <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">to_s</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">String</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">initial_offset</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Integer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">initial_offset</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">&quot;Offset exceeds the maximum size.&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">encoding</span> <span class="ruby-operator">!=</span> <span class="ruby-operator">::</span><span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>
<span class="ruby-identifier">the_pattern</span> = <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">offset</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">the_pattern</span>, <span class="ruby-identifier">initial_offset</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">offset</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Integer</span>)
<span class="ruby-identifier">result</span> = ((<span class="ruby-identifier">offset</span>)<span class="ruby-operator">..</span>(<span class="ruby-identifier">offset</span> <span class="ruby-operator">+</span> (<span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">&quot;You MUST provide the offset as an Integer.&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">&quot;You MUST provide a String to find.&quot;</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-pattern_ranges" class="method-detail ">
<div class="method-heading">
<span class="method-name">pattern_ranges</span><span
class="method-args">(the_pattern=&quot;&quot;)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="pattern_ranges-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 750</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">pattern_ranges</span>(<span class="ruby-identifier">the_pattern</span>=<span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-identifier">result</span> = []
<span class="ruby-identifier">offset</span> = <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">the_pattern</span> = <span class="ruby-identifier">the_pattern</span>.<span class="ruby-identifier">to_s</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">last_found</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">pattern_range</span>(<span class="ruby-identifier">the_pattern</span>,<span class="ruby-identifier">offset</span>)
<span class="ruby-keyword">while</span> <span class="ruby-identifier">last_found</span> <span class="ruby-operator">!=</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">do</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">last_found</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Range</span>)
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">last_found</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">last_found</span>.<span class="ruby-identifier">last</span>() <span class="ruby-operator">+</span> <span class="ruby-value">1</span>) <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-identifier">offset</span> = (<span class="ruby-identifier">last_found</span>.<span class="ruby-identifier">last</span>() <span class="ruby-operator">+</span> <span class="ruby-value">1</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">break</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">last_found</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">pattern_range</span>(<span class="ruby-identifier">the_pattern</span>,<span class="ruby-identifier">offset</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-permutation" class="method-detail ">
<div class="method-heading">
<span class="method-name">permutation</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="permutation-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1683</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">permutation</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># TODO: port c code to ruby (true-enumeration-as-bytearray support)</span>
<span class="ruby-identifier">enumerator</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:permutation</span>,<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">enumerator</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_permutation</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">the_permutation</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Enumerator</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">enumerator</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-pop" class="method-detail ">
<div class="method-heading">
<span class="method-name">pop</span><span
class="method-args">(how_many=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="pop-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1709</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">pop</span>(<span class="ruby-identifier">how_many</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-comment"># LIFO style stack operation</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">how_many</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">how_many</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{how_many} needs to be a positive Numeric&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice!</span>((<span class="ruby-identifier">how_many</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">*</span> <span class="ruby-value">-1</span>),(<span class="ruby-identifier">how_many</span>.<span class="ruby-identifier">to_i</span>))
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice!</span>(<span class="ruby-value">-1</span>,<span class="ruby-value">1</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-process" class="method-detail ">
<div class="method-heading">
<span class="method-name">process</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="process-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 691</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">process</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">entry</span>,<span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">entry</span>, <span class="ruby-identifier">index</span>, <span class="ruby-keyword">self</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-process-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">process!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="process-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 701</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">process!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">process</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>).<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-product" class="method-detail ">
<div class="method-heading">
<span class="method-name">product</span><span
class="method-args">(*others,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="product-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1721</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">product</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">others</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">others</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">others</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">others</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">other_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>([(<span class="ruby-identifier">the_byte</span>),(<span class="ruby-identifier">other_byte</span>)]))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">accumulator</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">others</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">other_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">accumulator</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>
<span class="ruby-identifier">accumulator</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">other_byte</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">accumulator</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-push" class="method-detail ">
<div class="method-heading">
<span class="method-name">push</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="push-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1746</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">push</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-comment"># LIFO style stack operation</span>
<span class="ruby-keyword">self</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-rassoc" class="method-detail ">
<div class="method-heading">
<span class="method-name">rassoc</span><span
class="method-args">(key=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="rassoc-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1751</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">rassoc</span>(<span class="ruby-identifier">key</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-assoc">assoc</a>
</div>
</div>
<div id="method-i-reject" class="method-detail ">
<div class="method-heading">
<span class="method-name">reject</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="reject-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1755</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reject</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">padvalue</span> = (<span class="ruby-ivar">@pad_value</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">maxsize</span> = (<span class="ruby-ivar">@max_size</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-reject-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">reject!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="reject-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1772</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reject!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">purgelist</span> = []
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">value</span>, <span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>) <span class="ruby-operator">==</span> <span class="ruby-keyword">true</span>
<span class="ruby-ivar">@data</span>[(<span class="ruby-identifier">index</span>)] = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">purgelist</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">index</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:reject!</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-repeated_combination" class="method-detail ">
<div class="method-heading">
<span class="method-name">repeated_combination</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="repeated_combination-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1177</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">repeated_combination</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># TODO: port c code to ruby (true-enumeration-as-bytearray support)</span>
<span class="ruby-identifier">enumerator</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:repeated_combination</span>,<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">enumerator</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_combination</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">the_combination</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Enumerator</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">enumerator</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-repeated_permutation" class="method-detail ">
<div class="method-heading">
<span class="method-name">repeated_permutation</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="repeated_permutation-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1696</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">repeated_permutation</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># TODO: port c code to ruby (true-enumeration-as-bytearray support)</span>
<span class="ruby-identifier">enumerator</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:repeated_permutation</span>,<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">enumerator</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_permutation</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">the_permutation</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Enumerator</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">enumerator</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-replace" class="method-detail ">
<div class="method-heading">
<span class="method-name">replace</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="replace-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1789</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">replace</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-comment"># replace data payload while leaving max_size and pad_value untouched, fitting replacement data into in-place constraints if any.</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">replacement</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">replacement</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">String</span>)
<span class="ruby-identifier">replacement</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">replacement</span>
<span class="ruby-identifier">replacement</span> = <span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">replacement</span>
<span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">replacement</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">replacement</span>[(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))])
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">replacement</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">Exception</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Could not convert #{args[0].class} to ByteArray&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-reverse" class="method-detail ">
<div class="method-heading">
<span class="method-name">reverse</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="reverse-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1820</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reverse</span>()
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">reverse</span>)
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">padvalue</span> = (<span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">clone</span>)
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">maxsize</span> = (<span class="ruby-ivar">@max_size</span>.<span class="ruby-identifier">clone</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-reverse-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">reverse!</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="reverse-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1829</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reverse!</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">reverse!</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-reverse_each" class="method-detail ">
<div class="method-heading">
<span class="method-name">reverse_each</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="reverse_each-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1834</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">reverse_each</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-comment"># use duplicate of self, do not preserve frozen state.</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">dup</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">clear</span>
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">reverse</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)}
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># ballons mem footprint x2: *ouch* - don&#39;t know a better way yet.</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">clone</span>.<span class="ruby-identifier">reverse!</span>.<span class="ruby-identifier">to_enum</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-rindex" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">rindex</span><span
class="method-args">(*args, &amp;block)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-find_index">find_index</a>
</div>
</div>
<div id="method-i-rotate" class="method-detail ">
<div class="method-heading">
<span class="method-name">rotate</span><span
class="method-args">(vector=1)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="rotate-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1848</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">rotate</span>(<span class="ruby-identifier">vector</span>=<span class="ruby-value">1</span>)
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">vector</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected a Numeric, you provided #{vector.class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-comment"># from array.c : rotate_count</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">vector</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">vector</span> = (<span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> (<span class="ruby-operator">~</span><span class="ruby-identifier">vector</span> <span class="ruby-operator">%</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>) <span class="ruby-operator">-</span> <span class="ruby-value">1</span>).<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">vector</span> = (<span class="ruby-identifier">vector</span> <span class="ruby-operator">%</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>).<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">Engine</span>.<span class="ruby-identifier">memory_load_high?</span>
<span class="ruby-comment"># trade speed for (2x) space</span>
<span class="ruby-identifier">scrap</span> = []
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">vector</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">the_range</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(((<span class="ruby-identifier">vector</span>)<span class="ruby-operator">..</span><span class="ruby-value">-1</span>))
<span class="ruby-identifier">scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>[(<span class="ruby-identifier">the_range</span>)]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>[(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">scrap</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># trade (5x) space for speed</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">rotate</span>(<span class="ruby-identifier">vector</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-rotate-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">rotate!</span><span
class="method-args">(vector=1)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="rotate-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1880</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">rotate!</span>(<span class="ruby-identifier">vector</span>=<span class="ruby-value">1</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">vector</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">vector</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">!=</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">new_data</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">rotate</span>(<span class="ruby-identifier">vector</span>).<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">unless</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">hash</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">new_data</span>.<span class="ruby-identifier">hash</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">new_data</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected a Numeric, you provided #{vector.class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-sample" class="method-detail ">
<div class="method-heading">
<span class="method-name">sample</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="sample-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1894</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sample</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">sample</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>))
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-search" class="method-detail ">
<div class="method-heading">
<span class="method-name">search</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="search-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 708</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">search</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = []
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">entry</span>,<span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">raw_result</span> = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">entry</span>,<span class="ruby-identifier">index</span>,<span class="ruby-keyword">self</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">raw_result</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">raw_result</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-select" class="method-detail ">
<div class="method-heading">
<span class="method-name">select</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="select-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1898</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">select</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">maxsize</span> = (<span class="ruby-ivar">@max_size</span>)
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">padvalue</span> = (<span class="ruby-ivar">@pad_value</span>)
<span class="ruby-identifier">result</span>.<span class="ruby-identifier">outervalue</span> = (<span class="ruby-ivar">@outer</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">value</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>) <span class="ruby-operator">==</span> <span class="ruby-keyword">false</span>
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-select-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">select!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="select-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1915</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">select!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">state</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">hash</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">select</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>).<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">if</span> <span class="ruby-identifier">state</span> <span class="ruby-operator">==</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">hash</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-keep_if">keep_if</a>
</div>
</div>
<div id="method-i-set_at_path" class="method-detail ">
<div class="method-heading">
<span class="method-name">set_at_path</span><span
class="method-args">(the_path=&quot;/&quot;,the_value=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="set_at_path-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2226</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">set_at_path</span>(<span class="ruby-identifier">the_path</span>=<span class="ruby-string">&quot;/&quot;</span>,<span class="ruby-identifier">the_value</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_path</span> <span class="ruby-operator">!=</span> <span class="ruby-string">&quot;/&quot;</span>
<span class="ruby-identifier">container</span> = <span class="ruby-keyword">self</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">container</span>
<span class="ruby-identifier">raw_selector</span> = <span class="ruby-operator">::</span><span class="ruby-constant">File</span><span class="ruby-operator">::</span><span class="ruby-identifier">basename</span>(<span class="ruby-identifier">the_path</span>)
<span class="ruby-identifier">selector</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">raw_selector</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">if</span> (<span class="ruby-identifier">raw_selector</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/^(?:[0-9])*[0-9](?:[0-9])*$/</span>) <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">selector</span> = <span class="ruby-identifier">raw_selector</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">selector</span>
<span class="ruby-identifier">container</span>[(<span class="ruby-identifier">selector</span>)] = <span class="ruby-identifier">the_value</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">container</span>[(<span class="ruby-identifier">selector</span>)] <span class="ruby-operator">==</span> <span class="ruby-identifier">the_value</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">true</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-comment"># ignore double slashes? &#39;//&#39;</span>
<span class="ruby-comment"># break</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-shift" class="method-detail ">
<div class="method-heading">
<span class="method-name">shift</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="shift-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1929</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">shift</span>()
<span class="ruby-comment"># FIFO style pop</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">delete_at</span>(<span class="ruby-value">0</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-shuffle" class="method-detail ">
<div class="method-heading">
<span class="method-name">shuffle</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="shuffle-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1934</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">shuffle</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:bytes</span>).<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">shuffle</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>))
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-shuffle-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">shuffle!</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="shuffle-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1938</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">shuffle!</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">shuffle</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>))
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-size" class="method-detail ">
<div class="method-heading">
<span class="method-name">size</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="size-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1943</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">size</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-length">length</a>, <a href="ByteArray.html#method-i-nitems">nitems</a>
</div>
</div>
<div id="method-i-slice" class="method-detail ">
<div class="method-heading">
<span class="method-name">slice</span><span
class="method-args">(indexer=0, length=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="slice-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1947</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">slice</span>(<span class="ruby-identifier">indexer</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">length</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-identifier">the_range</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_parameters</span>(<span class="ruby-identifier">indexer</span>,<span class="ruby-identifier">length</span>)
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">the_range</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">length</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{indexer.inspect},#{length.inspect} could not be fashioned into a valid Indexer&quot;</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;#{indexer.inspect} could not be fashioned into a valid Indexer&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment"># check overall compliance with maxsize</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@max_size</span>
<span class="ruby-keyword">if</span> ((<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">count</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@max_size</span>) <span class="ruby-operator">||</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)) <span class="ruby-operator">||</span> (<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">last</span> <span class="ruby-operator">&gt;</span> (<span class="ruby-ivar">@max_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)))
<span class="ruby-identifier">raise</span> <span class="ruby-constant">IndexError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Index exceeds #{@max_size} limit. You need to adjust maxsize.&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">last</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">byte_at</span>(<span class="ruby-identifier">the_range</span>.<span class="ruby-identifier">first</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytes_at</span>(<span class="ruby-identifier">the_range</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-slice-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">slice!</span><span
class="method-args">(indexer=0, length=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="slice-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1976</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">slice!</span>(<span class="ruby-identifier">indexer</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">length</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-identifier">replacement</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice</span>(<span class="ruby-identifier">indexer</span>,<span class="ruby-identifier">length</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">replacement</span>.<span class="ruby-identifier">chr</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">replacement</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice</span>(<span class="ruby-value">0</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-sort" class="method-detail ">
<div class="method-heading">
<span class="method-name">sort</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>BETA: <a href="ByteArray.html"><code>ByteArray</code></a> : see about self.to_a replacement (memory efficiency) in sort methods.</p>
<div class="method-source-code" id="sort-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 1992</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sort</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">sort</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">a</span>,<span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">pause</span>;<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">a</span>,<span class="ruby-identifier">b</span>)})
<span class="ruby-keyword">else</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">sort</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-sort-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">sort!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="sort-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2000</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sort!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">sort</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>).<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-sort_by-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">sort_by!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="sort_by-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2007</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sort_by!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">sort_by!</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">a</span>,<span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">pause</span>;<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">a</span>,<span class="ruby-identifier">b</span>)}).<span class="ruby-identifier">data</span>())
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:sort_by!</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-take" class="method-detail ">
<div class="method-heading">
<span class="method-name">take</span><span
class="method-args">(length)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="take-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2016</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">take</span>(<span class="ruby-identifier">length</span>)
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">slice</span>(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">length</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-take_while" class="method-detail ">
<div class="method-heading">
<span class="method-name">take_while</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="take_while-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2020</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">take_while</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">accumulator</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">the_byte</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">result</span> = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">the_byte</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">result</span>
<span class="ruby-identifier">accumulator</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">the_byte</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">break</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">accumulator</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:take_while</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-to_a" class="method-detail ">
<div class="method-heading">
<span class="method-name">to_a</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="to_a-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2037</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_a</span>()
<span class="ruby-identifier">result</span> = []
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
(<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)).<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>[(<span class="ruby-identifier">index</span>)]}
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-to_ary">to_ary</a>
</div>
</div>
<div id="method-i-to_ary" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">to_ary</span><span
class="method-args">()</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="ByteArray.html#method-i-to_a">to_a</a>
</div>
</div>
<div id="method-i-to_json" class="method-detail ">
<div class="method-heading">
<span class="method-name">to_json</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="to_json-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2049</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_json</span>()
((<span class="ruby-string">&quot;binary:&quot;</span> <span class="ruby-operator">+</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_s</span>).<span class="ruby-identifier">encode64</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-to_s" class="method-detail ">
<div class="method-heading">
<span class="method-name">to_s</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="to_s-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2045</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_s</span>()
<span class="ruby-ivar">@data</span>.<span class="ruby-identifier">dup</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-transpose" class="method-detail ">
<div class="method-heading">
<span class="method-name">transpose</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="transpose-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2053</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">transpose</span>()
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-uniq" class="method-detail ">
<div class="method-heading">
<span class="method-name">uniq</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="uniq-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2057</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">uniq</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-identifier">harness</span> = <span class="ruby-constant">Proc</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">element</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">pause</span>
<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">element</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>.<span class="ruby-identifier">to_a</span>.<span class="ruby-identifier">uniq</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">harness</span>))
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-uniq-21" class="method-detail ">
<div class="method-heading">
<span class="method-name">uniq!</span><span
class="method-args">(&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="uniq-21-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2069</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">uniq!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">scrap</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">uniq</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">==</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">size</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-identifier">scrap</span>)
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-unshift" class="method-detail ">
<div class="method-heading">
<span class="method-name">unshift</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="unshift-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2079</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">unshift</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-comment"># FIFO style push</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">insert</span>(<span class="ruby-value">0</span>,<span class="ruby-identifier">args</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-values_at" class="method-detail ">
<div class="method-heading">
<span class="method-name">values_at</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="values_at-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2087</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">values_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-identifier">args</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">selector</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">selector</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>) <span class="ruby-keyword">or</span> <span class="ruby-identifier">selector</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Range</span>)
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">selector</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Range</span>)
<span class="ruby-identifier">selector</span> = <span class="ruby-identifier">selector</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">scrap</span> = <span class="ruby-keyword">self</span>[(<span class="ruby-identifier">selector</span>)]
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Integer</span>)
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Expected Integer, Float or Range. You provided #{selector.class}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="ByteArray.html#method-i-indices">indices</a>, <a href="ByteArray.html#method-i-indexes">indexes</a>
</div>
</div>
<div id="method-i-zip" class="method-detail ">
<div class="method-heading">
<span class="method-name">zip</span><span
class="method-args">(*args,&amp;block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="zip-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 2112</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">zip</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>,<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
<span class="ruby-comment"># Converts any valid argument values to array, then merges elements of self with corresponding elements from each argument</span>
<span class="ruby-comment"># This generates a sequence of self.size n-element ByteArrays as step buffers, where n is one more that the count of arguments</span>
<span class="ruby-comment"># * Then flattened output as ByteArray *</span>
<span class="ruby-comment"># If the size of any argument is less than enumObj.size, @pad_value is supplied</span>
<span class="ruby-comment"># If a block given, it is invoked for each output array.</span>
<span class="ruby-comment"># If block returns an array or ByteArray, it replaces the provided buffer and is appended to output.</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">result_scrap</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">result_scrap</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-identifier">args</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each_index</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">args</span>[(<span class="ruby-identifier">index</span>)].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">args</span>[(<span class="ruby-identifier">index</span>)] = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">args</span>[(<span class="ruby-identifier">index</span>)])
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">byte</span>,<span class="ruby-identifier">index</span><span class="ruby-operator">|</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">buffer</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">buffer</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-identifier">buffer</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">byte</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-identifier">args</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:each_index</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">arg_index</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">index</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">args</span>[(<span class="ruby-identifier">arg_index</span>)].<span class="ruby-identifier">size</span>
<span class="ruby-identifier">buffer</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">buffer</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">args</span>[(<span class="ruby-identifier">arg_index</span>)].<span class="ruby-identifier">data</span>()[(<span class="ruby-identifier">index</span>)]
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:call</span>)
<span class="ruby-comment"># I want to differ from stock array.zip behavior:</span>
<span class="ruby-comment"># I want to have it possible to return the processed buffer back -</span>
<span class="ruby-comment"># to a result ByteArray if result of yield = array/ByteArray.</span>
<span class="ruby-identifier">raw_new</span> = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">buffer</span>))
<span class="ruby-keyword">if</span> <span class="ruby-identifier">raw_new</span>
<span class="ruby-identifier">buffer</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">raw_new</span>).<span class="ruby-identifier">data</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result_scrap</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">buffer</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">result_scrap</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-7C" class="method-detail ">
<div class="method-heading">
<span class="method-name">|</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="7C-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 981</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">|</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">scrap</span> = <span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span><span class="ruby-operator">::</span><span class="ruby-identifier">try_convert</span>(<span class="ruby-identifier">args</span>)
<span class="ruby-identifier">result</span> = <span class="ruby-keyword">self</span>.<span class="ruby-identifier">dclone</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">scrap</span>
<span class="ruby-identifier">scrap</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">byte</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">result</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">byte</span>)
<span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">byte</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">result</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="protected-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Protected Instance Methods</h3>
</header>
<div id="method-i-filter_data" class="method-detail ">
<div class="method-heading">
<span class="method-name">filter_data</span><span
class="method-args">(the_data=&quot;&quot;)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="filter_data-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 445</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">filter_data</span>(<span class="ruby-identifier">the_data</span>=<span class="ruby-string">&quot;&quot;</span>)
<span class="ruby-comment">#</span>
<span class="ruby-identifier">error_message</span> = (<span class="ruby-node">&quot;ByteArray.new expects a String, a Integer or Float between 0 and 255, a nil ( counted as padvalue() ), a ByteArray, or an Array of any of those; you provided #{the_data.inspect}&quot;</span>)
<span class="ruby-comment">#</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">is_any?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">NilClass</span>,<span class="ruby-operator">::</span><span class="ruby-constant">String</span>,<span class="ruby-operator">::</span><span class="ruby-constant">Numeric</span>, <span class="ruby-operator">::</span><span class="ruby-constant">Array</span>, <span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">Exception</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">error_message</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">String</span>)
<span class="ruby-identifier">the_data</span> = <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">slice_bytes</span>((<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">-1</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">the_data</span> = <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> (<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">255</span>).<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">the_data</span>)
<span class="ruby-identifier">the_data</span> = <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">Exception</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">error_message</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">GxG</span><span class="ruby-operator">::</span><span class="ruby-constant">ByteArray</span>)
<span class="ruby-identifier">the_data</span> = <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">data</span>().<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-operator">::</span><span class="ruby-constant">Array</span>)
<span class="ruby-identifier">temp_string</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">temp_string</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">flatten</span>.<span class="ruby-identifier">to_enum</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">element</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">temp_string</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">filter_data</span>(<span class="ruby-identifier">element</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">temp_string</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">the_data</span> = <span class="ruby-identifier">temp_string</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">the_data</span> = <span class="ruby-string">&quot;&quot;</span>
<span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">the_data</span>
<span class="ruby-identifier">the_data</span> = <span class="ruby-ivar">@pad_value</span>.<span class="ruby-identifier">to_i</span>.<span class="ruby-identifier">chr</span>
<span class="ruby-identifier">the_data</span>.<span class="ruby-identifier">force_encoding</span>(<span class="ruby-constant">Encoding</span><span class="ruby-operator">::</span><span class="ruby-constant">ASCII_8BIT</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-comment">#</span>
<span class="ruby-identifier">the_data</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-filter_parameters" class="method-detail ">
<div class="method-heading">
<span class="method-name">filter_parameters</span><span
class="method-args">(*args)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="filter_parameters-source">
<pre><span class="ruby-comment"># File lib/gxg/gxg_elements.rb, line 488</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">filter_parameters</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-identifier">the_range</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">the_range</span> = ((<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])<span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]))
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Numeric</span>)
<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">to_i</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">&lt;</span> <span class="ruby-value">1</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;Second parameter needs to be a Numeric greater than 0, you provided #{args[1].inspect}&quot;</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">the_range</span> = ((<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>])<span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> (<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Range</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">first</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">first</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">first</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">last</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>] = <span class="ruby-ivar">@data</span>.<span class="ruby-identifier">bytesize</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">last</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>] = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">last</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>] <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>]
<span class="ruby-identifier">the_range</span> = ((<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>])<span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>]))
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">the_range</span> = ((<span class="ruby-identifier">args</span>[<span class="ruby-value">2</span>])<span class="ruby-operator">..</span>(<span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-node">&quot;First parameter needs to be a Numeric or a Range, you provided #{args[0].inspect}&quot;</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">the_range</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.1.2.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>
Reference in a new issue View git blame Copy permalink