lili/opennurbs
1
0
Fork 0
mirror of https://github.com/mcneel/opennurbs.git synced 2026-03-30 23:57:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Publish!

Browse Source 
Generated from v6.0.11315.11111-test13
This commit is contained in:
Bozo
2018-02-02 07:57:49 -08:00
parent db96b72945
commit 9af473956f
957 changed files with 32952 additions and 16598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
6/dc/dfe/class_o_n___simple_array.html
View File

@@ -63,23 +63,19 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:a2167720a815f88f9cf70acccbb8f22a2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Copy constructor. <a href="#a2167720a815f88f9cf70acccbb8f22a2">More...</a><br /></td></tr>
<tr class="separator:a2167720a815f88f9cf70acccbb8f22a2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa4ba7b7d949098cba1e14d26eb0ee473"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4ba7b7d949098cba1e14d26eb0ee473">ON_SimpleArray</a> (size_t)</td></tr>
<tr class="memdesc:aa4ba7b7d949098cba1e14d26eb0ee473"><td class="mdescLeft">&#160;</td><td class="mdescRight">size_t parameter = initial capacity <a href="#aa4ba7b7d949098cba1e14d26eb0ee473">More...</a><br /></td></tr>
<tr class="separator:aa4ba7b7d949098cba1e14d26eb0ee473"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af6ae46b8e2bc5ee8f0803fc87e60d4cc"><td class="memItemLeft" align="right" valign="top">virtual&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#af6ae46b8e2bc5ee8f0803fc87e60d4cc">~ON_SimpleArray</a> ()</td></tr>
<tr class="separator:af6ae46b8e2bc5ee8f0803fc87e60d4cc"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a191f36f7af3813d99dac25c910a7f9a5"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a191f36f7af3813d99dac25c910a7f9a5">Append</a> (const T &amp;)</td></tr>
<tr class="separator:a191f36f7af3813d99dac25c910a7f9a5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5e10b309af51f313e265059bb1240559"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a5e10b309af51f313e265059bb1240559">Append</a> (int, const T *)</td></tr>
<tr class="memdesc:a5e10b309af51f313e265059bb1240559"><td class="mdescLeft">&#160;</td><td class="mdescRight">Append copy of an array T[count]. <a href="#a5e10b309af51f313e265059bb1240559">More...</a><br /></td></tr>
<tr class="separator:a5e10b309af51f313e265059bb1240559"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad6fb51ad272618b034b8dd4695094a2d"><td class="memItemLeft" align="right" valign="top">T &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad6fb51ad272618b034b8dd4695094a2d">AppendNew</a> ()</td></tr>
<tr class="memdesc:ad6fb51ad272618b034b8dd4695094a2d"><td class="mdescLeft">&#160;</td><td class="mdescRight">array operations //////////////////////////////////////////////////// <a href="#ad6fb51ad272618b034b8dd4695094a2d">More...</a><br /></td></tr>
<tr class="separator:ad6fb51ad272618b034b8dd4695094a2d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adce0cef747a0af8ba530d783803eebea"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adce0cef747a0af8ba530d783803eebea">Array</a> ()</td></tr>
<tr class="memdesc:adce0cef747a0af8ba530d783803eebea"><td class="mdescLeft">&#160;</td><td class="mdescRight">The <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adce0cef747a0af8ba530d783803eebea" title="The Array() function return the. ">Array()</a> function return the. <a href="#adce0cef747a0af8ba530d783803eebea">More...</a><br /></td></tr>
<tr class="separator:adce0cef747a0af8ba530d783803eebea"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0f00cbefe33723a49999cd813965ed44"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a0f00cbefe33723a49999cd813965ed44">Array</a> () const</td></tr>
<tr class="memdesc:a0f00cbefe33723a49999cd813965ed44"><td class="mdescLeft">&#160;</td><td class="mdescRight">m_a pointer value. <a href="#a0f00cbefe33723a49999cd813965ed44">More...</a><br /></td></tr>
<tr class="separator:a0f00cbefe33723a49999cd813965ed44"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1a2dd98978dcb410ffad30abdd8d6fda"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a1a2dd98978dcb410ffad30abdd8d6fda">At</a> (int)</td></tr>
<tr class="memdesc:a1a2dd98978dcb410ffad30abdd8d6fda"><td class="mdescLeft">&#160;</td><td class="mdescRight">At(index) returns nullptr if index &lt; 0 or index &gt;= count. <a href="#a1a2dd98978dcb410ffad30abdd8d6fda">More...</a><br /></td></tr>
@@ -99,12 +95,10 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:ad0d94bd1f923919e78b68e4e4e3072c9"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad0d94bd1f923919e78b68e4e4e3072c9">At</a> (ON__UINT64) const</td></tr>
<tr class="separator:ad0d94bd1f923919e78b68e4e4e3072c9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adfff8569ef8e5248c46a586d3a7f5d8d"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adfff8569ef8e5248c46a586d3a7f5d8d">BinarySearch</a> (const T *, int(*)(const T *, const T *)) const</td></tr>
<tr class="memdesc:adfff8569ef8e5248c46a586d3a7f5d8d"><td class="mdescLeft">&#160;</td><td class="mdescRight">See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; <a href="#adfff8569ef8e5248c46a586d3a7f5d8d">More...</a><br /></td></tr>
<tr class="separator:adfff8569ef8e5248c46a586d3a7f5d8d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6772cea657f623fe7d690786433b12d2"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a6772cea657f623fe7d690786433b12d2">BinarySearch</a> (const T *, int(*)(const T *, const T *), int) const</td></tr>
<tr class="separator:a6772cea657f623fe7d690786433b12d2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae06989b66432ab66a49511406d675ed9"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ae06989b66432ab66a49511406d675ed9">Capacity</a> () const</td></tr>
<tr class="memdesc:ae06989b66432ab66a49511406d675ed9"><td class="mdescLeft">&#160;</td><td class="mdescRight">capacity of array <a href="#ae06989b66432ab66a49511406d675ed9">More...</a><br /></td></tr>
<tr class="separator:ae06989b66432ab66a49511406d675ed9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad44741ad8393d128dae2ff39b8c596c9"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9">Count</a> () const</td></tr>
<tr class="memdesc:ad44741ad8393d128dae2ff39b8c596c9"><td class="mdescLeft">&#160;</td><td class="mdescRight">query /////////////////////////////////////////////////////////////// <a href="#ad44741ad8393d128dae2ff39b8c596c9">More...</a><br /></td></tr>
@@ -112,29 +106,26 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:aa3c8412725dd56733bbabee62e45f60d"><td class="memItemLeft" align="right" valign="top">ON__UINT32&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa3c8412725dd56733bbabee62e45f60d">DataCRC</a> (ON__UINT32 current_remainder) const</td></tr>
<tr class="separator:aa3c8412725dd56733bbabee62e45f60d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a56a43009d39635f9c0a08272391b5951"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a56a43009d39635f9c0a08272391b5951">Destroy</a> ()</td></tr>
<tr class="memdesc:a56a43009d39635f9c0a08272391b5951"><td class="mdescLeft">&#160;</td><td class="mdescRight">onfree any memory and set count and capacity to zero <a href="#a56a43009d39635f9c0a08272391b5951">More...</a><br /></td></tr>
<tr class="separator:a56a43009d39635f9c0a08272391b5951"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8c5f556cc24b13bfd1a4f6d09d1cb060"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8c5f556cc24b13bfd1a4f6d09d1cb060">EmergencyDestroy</a> (void)</td></tr>
<tr class="memdesc:a8c5f556cc24b13bfd1a4f6d09d1cb060"><td class="mdescLeft">&#160;</td><td class="mdescRight">emergency bailout /////////////////////////////////////////////////// <a href="#a8c5f556cc24b13bfd1a4f6d09d1cb060">More...</a><br /></td></tr>
<tr class="separator:a8c5f556cc24b13bfd1a4f6d09d1cb060"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8d37e0c0eaf603fffdd9c3e9e3d1fe48"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8d37e0c0eaf603fffdd9c3e9e3d1fe48">Empty</a> ()</td></tr>
<tr class="memdesc:a8d37e0c0eaf603fffdd9c3e9e3d1fe48"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets count to 0, leaves capacity untouched. <a href="#a8d37e0c0eaf603fffdd9c3e9e3d1fe48">More...</a><br /></td></tr>
<tr class="separator:a8d37e0c0eaf603fffdd9c3e9e3d1fe48"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adc4dd6d8de7311c1be580a62b3bcb8e4"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adc4dd6d8de7311c1be580a62b3bcb8e4">First</a> ()</td></tr>
<tr class="separator:adc4dd6d8de7311c1be580a62b3bcb8e4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a16d639114475493490dd7cb240b18c67"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a16d639114475493490dd7cb240b18c67">First</a> () const</td></tr>
<tr class="memdesc:a16d639114475493490dd7cb240b18c67"><td class="mdescLeft">&#160;</td><td class="mdescRight">returns nullptr if count = 0 <a href="#a16d639114475493490dd7cb240b18c67">More...</a><br /></td></tr>
<tr class="separator:a16d639114475493490dd7cb240b18c67"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a81068392f935f0d7efa9d772960bf157"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a81068392f935f0d7efa9d772960bf157">HeapSort</a> (int(*)(const T *, const T *))</td></tr>
<tr class="separator:a81068392f935f0d7efa9d772960bf157"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4a0e9f915b7b24ce1c9d700e011f3cce"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a4a0e9f915b7b24ce1c9d700e011f3cce">Insert</a> (int, const T &amp;)</td></tr>
<tr class="separator:a4a0e9f915b7b24ce1c9d700e011f3cce"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afff693cde3bcf58c12392bc286204962"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#afff693cde3bcf58c12392bc286204962">KeepArray</a> ()</td></tr>
<tr class="memdesc:afff693cde3bcf58c12392bc286204962"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert user tool to take charge of the memory used by the dyanmic array. <a href="#afff693cde3bcf58c12392bc286204962">More...</a><br /></td></tr>
<tr class="separator:afff693cde3bcf58c12392bc286204962"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a11948f1e15b893414a0b432fd23a9d80"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a11948f1e15b893414a0b432fd23a9d80">Last</a> ()</td></tr>
<tr class="separator:a11948f1e15b893414a0b432fd23a9d80"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8a29206db50e59b7c598c8734444fe4a"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8a29206db50e59b7c598c8734444fe4a">Last</a> () const</td></tr>
<tr class="memdesc:a8a29206db50e59b7c598c8734444fe4a"><td class="mdescLeft">&#160;</td><td class="mdescRight">returns nullptr if count = 0 <a href="#a8a29206db50e59b7c598c8734444fe4a">More...</a><br /></td></tr>
<tr class="separator:a8a29206db50e59b7c598c8734444fe4a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9e27ce66d3c528a0b4ab6423b3524d33"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a9e27ce66d3c528a0b4ab6423b3524d33">MemSet</a> (unsigned char)</td></tr>
<tr class="separator:a9e27ce66d3c528a0b4ab6423b3524d33"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -143,7 +134,6 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:a107e3d0dffa5187fed1ce114afdd7d5f"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a107e3d0dffa5187fed1ce114afdd7d5f">operator const T *</a> () const</td></tr>
<tr class="separator:a107e3d0dffa5187fed1ce114afdd7d5f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aedf3af5aa6188ab4ade1f2fd3f910938"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aedf3af5aa6188ab4ade1f2fd3f910938">operator T*</a> ()</td></tr>
<tr class="memdesc:aedf3af5aa6188ab4ade1f2fd3f910938"><td class="mdescLeft">&#160;</td><td class="mdescRight">The cast operators return a pointer. <a href="#aedf3af5aa6188ab4ade1f2fd3f910938">More...</a><br /></td></tr>
<tr class="separator:aedf3af5aa6188ab4ade1f2fd3f910938"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad64a5a71533d8a06eb1a4961628b6ea2"><td class="memItemLeft" align="right" valign="top"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html">ON_SimpleArray</a>&lt; T &gt; &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad64a5a71533d8a06eb1a4961628b6ea2">operator=</a> (const <a class="el" href="../../dc/dfe/class_o_n___simple_array.html">ON_SimpleArray</a>&lt; T &gt; &amp;)</td></tr>
<tr class="separator:ad64a5a71533d8a06eb1a4961628b6ea2"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -166,7 +156,6 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:abe6cd30eaa175e4c03cc23576acdd4f0"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#abe6cd30eaa175e4c03cc23576acdd4f0">Permute</a> (const int *)</td></tr>
<tr class="separator:abe6cd30eaa175e4c03cc23576acdd4f0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8edc28b59c54bb9ab779199dd0e9c937"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8edc28b59c54bb9ab779199dd0e9c937">QuickSort</a> (int(*)(const T *, const T *))</td></tr>
<tr class="memdesc:a8edc28b59c54bb9ab779199dd0e9c937"><td class="mdescLeft">&#160;</td><td class="mdescRight">See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; <a href="#a8edc28b59c54bb9ab779199dd0e9c937">More...</a><br /></td></tr>
<tr class="separator:a8edc28b59c54bb9ab779199dd0e9c937"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aba771b1bd1d30886c96da29ab89b86da"><td class="memItemLeft" align="right" valign="top">virtual T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aba771b1bd1d30886c96da29ab89b86da">Realloc</a> (T *, int)</td></tr>
<tr class="memdesc:aba771b1bd1d30886c96da29ab89b86da"><td class="mdescLeft">&#160;</td><td class="mdescRight">low level memory managment ////////////////////////////////////////// <a href="#aba771b1bd1d30886c96da29ab89b86da">More...</a><br /></td></tr>
@@ -179,16 +168,16 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:a854343dc47d8e351690acaa531f2b44a"><td class="mdescLeft">&#160;</td><td class="mdescRight">memory managment //////////////////////////////////////////////////// <a href="#a854343dc47d8e351690acaa531f2b44a">More...</a><br /></td></tr>
<tr class="separator:a854343dc47d8e351690acaa531f2b44a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8ea224d8ba49b55fce89f04657ccb0e5"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8ea224d8ba49b55fce89f04657ccb0e5">Reverse</a> ()</td></tr>
<tr class="memdesc:a8ea224d8ba49b55fce89f04657ccb0e5"><td class="mdescLeft">&#160;</td><td class="mdescRight">reverse order <a href="#a8ea224d8ba49b55fce89f04657ccb0e5">More...</a><br /></td></tr>
<tr class="separator:a8ea224d8ba49b55fce89f04657ccb0e5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa4f0900f2e6c9ca19f49dbc2c0ed8a32"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4f0900f2e6c9ca19f49dbc2c0ed8a32">Search</a> (const T &amp;) const</td></tr>
<tr class="separator:aa4f0900f2e6c9ca19f49dbc2c0ed8a32"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6270dba096ef3655b75f3aeb211d1139"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a6270dba096ef3655b75f3aeb211d1139">Search</a> (const T *, int(*)(const T *, const T *)) const</td></tr>
<tr class="memdesc:a6270dba096ef3655b75f3aeb211d1139"><td class="mdescLeft">&#160;</td><td class="mdescRight">See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; <a href="#a6270dba096ef3655b75f3aeb211d1139">More...</a><br /></td></tr>
<tr class="separator:a6270dba096ef3655b75f3aeb211d1139"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a741ee52742f90e2c7f5747700e161ea4"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a741ee52742f90e2c7f5747700e161ea4">SetArray</a> (T *)</td></tr>
<tr class="memdesc:a741ee52742f90e2c7f5747700e161ea4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Do not use this version of <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a741ee52742f90e2c7f5747700e161ea4" title="Do not use this version of SetArray(). Use the one that takes a pointer, count and capacity...">SetArray()</a>. Use the one that takes a pointer, count and capacity. <a href="#a741ee52742f90e2c7f5747700e161ea4">More...</a><br /></td></tr>
<tr class="separator:a741ee52742f90e2c7f5747700e161ea4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1df4d304d2be6c2da1fec97a5cc462a3"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a1df4d304d2be6c2da1fec97a5cc462a3">SetArray</a> (T *, int, int)</td></tr>
<tr class="memdesc:a1df4d304d2be6c2da1fec97a5cc462a3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert user tool to set the memory used by the dyanmic array. <a href="#a1df4d304d2be6c2da1fec97a5cc462a3">More...</a><br /></td></tr>
<tr class="separator:a1df4d304d2be6c2da1fec97a5cc462a3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a67e159de08eb6e1991ec10f551f6df05"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a67e159de08eb6e1991ec10f551f6df05">SetCapacity</a> (size_t)</td></tr>
<tr class="separator:a67e159de08eb6e1991ec10f551f6df05"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -196,20 +185,18 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:a449bfb832fcb364e9b8349ea4dc8a343"><td class="mdescLeft">&#160;</td><td class="mdescRight">low level memory managment ////////////////////////////////////////// <a href="#a449bfb832fcb364e9b8349ea4dc8a343">More...</a><br /></td></tr>
<tr class="separator:a449bfb832fcb364e9b8349ea4dc8a343"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a02045fb0cf4c9c24aabba20a2ae0c9f0"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a02045fb0cf4c9c24aabba20a2ae0c9f0">Shrink</a> ()</td></tr>
<tr class="memdesc:a02045fb0cf4c9c24aabba20a2ae0c9f0"><td class="mdescLeft">&#160;</td><td class="mdescRight">remove unused capacity <a href="#a02045fb0cf4c9c24aabba20a2ae0c9f0">More...</a><br /></td></tr>
<tr class="separator:a02045fb0cf4c9c24aabba20a2ae0c9f0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7ddb43ae86d40b5088a9ed0852354899"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a7ddb43ae86d40b5088a9ed0852354899">SizeOfArray</a> () const</td></tr>
<tr class="memdesc:a7ddb43ae86d40b5088a9ed0852354899"><td class="mdescLeft">&#160;</td><td class="mdescRight">amount of memory in the m_a[] array <a href="#a7ddb43ae86d40b5088a9ed0852354899">More...</a><br /></td></tr>
<tr class="separator:a7ddb43ae86d40b5088a9ed0852354899"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae78ec3ac6f59fd1d61e69e334124f2f5"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ae78ec3ac6f59fd1d61e69e334124f2f5">SizeOfElement</a> () const</td></tr>
<tr class="memdesc:ae78ec3ac6f59fd1d61e69e334124f2f5"><td class="mdescLeft">&#160;</td><td class="mdescRight">amount of memory in an m_a[] array element <a href="#ae78ec3ac6f59fd1d61e69e334124f2f5">More...</a><br /></td></tr>
<tr class="separator:ae78ec3ac6f59fd1d61e69e334124f2f5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a14e3d8c3c9542339ffabe5b404b76062"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062">Sort</a> (ON::sort_algorithm sort_algorithm, int *, int(*)(const T *, const T *)) const</td></tr>
<tr class="memdesc:a14e3d8c3c9542339ffabe5b404b76062"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062" title="Sort() fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modi...">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified. <a href="#a14e3d8c3c9542339ffabe5b404b76062">More...</a><br /></td></tr>
<tr class="separator:a14e3d8c3c9542339ffabe5b404b76062"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a984f3c72a00955b8aa497b4d7e716c72"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a984f3c72a00955b8aa497b4d7e716c72">Sort</a> (ON::sort_algorithm sort_algorithm, int *, int(*)(const T *, const T *, void *), void *) const</td></tr>
<tr class="memdesc:a984f3c72a00955b8aa497b4d7e716c72"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062" title="Sort() fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modi...">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified. <a href="#a984f3c72a00955b8aa497b4d7e716c72">More...</a><br /></td></tr>
<tr class="separator:a984f3c72a00955b8aa497b4d7e716c72"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a586cf6b13a035d38f5eeeafec97fdff6"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a586cf6b13a035d38f5eeeafec97fdff6">Swap</a> (int, int)</td></tr>
<tr class="memdesc:a586cf6b13a035d38f5eeeafec97fdff6"><td class="mdescLeft">&#160;</td><td class="mdescRight">swap elements i and j <a href="#a586cf6b13a035d38f5eeeafec97fdff6">More...</a><br /></td></tr>
<tr class="separator:a586cf6b13a035d38f5eeeafec97fdff6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7afd26b9d114490a7814353e3590f3a4"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a7afd26b9d114490a7814353e3590f3a4">UnsignedCount</a> () const</td></tr>
<tr class="separator:a7afd26b9d114490a7814353e3590f3a4"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -225,25 +212,13 @@ Protected Member Functions</h2></td></tr>
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-attribs"></a>
Protected Attributes</h2></td></tr>
<tr class="memitem:a5a8b7b4e1c8d4720f86d7cdcc880bb1b"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a5a8b7b4e1c8d4720f86d7cdcc880bb1b">m_a</a></td></tr>
<tr class="memdesc:a5a8b7b4e1c8d4720f86d7cdcc880bb1b"><td class="mdescLeft">&#160;</td><td class="mdescRight">pointer to array memory <a href="#a5a8b7b4e1c8d4720f86d7cdcc880bb1b">More...</a><br /></td></tr>
<tr class="separator:a5a8b7b4e1c8d4720f86d7cdcc880bb1b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1ab2b35163e7feb6630af8fccdf043dc"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a1ab2b35163e7feb6630af8fccdf043dc">m_capacity</a></td></tr>
<tr class="memdesc:a1ab2b35163e7feb6630af8fccdf043dc"><td class="mdescLeft">&#160;</td><td class="mdescRight">actual length of m_a[] <a href="#a1ab2b35163e7feb6630af8fccdf043dc">More...</a><br /></td></tr>
<tr class="separator:a1ab2b35163e7feb6630af8fccdf043dc"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a36d30dac6b1d443f64c267e1dbc62ff8"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a36d30dac6b1d443f64c267e1dbc62ff8">m_count</a></td></tr>
<tr class="memdesc:a36d30dac6b1d443f64c267e1dbc62ff8"><td class="mdescLeft">&#160;</td><td class="mdescRight">0 &lt;= m_count &lt;= m_capacity <a href="#a36d30dac6b1d443f64c267e1dbc62ff8">More...</a><br /></td></tr>
<tr class="separator:a36d30dac6b1d443f64c267e1dbc62ff8"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><h3>template&lt;class T&gt;<br />
class ON_SimpleArray&lt; T &gt;</h3>
<dl class="section rcs"><dt>NoKeywords</dt><dd></dd></dl>
<p>/ / Copyright (c) 1993-2012 Robert McNeel &amp; Associates. All rights reserved. / OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert / McNeel &amp; Associates. / / THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. / ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF / MERCHANTABILITY ARE HEREBY DISCLAIMED. / / For complete openNURBS copyright information see <a href="http://www.opennurbs.org">http://www.opennurbs.org</a>. / //////////////////////////////////////////////////////////////</p>
<p>The ON_SimpleArray&lt;&gt; template is more efficient than the ON_ClassArray&lt;&gt; template, but ON_SimpleArray&lt;&gt; should not be used for arrays of classes that require explicit construction, destruction, or copy operators.</p>
<p>Elements returned by <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad6fb51ad272618b034b8dd4695094a2d" title="array operations //////////////////////////////////////////////////// ">AppendNew()</a> are memset to zero.</p>
<p>By default, ON_SimpleArray&lt;&gt; uses onrealloc() to manage the dynamic array memory. If you want to use something besides onrealloc() to manage the array memory, then override <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aba771b1bd1d30886c96da29ab89b86da" title="low level memory managment ////////////////////////////////////////// ">ON_SimpleArray::Realloc()</a>. </p>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a id="a40938b1db05c86fe59395dfabfe3d3be"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a40938b1db05c86fe59395dfabfe3d3be">&#9670;&nbsp;</a></span>ON_SimpleArray() <span class="overload">[1/3]</span></h2>
@@ -262,7 +237,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>construction //////////////////////////////////////////////////////// </p>
<p>These constructors create an array that uses onrealloc() to manage the array memory. </p>
</div>
</div>
@@ -312,7 +286,6 @@ template&lt;class T&gt; </div>
</div><div class="memdoc">
<p>Copy constructor. </p>
<p>&lt; operator= defined below </p>
</div>
</div>
@@ -334,8 +307,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>size_t parameter = initial capacity </p>
</div>
</div>
<h2 class="groupheader">Member Function Documentation</h2>
@@ -356,11 +327,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Append copy of element. Increments count by 1. </p>
<p>&lt; (int) cast is for 64 bit pointers</p>
<p>26 Sep 2005 Dale Lear User passed in an element of the m_a[] that will get reallocated by the call to Reserve(newcapacity).</p>
<p>&lt; ON_*Array&lt;&gt; templates do not require robust copy constructor.</p>
<p>&lt; ON_*Array&lt;&gt; templates require a robust operator=. </p>
</div>
</div>
@@ -392,8 +358,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>Append copy of an array T[count]. </p>
</div>
</div>
<a id="ad6fb51ad272618b034b8dd4695094a2d"></a>
@@ -414,7 +378,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>array operations //////////////////////////////////////////////////// </p>
<p>Most efficient way to add a new element to the array. Increases count by 1. Returned element is memset to zero. </p>
</div>
</div>
@@ -435,8 +398,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>The <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adce0cef747a0af8ba530d783803eebea" title="The Array() function return the. ">Array()</a> function return the. </p>
</div>
</div>
<a id="a0f00cbefe33723a49999cd813965ed44"></a>
@@ -456,8 +417,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>m_a pointer value. </p>
</div>
</div>
<a id="a1a2dd98978dcb410ffad30abdd8d6fda"></a>
@@ -649,14 +608,8 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; </p>
<p>BinarySearch( p, compare ) does a fast search of a sorted array and returns the smallest index "i" of the element that satisifies 0==compare(p,&amp;array[i]).</p>
<p>BinarySearch( p, compare, count ) does a fast search of the first count element sorted array and returns the smallest index "i" of the element that satisifies 0==compare(p,&amp;array[i]). The version that takes a "count" is useful when elements are being appended during a calculation and the appended elements are not sorted.</p>
<p>If the search is successful, <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adfff8569ef8e5248c46a586d3a7f5d8d" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">BinarySearch()</a> returns the index of the element (&gt;=0). If the search is not successful, <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adfff8569ef8e5248c46a586d3a7f5d8d" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">BinarySearch()</a> returns -1. Use QuickSort( compare ) or, in rare cases and after meaningful performance testing using optimzed release builds, HeapSort( compare ) to sort the array. </p>
<p>This worked on a wide range of 32 bit compilers.</p>
<p>Convert "found" pointer to array index.</p>
<p>In an ideal world, return ((int)(found - m_a)) would work everywhere. In practice, this should work any 32 bit compiler and we can hope the optimzer generates efficient code.</p>
<p>"key" not found </p>
</div>
@@ -696,7 +649,6 @@ template&lt;class T&gt; </div>
</div><div class="memdoc">
<p>This worked on a wide range of 32 bit compilers.</p>
<p>Convert "found" pointer to array index.</p>
<p>In an ideal world, return ((int)(found - m_a)) would work everywhere. In practice, this should work any 32 bit compiler and we can hope the optimzer generates efficient code.</p>
<p>"key" not found </p>
</div>
@@ -718,8 +670,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>capacity of array </p>
</div>
</div>
<a id="ad44741ad8393d128dae2ff39b8c596c9"></a>
@@ -740,7 +690,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>query /////////////////////////////////////////////////////////////// </p>
<p>number of elements in array </p>
</div>
</div>
@@ -781,8 +730,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>onfree any memory and set count and capacity to zero </p>
</div>
</div>
<a id="a8c5f556cc24b13bfd1a4f6d09d1cb060"></a>
@@ -804,8 +751,7 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>emergency bailout /////////////////////////////////////////////////// </p>
<p>emergency destroy ///////////////////////////////////////////////////</p>
<p>call only when memory used by this array may have become invalid for reasons beyond your control. <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8c5f556cc24b13bfd1a4f6d09d1cb060" title="emergency bailout /////////////////////////////////////////////////// ">EmergencyDestroy()</a> zeros anything that could possibly cause <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#af6ae46b8e2bc5ee8f0803fc87e60d4cc">~ON_SimpleArray()</a> to crash. </p>
<p>emergency destroy /////////////////////////////////////////////////// </p>
</div>
</div>
@@ -826,8 +772,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>Sets count to 0, leaves capacity untouched. </p>
</div>
</div>
<a id="adc4dd6d8de7311c1be580a62b3bcb8e4"></a>
@@ -866,8 +810,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>returns nullptr if count = 0 </p>
</div>
</div>
<a id="a81068392f935f0d7efa9d772960bf157"></a>
@@ -887,7 +829,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Sorts the array using the heap sort algorithm. <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8edc28b59c54bb9ab779199dd0e9c937" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">QuickSort()</a> is generally the better choice. </p>
</div>
</div>
@@ -918,7 +859,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Insert copy of element. Uses memmove() to perform any necessary moving. Increases count by 1. </p>
</div>
</div>
@@ -938,7 +878,9 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: Expert user tool to take charge of the memory used by the dyanmic array. Returns: A pointer to the array and zeros out this class. The returned pointer is on the heap and must be deallocated by calling onfree(). </p>
<p>Expert user tool to take charge of the memory used by the dyanmic array. </p>
<dl class="section return"><dt>Returns</dt><dd>A pointer to the array and zeros out this class. The returned pointer is on the heap and must be deallocated by calling onfree(). </dd></dl>
</div>
</div>
@@ -978,8 +920,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>returns nullptr if count = 0 </p>
</div>
</div>
<a id="a9e27ce66d3c528a0b4ab6423b3524d33"></a>
@@ -999,7 +939,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Sets all bytes in array memory to value. Count and capacity are not changed. </p>
</div>
</div>
@@ -1047,7 +986,6 @@ template&lt;class T &gt; </div>
<p>implimentation ////////////////////////////////////////////////////// </p>
<p>array operations //////////////////////////////////////////////////// </p>
<p>private function for moving blocks of array memory caller is responsible for updating m_count. </p>
</div>
</div>
@@ -1067,11 +1005,7 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>is &lt; current <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>, then count is reduced to value.When the dynamic array needs to grow, this calculates the new value for m_capacity. </p>
<p>Note: This code appears in <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a5d2395da5bc042c230d799ed92c9c564">ON_SimpleArray&lt;T&gt;::NewCapacity()</a> and <a class="el" href="../../dd/d40/class_o_n___class_array.html#a39b36908b477ca9e79dd435d1802237a">ON_ClassArray&lt;T&gt;::NewCapacity()</a>. Changes made to either function should be made to both functions. Because this code is template code that has to support dynamic linking and the code is defined in a header, I'm using copy-and-paste rather than a static.</p>
<p>This function returns 2*m_count unless that will result in an additional allocation of more than cap_size bytes. The cap_size concept was added in January 2010 because some calculations on enormous models were slightly underestimating the initial <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a854343dc47d8e351690acaa531f2b44a" title="memory managment //////////////////////////////////////////////////// ">Reserve()</a> size and then wasting gigabytes of memory.</p>
<p>cap_size = 128 MB on 32-bit os, 256 MB on 64 bit os</p>
<p>Growing the array will increase the memory use by more than cap_size. </p>
<p>cap_size = 128 MB on 32-bit os, 256 MB on 64 bit os </p>
</div>
</div>
@@ -1091,7 +1025,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>to the array. If <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a> is zero, this pointer is nullptr. </p>
</div>
</div>
@@ -1112,8 +1045,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>The cast operators return a pointer. </p>
</div>
</div>
<a id="ad64a5a71533d8a06eb1a4961628b6ea2"></a>
@@ -1153,7 +1084,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>The operator[] does to not check for valid indices. The caller is responsibile for insuring that 0 &lt;= i &lt; <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ae06989b66432ab66a49511406d675ed9" title="capacity of array ">Capacity()</a> </p>
</div>
</div>
@@ -1314,8 +1244,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Permutes the array so that output[i] = input[index[i]]. The index[] array should be a permutation of (0,...,<a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1). </p>
<p>&lt; must use memcopy and not operator= </p>
</div>
</div>
@@ -1337,9 +1265,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; </p>
<p>Sorts the array using the quick sort algorithm. </p>
</div>
</div>
<a id="aba771b1bd1d30886c96da29ab89b86da"></a>
@@ -1380,12 +1305,7 @@ template&lt;class T&gt; </div>
<p>low level memory managment ////////////////////////////////////////// </p>
<p>Class ON_SimpleArray&lt;&gt;</p>
<p>By default, ON_SimpleArray&lt;&gt; uses onrealloc() to manage the dynamic array memory. If you want to use something besides onrealloc() to manage the array memory, then override <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aba771b1bd1d30886c96da29ab89b86da" title="low level memory managment ////////////////////////////////////////// ">Realloc()</a>. The T* Realloc(ptr, capacity) should do the following:</p>
<p>1) If ptr and capacity are zero, return nullptr. 2) If ptr is nullptr, an capacity &gt; 0, allocate a memory block of capacity*sizeof(T) bytes and return a pointer to this block. If the allocation request fails, return nullptr. 3) If ptr is not nullptr and capacity is 0, free the memory block pointed to by ptr and return nullptr. 4) If ptr is not nullptr and capacity &gt; 0, then reallocate the memory block and return a pointer to the reallocated block. If the reallocation request fails, return nullptr.</p>
<p>NOTE WELL: Microsoft's VC 6.0 realloc() contains a bug that can cause crashes and should be avoided. See MSDN Knowledge Base article ID Q225099 for more information. (re)allocated capacity*sizeof(T) bytes</p>
<dl class="section rcs"><dt>NoKeywords</dt><dd></dd></dl>
<p>/ / Copyright (c) 1993-2012 Robert McNeel &amp; Associates. All rights reserved. / OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert / McNeel &amp; Associates. / / THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. / ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF / MERCHANTABILITY ARE HEREBY DISCLAIMED. / / For complete openNURBS copyright information see <a href="http://www.opennurbs.org">http://www.opennurbs.org</a>. / //////////////////////////////////////////////////////////////When this file is parsed with /W4 warnings, two bogus warnings are generated. The <a class="el" href="../../dd/d40/class_o_n___class_array.html#ad4650327b91304e934de5bf6fe4bb9ae">ON_ClassArray&lt;T&gt;::DestroyElement</a> template function generates a C4100: 'x' : unreferenced formal parameter warning. This appears to be caused by a bug in the compiler warning code or the way templates are expanded. This pragma is needed squelch the bogus warning. The ON_CompareIncreasing and ON_CompareDecreasing templates generate a C4211: nonstandard extension used : redefined extern to static warning. Microsoft's compiler appears to have a little trouble when static functions are declared before they are defined in a single .cpp file. This pragma is needed squelch the bogus warning. The main reason the definitions of the functions for the <a class="el" href="../../dc/dfe/class_o_n___simple_array.html">ON_SimpleArray</a> and <a class="el" href="../../dd/d40/class_o_n___class_array.html">ON_ClassArray</a> templates are in this separate file is so that the Microsoft developer studio autocomplete functions will work on these classes.</p>
<p>This file is included by <a class="el" href="../../d3/d03/opennurbs__array_8h_source.html">opennurbs_array.h</a> in the appropriate spot. If you need the definitions in the file, then you should include <a class="el" href="../../d3/d03/opennurbs__array_8h_source.html">opennurbs_array.h</a> and let it take care of including this file.construction //////////////////////////////////////////////////////// </p>
<p>construction //////////////////////////////////////////////////////// </p>
</div>
</div>
@@ -1405,7 +1325,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Removes last element. Decrements count by 1. Does not change capacity. </p>
</div>
</div>
@@ -1434,7 +1353,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Removes element. Uses memmove() to perform any necessary shifting. Decrements count by 1. Does not change capacity </p>
</div>
</div>
@@ -1457,7 +1375,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>memory managment //////////////////////////////////////////////////// </p>
<p>increase capacity to at least the requested value </p>
</div>
</div>
@@ -1478,9 +1395,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>reverse order </p>
<p>NOTE: If anything in "T" depends on the value of this's address, then don't call <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a8ea224d8ba49b55fce89f04657ccb0e5" title="reverse order ">Reverse()</a>. </p>
</div>
</div>
<a id="aa4f0900f2e6c9ca19f49dbc2c0ed8a32"></a>
@@ -1500,7 +1414,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Search( e ) does a SLOW search of the array starting at array[0] and returns the index "i" of the first element that satisfies e == array[i]. (== is really memcmp()). If the search is not successful, then <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4f0900f2e6c9ca19f49dbc2c0ed8a32">Search()</a> returns -1. For Search(T) to work correctly, T must be a simple type. Use Search(p,compare()) for Ts that are structs/classes that contain pointers. <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4f0900f2e6c9ca19f49dbc2c0ed8a32">Search()</a> is only suitable for performing infrequent searchs of small arrays. Sort the array and use <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adfff8569ef8e5248c46a586d3a7f5d8d" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">BinarySearch()</a> for performing efficient searches. </p>
</div>
</div>
@@ -1532,9 +1445,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; </p>
<p>Search( p, compare ) does a SLOW search of the array starting at array[0] and returns the index "i" of the first element that satisfies compare(p,&amp;array[i])==0. If the search is not successful, then <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4f0900f2e6c9ca19f49dbc2c0ed8a32">Search()</a> returns -1. <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aa4f0900f2e6c9ca19f49dbc2c0ed8a32">Search()</a> is only suitable for performing infrequent searches of small arrays. Sort the array and use <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#adfff8569ef8e5248c46a586d3a7f5d8d" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">BinarySearch()</a> for performing efficient searches. </p>
</div>
</div>
<a id="a741ee52742f90e2c7f5747700e161ea4"></a>
@@ -1554,7 +1464,8 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: Do not use this version of <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a741ee52742f90e2c7f5747700e161ea4">SetArray()</a>. Use the one that takes a pointer, count and capacity. </p>
<p>Do not use this version of <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a741ee52742f90e2c7f5747700e161ea4" title="Do not use this version of SetArray(). Use the one that takes a pointer, count and capacity...">SetArray()</a>. Use the one that takes a pointer, count and capacity. </p>
</div>
</div>
@@ -1591,7 +1502,9 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: Expert user tool to set the memory used by the dyanmic array. Parameters: T* pointer - [in] int count [in] int capacity - [in] m_a is set to pointer, m_count is set to count, and m_capacity is set to capacity. It is critical that the pointer be one returned by onmalloc(sz), where sz &gt;= capacity*sizeof(T[0]). </p>
<p>Expert user tool to set the memory used by the dyanmic array. </p>
<p>TODODOC: T* pointer - [in] TODODOC: int count [in] TODODOC: int capacity - [in] TODODOC: m_a is set to pointer, m_count is set to count, and m_capacity TODODOC: is set to capacity. It is critical that the pointer be one TODODOC: returned by onmalloc(sz), where sz &gt;= capacity*sizeof(T[0]). </p>
</div>
</div>
@@ -1612,8 +1525,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Shrink/grows capacity. If value </p>
<p>Allow "expert" users of ON_SimpleArray&lt;&gt;.SetArray(*,*,0) to clean up after themselves and deals with the case when the forget to clean up after themselves.</p>
<p>sets capacity to input value</p>
<p>NOTE: <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#aba771b1bd1d30886c96da29ab89b86da" title="low level memory managment ////////////////////////////////////////// ">Realloc()</a> does an allocation if the first argument is nullptr.</p>
<p>zero new memory</p>
@@ -1640,7 +1551,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>low level memory managment ////////////////////////////////////////// </p>
<p>If value is &lt;= <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ae06989b66432ab66a49511406d675ed9" title="capacity of array ">Capacity()</a>, then sets count to specified value. </p>
</div>
</div>
@@ -1661,8 +1571,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>remove unused capacity </p>
</div>
</div>
<a id="a7ddb43ae86d40b5088a9ed0852354899"></a>
@@ -1682,8 +1590,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>amount of memory in the m_a[] array </p>
</div>
</div>
<a id="ae78ec3ac6f59fd1d61e69e334124f2f5"></a>
@@ -1703,8 +1609,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>amount of memory in an m_a[] array element </p>
</div>
</div>
<a id="a14e3d8c3c9542339ffabe5b404b76062"></a>
@@ -1740,8 +1644,17 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified.</p>
<p>Parameters: sort_algorithm - [in] ON::sort_algorithm::quick_sort (best in general) or ON::sort_algorithm::heap_sort Use ON::sort_algorithm::heap_sort only if you have done extensive testing with optimized release builds and are confident heap sort is significantly faster. index - [out] an array of length <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1). compare - [in] compare function compare(a,b,p) should return &lt;0 if a&lt;b, 0, if a==b, and &gt;0 if a&gt;b. Returns: true if successful </p>
<p><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062" title="Sort() fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modi...">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified. </p>
<dl class="params"><dt>Parameters</dt><dd>
<table class="params">
<tr><td class="paramname">sort_algorithm</td><td>[in] ON::sort_algorithm::quick_sort (best in general) or ON::sort_algorithm::heap_sort Use ON::sort_algorithm::heap_sort only if you have done extensive testing with optimized release builds and are confident heap sort is significantly faster.</td></tr>
<tr><td class="paramname">index</td><td>[out] an array of length <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1).</td></tr>
<tr><td class="paramname">compare</td><td>[in] compare function compare(a,b,p) should return &lt;0 if a&lt;b, 0, if a==b, and &gt;0 if a&gt;b.</td></tr>
</table>
</dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if successful </dd></dl>
</div>
</div>
@@ -1784,17 +1697,18 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified.</p>
<p>Parameters: sort_algorithm - [in] ON::sort_algorithm::quick_sort (best in general) or ON::sort_algorithm::heap_sort Use ON::sort_algorithm::heap_sort only if you have done extensive testing with optimized release builds and are confident heap sort is significantly faster. index - [out] an array of length <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1). compare - [in] compare function compare(a,b,p) should return &lt;0 if a&lt;b, 0, if a==b, and &gt;0 if a&gt;b. p - [in] pointer passed as third argument to compare.</p>
<p>Returns: true if successful </p>
<p><a class="el" href="../../dc/dfe/class_o_n___simple_array.html#a14e3d8c3c9542339ffabe5b404b76062" title="Sort() fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modi...">Sort()</a> fills in the index[] array so that array[index[i]] &lt;= array[index[i+1]]. The array is not modified. </p>
<dl class="params"><dt>Parameters</dt><dd>
<table class="params">
<tr><td class="paramname">index</td><td>index[] </td></tr>
<tr><td class="paramname">compar</td><td>int compare(const T*,const T*,void* p) </td></tr>
<tr><td class="paramname">p</td><td>p </td></tr>
<tr><td class="paramname">sort_algorithm</td><td>[in] ON::sort_algorithm::quick_sort (best in general) or ON::sort_algorithm::heap_sort Use ON::sort_algorithm::heap_sort only if you have done extensive testing with optimized release builds and are confident heap sort is significantly faster.</td></tr>
<tr><td class="paramname">index</td><td>[out] an array of length <a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dc/dfe/class_o_n___simple_array.html#ad44741ad8393d128dae2ff39b8c596c9" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1).</td></tr>
<tr><td class="paramname">compare</td><td>[in] compare function compare(a,b,p) should return &lt;0 if a&lt;b, 0, if a==b, and &gt;0 if a&gt;b.</td></tr>
<tr><td class="paramname">p</td><td>[in] pointer passed as third argument to compare. </td></tr>
</table>
</dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if successful </dd></dl>
</div>
</div>
@@ -1826,8 +1740,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>swap elements i and j </p>
</div>
</div>
<a id="a7afd26b9d114490a7814353e3590f3a4"></a>
@@ -1865,7 +1777,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Zeros all array memory. Count and capacity are not changed. </p>
</div>
</div>
@@ -1892,8 +1803,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>pointer to array memory </p>
</div>
</div>
<a id="a1ab2b35163e7feb6630af8fccdf043dc"></a>
@@ -1918,8 +1827,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>actual length of m_a[] </p>
</div>
</div>
<a id="a36d30dac6b1d443f64c267e1dbc62ff8"></a>
@@ -1944,8 +1851,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>0 &lt;= m_count &lt;= m_capacity </p>
</div>
</div>
</div><!-- contents -->
@@ -1954,7 +1859,7 @@ template&lt;class T&gt; </div>
</div> <!-- page-content -->
</div> <!-- container -->
<hr class="footer"/><address class="footer"><small>
Generated on Wed Jan 31 2018 14:45:41 for openNURBS SDK Help by <a href="http://www.doxygen.org/index.html">
Generated on Fri Feb 2 2018 07:57:31 for openNURBS SDK Help by <a href="http://www.doxygen.org/index.html">
<!-- <img class="footer" src="../../doxygen.png" alt="doxygen"/> -->
Doxygen
</a> 1.8.13