lili/opennurbs
1
0
Fork 0
mirror of https://github.com/mcneel/opennurbs.git synced 2026-04-05 03:47:55 +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

165
6/dd/d40/class_o_n___class_array.html
View File

@@ -59,7 +59,7 @@ Inheritance diagram for ON_ClassArray&lt; T &gt;:</div>
<div class="center">
<img src="../../dd/d40/class_o_n___class_array.png" usemap="#ON_5FClassArray_3C_20T_20_3E_map" alt=""/>
<map id="ON_5FClassArray_3C_20T_20_3E_map" name="ON_5FClassArray_3C_20T_20_3E_map">
<area href="../../da/d08/class_o_n___object_array.html" alt="ON_ObjectArray&lt; T &gt;" shape="rect" coords="0,56,139,80"/>
<area href="../../da/d08/class_o_n___object_array.html" title="ON_Object array is used to store lists of classes that are derived from ON_Object. It differs from ON_ClassArray in that the virtual ON_Object::MemoryRelocate function is called when growing the dynamic array requires changing the location of the memory buffer used to store the elements in the array. " alt="ON_ObjectArray&lt; T &gt;" shape="rect" coords="0,56,139,80"/>
</map>
</div></div>
<table class="memberdecls">
@@ -69,27 +69,22 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:aa12a2a08c847c3221d9ebd037cd67236"><td class="mdescLeft">&#160;</td><td class="mdescRight">construction //////////////////////////////////////////////////////// <a href="#aa12a2a08c847c3221d9ebd037cd67236">More...</a><br /></td></tr>
<tr class="separator:aa12a2a08c847c3221d9ebd037cd67236"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2a29bdce0835c65c43d220d2bb3d18c7"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a2a29bdce0835c65c43d220d2bb3d18c7">ON_ClassArray</a> (size_t)</td></tr>
<tr class="memdesc:a2a29bdce0835c65c43d220d2bb3d18c7"><td class="mdescLeft">&#160;</td><td class="mdescRight">size_t parameter = initial capacity <a href="#a2a29bdce0835c65c43d220d2bb3d18c7">More...</a><br /></td></tr>
<tr class="separator:a2a29bdce0835c65c43d220d2bb3d18c7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa0a6a9e85b363987aede2c91e46b5036"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aa0a6a9e85b363987aede2c91e46b5036">ON_ClassArray</a> (const <a class="el" href="../../dd/d40/class_o_n___class_array.html">ON_ClassArray</a>&lt; T &gt; &amp;)</td></tr>
<tr class="memdesc:aa0a6a9e85b363987aede2c91e46b5036"><td class="mdescLeft">&#160;</td><td class="mdescRight">Copy constructor. <a href="#aa0a6a9e85b363987aede2c91e46b5036">More...</a><br /></td></tr>
<tr class="separator:aa0a6a9e85b363987aede2c91e46b5036"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad8afae29c14a95b85324992907c38929"><td class="memItemLeft" align="right" valign="top">virtual&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ad8afae29c14a95b85324992907c38929">~ON_ClassArray</a> ()</td></tr>
<tr class="memdesc:ad8afae29c14a95b85324992907c38929"><td class="mdescLeft">&#160;</td><td class="mdescRight">override for struct member deallocation, etc. <a href="#ad8afae29c14a95b85324992907c38929">More...</a><br /></td></tr>
<tr class="separator:ad8afae29c14a95b85324992907c38929"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a417093e16515cefacd17dc940ea4a52f"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a417093e16515cefacd17dc940ea4a52f">Append</a> (const T &amp;)</td></tr>
<tr class="separator:a417093e16515cefacd17dc940ea4a52f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad863aa00c481c6d22cf0bab4d9fab0b7"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ad863aa00c481c6d22cf0bab4d9fab0b7">Append</a> (int, const T *)</td></tr>
<tr class="memdesc:ad863aa00c481c6d22cf0bab4d9fab0b7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Append copy of an array T[count]. <a href="#ad863aa00c481c6d22cf0bab4d9fab0b7">More...</a><br /></td></tr>
<tr class="separator:ad863aa00c481c6d22cf0bab4d9fab0b7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3453ebec06da96dd2bc10f66b4312dda"><td class="memItemLeft" align="right" valign="top">T &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a3453ebec06da96dd2bc10f66b4312dda">AppendNew</a> ()</td></tr>
<tr class="memdesc:a3453ebec06da96dd2bc10f66b4312dda"><td class="mdescLeft">&#160;</td><td class="mdescRight">array operations //////////////////////////////////////////////////// <a href="#a3453ebec06da96dd2bc10f66b4312dda">More...</a><br /></td></tr>
<tr class="separator:a3453ebec06da96dd2bc10f66b4312dda"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a36597e8827a812df0d9c6c81c1db4e81"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a36597e8827a812df0d9c6c81c1db4e81">Array</a> ()</td></tr>
<tr class="memdesc:a36597e8827a812df0d9c6c81c1db4e81"><td class="mdescLeft">&#160;</td><td class="mdescRight">The <a class="el" href="../../dd/d40/class_o_n___class_array.html#a36597e8827a812df0d9c6c81c1db4e81" title="The Array() function return the. ">Array()</a> function return the. <a href="#a36597e8827a812df0d9c6c81c1db4e81">More...</a><br /></td></tr>
<tr class="separator:a36597e8827a812df0d9c6c81c1db4e81"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4772c4d3558d1d2567310010fa3add1d"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a4772c4d3558d1d2567310010fa3add1d">Array</a> () const</td></tr>
<tr class="memdesc:a4772c4d3558d1d2567310010fa3add1d"><td class="mdescLeft">&#160;</td><td class="mdescRight">m_a pointer value. <a href="#a4772c4d3558d1d2567310010fa3add1d">More...</a><br /></td></tr>
<tr class="separator:a4772c4d3558d1d2567310010fa3add1d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5451b98ba3fb0936ffbfe9f59cb4b09e"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a5451b98ba3fb0936ffbfe9f59cb4b09e">At</a> (int)</td></tr>
<tr class="memdesc:a5451b98ba3fb0936ffbfe9f59cb4b09e"><td class="mdescLeft">&#160;</td><td class="mdescRight">At(index) returns nullptr if index &lt; 0 or index &gt;= count. <a href="#a5451b98ba3fb0936ffbfe9f59cb4b09e">More...</a><br /></td></tr>
@@ -109,32 +104,26 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:ac1621f585217b42abd35061dabb7dfe2"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ac1621f585217b42abd35061dabb7dfe2">At</a> (ON__UINT64) const</td></tr>
<tr class="separator:ac1621f585217b42abd35061dabb7dfe2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6f69264bb06391c81571f0182fbaef08"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a6f69264bb06391c81571f0182fbaef08">BinarySearch</a> (const T *, int(*)(const T *, const T *)) const</td></tr>
<tr class="memdesc:a6f69264bb06391c81571f0182fbaef08"><td class="mdescLeft">&#160;</td><td class="mdescRight">See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; <a href="#a6f69264bb06391c81571f0182fbaef08">More...</a><br /></td></tr>
<tr class="separator:a6f69264bb06391c81571f0182fbaef08"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af70b91b3b3fd7ecfb8f8fcf3e1d342b8"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#af70b91b3b3fd7ecfb8f8fcf3e1d342b8">BinarySearch</a> (const T *, int(*)(const T *, const T *), int) const</td></tr>
<tr class="separator:af70b91b3b3fd7ecfb8f8fcf3e1d342b8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af828eb3eedaefe303676b81b0b5bd0cd"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#af828eb3eedaefe303676b81b0b5bd0cd">Capacity</a> () const</td></tr>
<tr class="memdesc:af828eb3eedaefe303676b81b0b5bd0cd"><td class="mdescLeft">&#160;</td><td class="mdescRight">capacity of array <a href="#af828eb3eedaefe303676b81b0b5bd0cd">More...</a><br /></td></tr>
<tr class="separator:af828eb3eedaefe303676b81b0b5bd0cd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1845abffe10408c4ce46046d9232f8e8"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8">Count</a> () const</td></tr>
<tr class="memdesc:a1845abffe10408c4ce46046d9232f8e8"><td class="mdescLeft">&#160;</td><td class="mdescRight">query /////////////////////////////////////////////////////////////// <a href="#a1845abffe10408c4ce46046d9232f8e8">More...</a><br /></td></tr>
<tr class="separator:a1845abffe10408c4ce46046d9232f8e8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab8a86fe207a6b43c493104e166003250"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ab8a86fe207a6b43c493104e166003250">Destroy</a> ()</td></tr>
<tr class="memdesc:ab8a86fe207a6b43c493104e166003250"><td class="mdescLeft">&#160;</td><td class="mdescRight">onfree any memory and set count and capacity to zero <a href="#ab8a86fe207a6b43c493104e166003250">More...</a><br /></td></tr>
<tr class="separator:ab8a86fe207a6b43c493104e166003250"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aebe0869a166cd4e3d74e5aaa731ab831"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aebe0869a166cd4e3d74e5aaa731ab831">EmergencyDestroy</a> (void)</td></tr>
<tr class="memdesc:aebe0869a166cd4e3d74e5aaa731ab831"><td class="mdescLeft">&#160;</td><td class="mdescRight">emergency bailout /////////////////////////////////////////////////// <a href="#aebe0869a166cd4e3d74e5aaa731ab831">More...</a><br /></td></tr>
<tr class="separator:aebe0869a166cd4e3d74e5aaa731ab831"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acc29b3806f214bf0253499255e307856"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#acc29b3806f214bf0253499255e307856">Empty</a> ()</td></tr>
<tr class="memdesc:acc29b3806f214bf0253499255e307856"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets count to 0, leaves capacity untouched. <a href="#acc29b3806f214bf0253499255e307856">More...</a><br /></td></tr>
<tr class="separator:acc29b3806f214bf0253499255e307856"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a00c04a9b48b53459764dffe506b5e34c"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a00c04a9b48b53459764dffe506b5e34c">First</a> ()</td></tr>
<tr class="separator:a00c04a9b48b53459764dffe506b5e34c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9069a7bc0b5126ff143f70aa43b43230"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a9069a7bc0b5126ff143f70aa43b43230">First</a> () const</td></tr>
<tr class="memdesc:a9069a7bc0b5126ff143f70aa43b43230"><td class="mdescLeft">&#160;</td><td class="mdescRight">returns nullptr if count = 0 <a href="#a9069a7bc0b5126ff143f70aa43b43230">More...</a><br /></td></tr>
<tr class="separator:a9069a7bc0b5126ff143f70aa43b43230"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aeacff55bc065868229f3269bb47d0e31"><td class="memItemLeft" align="right" valign="top">virtual bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aeacff55bc065868229f3269bb47d0e31">HeapSort</a> (int(*)(const T *, const T *))</td></tr>
<tr class="memdesc:aeacff55bc065868229f3269bb47d0e31"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aaaccc2915ed9407ed77e5355ed02f61a" title="Sorts the array using the heap sort algorithm. ">QuickSort()</a> is generally the better choice. <a href="#aeacff55bc065868229f3269bb47d0e31">More...</a><br /></td></tr>
<tr class="separator:aeacff55bc065868229f3269bb47d0e31"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aebeebfb862065c0d62c00389ae3f499b"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aebeebfb862065c0d62c00389ae3f499b">Insert</a> (int, const T &amp;)</td></tr>
<tr class="memdesc:aebeebfb862065c0d62c00389ae3f499b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Insert called with a reference uses operator =. <a href="#aebeebfb862065c0d62c00389ae3f499b">More...</a><br /></td></tr>
@@ -144,14 +133,12 @@ Public Member Functions</h2></td></tr>
<tr class="memitem:a5e9dfdb1601fb20ce86dfe8244719665"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a5e9dfdb1601fb20ce86dfe8244719665">Last</a> ()</td></tr>
<tr class="separator:a5e9dfdb1601fb20ce86dfe8244719665"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a558bc5d60a7dc8d9885a387e12bd8ae6"><td class="memItemLeft" align="right" valign="top">const T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a558bc5d60a7dc8d9885a387e12bd8ae6">Last</a> () const</td></tr>
<tr class="memdesc:a558bc5d60a7dc8d9885a387e12bd8ae6"><td class="mdescLeft">&#160;</td><td class="mdescRight">returns nullptr if count = 0 <a href="#a558bc5d60a7dc8d9885a387e12bd8ae6">More...</a><br /></td></tr>
<tr class="separator:a558bc5d60a7dc8d9885a387e12bd8ae6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a39b36908b477ca9e79dd435d1802237a"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a39b36908b477ca9e79dd435d1802237a">NewCapacity</a> () const</td></tr>
<tr class="separator:a39b36908b477ca9e79dd435d1802237a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad42aed50f4d66e4a33379db171c71fd8"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ad42aed50f4d66e4a33379db171c71fd8">operator const T *</a> () const</td></tr>
<tr class="separator:ad42aed50f4d66e4a33379db171c71fd8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5e8b150fdfb6f1c2d5a625ee09273432"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a5e8b150fdfb6f1c2d5a625ee09273432">operator T*</a> ()</td></tr>
<tr class="memdesc:a5e8b150fdfb6f1c2d5a625ee09273432"><td class="mdescLeft">&#160;</td><td class="mdescRight">The cast operators return a pointer. <a href="#a5e8b150fdfb6f1c2d5a625ee09273432">More...</a><br /></td></tr>
<tr class="separator:a5e8b150fdfb6f1c2d5a625ee09273432"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab7b741c3481b50b44d69bd4a620296e8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="../../dd/d40/class_o_n___class_array.html">ON_ClassArray</a>&lt; T &gt; &amp;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ab7b741c3481b50b44d69bd4a620296e8">operator=</a> (const <a class="el" href="../../dd/d40/class_o_n___class_array.html">ON_ClassArray</a>&lt; T &gt; &amp;)</td></tr>
<tr class="memdesc:ab7b741c3481b50b44d69bd4a620296e8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Assignment operator. <a href="#ab7b741c3481b50b44d69bd4a620296e8">More...</a><br /></td></tr>
@@ -188,13 +175,14 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:a619516bde2761154d967c96ee6c2b044"><td class="mdescLeft">&#160;</td><td class="mdescRight">memory managment ///////////////////////////////////////////////// <a href="#a619516bde2761154d967c96ee6c2b044">More...</a><br /></td></tr>
<tr class="separator:a619516bde2761154d967c96ee6c2b044"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae0cf9e8ff629067820b78bf8fa4723fd"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#ae0cf9e8ff629067820b78bf8fa4723fd">Reverse</a> ()</td></tr>
<tr class="memdesc:ae0cf9e8ff629067820b78bf8fa4723fd"><td class="mdescLeft">&#160;</td><td class="mdescRight">reverse order <a href="#ae0cf9e8ff629067820b78bf8fa4723fd">More...</a><br /></td></tr>
<tr class="separator:ae0cf9e8ff629067820b78bf8fa4723fd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a815f500f614c1742ba1f250b6e46ab1c"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a815f500f614c1742ba1f250b6e46ab1c">Search</a> (const T *, int(*)(const T *, const T *)) const</td></tr>
<tr class="separator:a815f500f614c1742ba1f250b6e46ab1c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a404695bf0683f18b0e2a1b2cc2538fa3"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a404695bf0683f18b0e2a1b2cc2538fa3">SetArray</a> (T *)</td></tr>
<tr class="memdesc:a404695bf0683f18b0e2a1b2cc2538fa3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Do not use this version of <a class="el" href="../../dd/d40/class_o_n___class_array.html#a404695bf0683f18b0e2a1b2cc2538fa3" title="Do not use this version of SetArray(). Use the one that takes a pointer, count and capacity: SetArray...">SetArray()</a>. Use the one that takes a pointer, count and capacity: SetArray(pointer,count,capacity) <a href="#a404695bf0683f18b0e2a1b2cc2538fa3">More...</a><br /></td></tr>
<tr class="separator:a404695bf0683f18b0e2a1b2cc2538fa3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a382c44cb8eaa73cc598d587fdfda5220"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a382c44cb8eaa73cc598d587fdfda5220">SetArray</a> (T *, int, int)</td></tr>
<tr class="memdesc:a382c44cb8eaa73cc598d587fdfda5220"><td class="mdescLeft">&#160;</td><td class="mdescRight">Expert user tool to set the memory used by the dyanmic array. <a href="#a382c44cb8eaa73cc598d587fdfda5220">More...</a><br /></td></tr>
<tr class="separator:a382c44cb8eaa73cc598d587fdfda5220"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a49bc44bb095af6dd8173a91441b78bfd"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a49bc44bb095af6dd8173a91441b78bfd">SetCapacity</a> (size_t)</td></tr>
<tr class="separator:a49bc44bb095af6dd8173a91441b78bfd"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -202,20 +190,18 @@ Public Member Functions</h2></td></tr>
<tr class="memdesc:a7ffd376de3d1af10f22caea8e5b5d114"><td class="mdescLeft">&#160;</td><td class="mdescRight">low level memory managment ////////////////////////////////////////// <a href="#a7ffd376de3d1af10f22caea8e5b5d114">More...</a><br /></td></tr>
<tr class="separator:a7ffd376de3d1af10f22caea8e5b5d114"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a34c5ba8cd96d26d1880e2ecd0f21b6e5"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a34c5ba8cd96d26d1880e2ecd0f21b6e5">Shrink</a> ()</td></tr>
<tr class="memdesc:a34c5ba8cd96d26d1880e2ecd0f21b6e5"><td class="mdescLeft">&#160;</td><td class="mdescRight">remove unused capacity <a href="#a34c5ba8cd96d26d1880e2ecd0f21b6e5">More...</a><br /></td></tr>
<tr class="separator:a34c5ba8cd96d26d1880e2ecd0f21b6e5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a317aa7fa09844d153876fa707ae87e2d"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a317aa7fa09844d153876fa707ae87e2d">SizeOfArray</a> () const</td></tr>
<tr class="memdesc:a317aa7fa09844d153876fa707ae87e2d"><td class="mdescLeft">&#160;</td><td class="mdescRight">amount of memory in the m_a[] array <a href="#a317aa7fa09844d153876fa707ae87e2d">More...</a><br /></td></tr>
<tr class="separator:a317aa7fa09844d153876fa707ae87e2d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adf0b64e2722e1e77fa1dfd5fe1e222de"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#adf0b64e2722e1e77fa1dfd5fe1e222de">SizeOfElement</a> () const</td></tr>
<tr class="memdesc:adf0b64e2722e1e77fa1dfd5fe1e222de"><td class="mdescLeft">&#160;</td><td class="mdescRight">amount of memory in an m_a[] array element <a href="#adf0b64e2722e1e77fa1dfd5fe1e222de">More...</a><br /></td></tr>
<tr class="separator:adf0b64e2722e1e77fa1dfd5fe1e222de"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acc32ae1ba071b666ae49a9d2c2a041e7"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7">Sort</a> (ON::sort_algorithm sort_algorithm, int *, int(*)(const T *, const T *)) const</td></tr>
<tr class="memdesc:acc32ae1ba071b666ae49a9d2c2a041e7"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7" 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="#acc32ae1ba071b666ae49a9d2c2a041e7">More...</a><br /></td></tr>
<tr class="separator:acc32ae1ba071b666ae49a9d2c2a041e7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a62165890958430bf2e377aaabc7fd93c"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a62165890958430bf2e377aaabc7fd93c">Sort</a> (ON::sort_algorithm sort_algorithm, int *, int(*)(const T *, const T *, void *), void *) const</td></tr>
<tr class="memdesc:a62165890958430bf2e377aaabc7fd93c"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7" 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="#a62165890958430bf2e377aaabc7fd93c">More...</a><br /></td></tr>
<tr class="separator:a62165890958430bf2e377aaabc7fd93c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa00c91a632d42ebbd4a04715750953ca"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#aa00c91a632d42ebbd4a04715750953ca">Swap</a> (int, int)</td></tr>
<tr class="memdesc:aa00c91a632d42ebbd4a04715750953ca"><td class="mdescLeft">&#160;</td><td class="mdescRight">swap elements i and j <a href="#aa00c91a632d42ebbd4a04715750953ca">More...</a><br /></td></tr>
<tr class="separator:aa00c91a632d42ebbd4a04715750953ca"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a64d1db4495becbc776ba36549ad93fd1"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a64d1db4495becbc776ba36549ad93fd1">UnsignedCount</a> () const</td></tr>
<tr class="separator:a64d1db4495becbc776ba36549ad93fd1"><td class="memSeparator" colspan="2">&#160;</td></tr>
@@ -235,22 +221,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:adfced275ab81f79ae6a60d5f660c0fdf"><td class="memItemLeft" align="right" valign="top">T *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#adfced275ab81f79ae6a60d5f660c0fdf">m_a</a></td></tr>
<tr class="memdesc:adfced275ab81f79ae6a60d5f660c0fdf"><td class="mdescLeft">&#160;</td><td class="mdescRight">pointer to array memory <a href="#adfced275ab81f79ae6a60d5f660c0fdf">More...</a><br /></td></tr>
<tr class="separator:adfced275ab81f79ae6a60d5f660c0fdf"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a867ba84ffce9dc8146dc5e7ce71d9ac8"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#a867ba84ffce9dc8146dc5e7ce71d9ac8">m_capacity</a></td></tr>
<tr class="memdesc:a867ba84ffce9dc8146dc5e7ce71d9ac8"><td class="mdescLeft">&#160;</td><td class="mdescRight">actual length of m_a[] <a href="#a867ba84ffce9dc8146dc5e7ce71d9ac8">More...</a><br /></td></tr>
<tr class="separator:a867ba84ffce9dc8146dc5e7ce71d9ac8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af361d7cf1705dccf62a534ddd0c48a69"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="../../dd/d40/class_o_n___class_array.html#af361d7cf1705dccf62a534ddd0c48a69">m_count</a></td></tr>
<tr class="memdesc:af361d7cf1705dccf62a534ddd0c48a69"><td class="mdescLeft">&#160;</td><td class="mdescRight">0 &lt;= m_count &lt;= m_capacity <a href="#af361d7cf1705dccf62a534ddd0c48a69">More...</a><br /></td></tr>
<tr class="separator:af361d7cf1705dccf62a534ddd0c48a69"><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_ClassArray&lt; T &gt;</h3>
<p>The ON_ClassArray&lt;&gt; template is designed to be used with classes that require non-trivial construction or destruction. Any class used with the ON_ClassArray&lt;&gt; template must have a robust <a class="el" href="../../dd/d40/class_o_n___class_array.html#ab7b741c3481b50b44d69bd4a620296e8" title="Assignment operator. ">operator=()</a>.</p>
<p>By default, ON_ClassArray&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="../../dd/d40/class_o_n___class_array.html#a6146b9447dfc2420fd1ddc79f4e25d13" title="low level memory managment /////////////////////////////////////// ">ON_ClassArray::Realloc()</a>. In practice this means that if your class has members with back-pointers, then you cannot use it in the defaule <a class="el" href="../../dd/d40/class_o_n___class_array.html">ON_ClassArray</a>. See <a class="el" href="../../da/d08/class_o_n___object_array.html">ON_ObjectArray</a> for an example. </p>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a id="aa12a2a08c847c3221d9ebd037cd67236"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aa12a2a08c847c3221d9ebd037cd67236">&#9670;&nbsp;</a></span>ON_ClassArray() <span class="overload">[1/3]</span></h2>
@@ -290,8 +267,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>size_t parameter = initial capacity </p>
</div>
</div>
<a id="aa0a6a9e85b363987aede2c91e46b5036"></a>
@@ -313,7 +288,6 @@ template&lt;class T&gt; </div>
</div><div class="memdoc">
<p>Copy constructor. </p>
<p>&lt; operator= defined below </p>
</div>
</div>
@@ -342,8 +316,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>override for struct member deallocation, etc. </p>
</div>
</div>
<h2 class="groupheader">Member Function Documentation</h2>
@@ -364,11 +336,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>
@@ -400,8 +367,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="a3453ebec06da96dd2bc10f66b4312dda"></a>
@@ -422,7 +387,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>array operations //////////////////////////////////////////////////// </p>
<p>Most efficient way to add a new class to the array. Increases count by 1. </p>
<p>First destroy what's there ..</p>
<p>and then get a properly initialized element </p>
@@ -445,8 +409,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>The <a class="el" href="../../dd/d40/class_o_n___class_array.html#a36597e8827a812df0d9c6c81c1db4e81" title="The Array() function return the. ">Array()</a> function return the. </p>
</div>
</div>
<a id="a4772c4d3558d1d2567310010fa3add1d"></a>
@@ -466,8 +428,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>m_a pointer value. </p>
</div>
</div>
<a id="a5451b98ba3fb0936ffbfe9f59cb4b09e"></a>
@@ -660,11 +620,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>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="../../dd/d40/class_o_n___class_array.html#a6f69264bb06391c81571f0182fbaef08" 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="../../dd/d40/class_o_n___class_array.html#a6f69264bb06391c81571f0182fbaef08" 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>
</div>
</div>
<a id="af70b91b3b3fd7ecfb8f8fcf3e1d342b8"></a>
@@ -720,8 +675,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>capacity of array </p>
</div>
</div>
<a id="a827238e8843d73fc952018a49278b4c6"></a>
@@ -749,7 +702,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>use placement ( new(size_t,void*) ) to construct T in supplied memory </p>
</div>
</div>
@@ -771,7 +723,6 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>query /////////////////////////////////////////////////////////////// </p>
<p>number of elements in array </p>
</div>
</div>
@@ -792,8 +743,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="ad4650327b91304e934de5bf6fe4bb9ae"></a>
@@ -843,8 +792,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="../../dd/d40/class_o_n___class_array.html#aebe0869a166cd4e3d74e5aaa731ab831" title="emergency bailout /////////////////////////////////////////////////// ">EmergencyDestroy()</a> zeros anything that could possibly cause <a class="el" href="../../dd/d40/class_o_n___class_array.html#ad8afae29c14a95b85324992907c38929" title="override for struct member deallocation, etc. ">~ON_ClassArray()</a> to crash. </p>
<p>emergency destroy /////////////////////////////////////////////////// </p>
</div>
</div>
@@ -865,9 +813,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>Sets count to 0, leaves capacity untouched. </p>
<p>This call to memset is ok even when T has a vtable because in-place construction is used later. </p>
</div>
</div>
<a id="a00c04a9b48b53459764dffe506b5e34c"></a>
@@ -906,8 +851,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>returns nullptr if count = 0 </p>
</div>
</div>
<a id="aeacff55bc065868229f3269bb47d0e31"></a>
@@ -936,9 +879,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p><a class="el" href="../../dd/d40/class_o_n___class_array.html#aaaccc2915ed9407ed77e5355ed02f61a" title="Sorts the array using the heap sort algorithm. ">QuickSort()</a> is generally the better choice. </p>
<p>Sorts the array using the heap sort algorithm. See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; </p>
<p>Reimplemented in <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; T &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_Texture &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepTrim &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepFaceSide &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepEdge &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepLoop &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepRegion &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepFace &gt;</a>, and <a class="el" href="../../da/d08/class_o_n___object_array.html#a51ee75049ffb91c10f2acb17b99d3a66">ON_ObjectArray&lt; ON_BrepVertex &gt;</a>.</p>
</div>
@@ -972,9 +912,6 @@ template&lt;class T&gt; </div>
</div><div class="memdoc">
<p>Insert called with a reference uses operator =. </p>
<p>Insert copy of element. Uses memmove() to perform any necessary moving. Increases count by 1. </p>
<p>This call to memset is ok even when T has a vtable because in-place construction is used later.</p>
<p>&lt; uses T::operator=() to copy x to array </p>
</div>
</div>
@@ -994,8 +931,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>returns pointer to array and zeros out this class. Caller is responsible for calling destructor on each element and then using onfree() to release array memory. E.g.,</p>
<p>for (int i=capacity;i&gt;=0;i&ndash;) { array[i].~T(); } onfree(array); </p>
</div>
</div>
@@ -1035,8 +970,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>returns nullptr if count = 0 </p>
</div>
</div>
<a id="a58673a8f943b627698b7f917b8bbcfdf"></a>
@@ -1083,8 +1016,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 and managing destruction/creation.</p>
<p>This call to memmove is ok, even when T is a class with a vtable because the it doesn't change the vtable for the class. Classes that have back pointers, like <a class="el" href="../../d5/d55/class_o_n___user_data.html">ON_UserData</a>, are handled elsewhere and cannot be in ON_ClassArray&lt;&gt;s. </p>
</div>
</div>
@@ -1104,11 +1035,7 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>is &lt; current <a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" 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="../../dd/d40/class_o_n___class_array.html#a619516bde2761154d967c96ee6c2b044" 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>
@@ -1128,7 +1055,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>to the array. If <a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a> is zero, this pointer is nullptr. </p>
</div>
</div>
@@ -1149,8 +1075,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>The cast operators return a pointer. </p>
</div>
</div>
<a id="ab7b741c3481b50b44d69bd4a620296e8"></a>
@@ -1192,7 +1116,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="../../dd/d40/class_o_n___class_array.html#af828eb3eedaefe303676b81b0b5bd0cd" title="capacity of array ">Capacity()</a> </p>
</div>
</div>
@@ -1353,8 +1276,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="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1). </p>
<p>&lt; must use memcopy and not operator= </p>
</div>
</div>
@@ -1428,9 +1349,6 @@ template&lt;class T&gt; </div>
<p>low level memory managment /////////////////////////////////////// </p>
<p>Class ON_ClassArray&lt;&gt;</p>
<p>By default, ON_ClassArray&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="../../dd/d40/class_o_n___class_array.html#a6146b9447dfc2420fd1ddc79f4e25d13" 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>
<p>construction //////////////////////////////////////////////////////// </p>
<p>Reimplemented in <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; T &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_Texture &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepTrim &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepFaceSide &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepEdge &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepLoop &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepRegion &gt;</a>, <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepFace &gt;</a>, and <a class="el" href="../../da/d08/class_o_n___object_array.html#a13c0a45951d15ca0d2a522e553b4a842">ON_ObjectArray&lt; ON_BrepVertex &gt;</a>.</p>
@@ -1453,7 +1371,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>
@@ -1474,9 +1391,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>
<p>This call to memset is ok even when T has a vtable because in-place construction is used later.</p>
<p>This call to memset is ok even when T has a vtable because in-place construction is used later. </p>
</div>
</div>
@@ -1499,8 +1413,7 @@ template&lt;class T &gt; </div>
</div><div class="memdoc">
<p>memory managment ///////////////////////////////////////////////// </p>
<p>memory managment ////////////////////////////////////////////////////</p>
<p>increase capacity to at least the requested value </p>
<p>memory managment //////////////////////////////////////////////////// </p>
</div>
</div>
@@ -1521,9 +1434,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="../../dd/d40/class_o_n___class_array.html#ae0cf9e8ff629067820b78bf8fa4723fd" title="reverse order ">Reverse()</a>. </p>
</div>
</div>
<a id="a815f500f614c1742ba1f250b6e46ab1c"></a>
@@ -1553,7 +1463,6 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<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="../../dd/d40/class_o_n___class_array.html#a815f500f614c1742ba1f250b6e46ab1c">Search()</a> returns -1. <a class="el" href="../../dd/d40/class_o_n___class_array.html#a815f500f614c1742ba1f250b6e46ab1c">Search()</a> is only suitable for performing infrequent searches of small arrays. Sort the array and use <a class="el" href="../../dd/d40/class_o_n___class_array.html#a6f69264bb06391c81571f0182fbaef08" title="See Also: ON_CompareIncreasing&lt;T&gt; and ON_CompareDeccreasing&lt;T&gt; ">BinarySearch()</a> for performing efficient searches. </p>
</div>
</div>
@@ -1574,7 +1483,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="../../dd/d40/class_o_n___class_array.html#a404695bf0683f18b0e2a1b2cc2538fa3">SetArray()</a>. Use the one that takes a pointer, count and capacity: SetArray(pointer,count,capacity) </p>
<p>Do not use this version of <a class="el" href="../../dd/d40/class_o_n___class_array.html#a404695bf0683f18b0e2a1b2cc2538fa3" title="Do not use this version of SetArray(). Use the one that takes a pointer, count and capacity: SetArray...">SetArray()</a>. Use the one that takes a pointer, count and capacity: SetArray(pointer,count,capacity) </p>
</div>
</div>
@@ -1611,7 +1521,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] 0 &lt;= count &lt;= capacity 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]), and that the in-place operator new has been used to initialize each element of the array. </p>
<p>Expert user tool to set the memory used by the dyanmic array. </p>
<p>TODODOC: T* pointer - [in] TODODOC: int count - [in] 0 &lt;= count &lt;= capacity 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]), TODODOC: and that the in-place operator new has been used to initialize TODODOC: each element of the array. </p>
</div>
</div>
@@ -1632,12 +1544,9 @@ 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>uses "placement" for class construction/destruction</p>
<p>growing</p>
<p>initialize new elements with default constructor</p>
<p>even when m_a is an array of classes with vtable pointers, this call to memset(..., 0, ...) is what I want to do because in-place construction will be used when needed on this memory.</p>
<p>memory allocation failed</p>
<p>shrinking</p>
<p>memory allocation failed </p>
@@ -1663,7 +1572,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="../../dd/d40/class_o_n___class_array.html#af828eb3eedaefe303676b81b0b5bd0cd" title="capacity of array ">Capacity()</a>, then sets count to specified value. </p>
</div>
</div>
@@ -1684,8 +1592,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>remove unused capacity </p>
</div>
</div>
<a id="a317aa7fa09844d153876fa707ae87e2d"></a>
@@ -1705,8 +1611,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="adf0b64e2722e1e77fa1dfd5fe1e222de"></a>
@@ -1726,8 +1630,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="acc32ae1ba071b666ae49a9d2c2a041e7"></a>
@@ -1763,9 +1665,17 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: <a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7">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="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1). compare - [in] compare function compare(a,b) should return &lt;0 if a&lt;b, 0, if a==b, and &gt;0 if a&gt;b.</p>
<p>Returns: true if successful </p>
<p><a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7" 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="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a>-1).</td></tr>
<tr><td class="paramname">compare</td><td>[in] compare function compare(a,b) 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>
@@ -1808,17 +1718,18 @@ template&lt;class T&gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Description: <a class="el" href="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7">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="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" 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="../../dd/d40/class_o_n___class_array.html#acc32ae1ba071b666ae49a9d2c2a041e7" 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="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" title="query /////////////////////////////////////////////////////////////// ">Count()</a> that is returned with some permutation of (0,1,...,<a class="el" href="../../dd/d40/class_o_n___class_array.html#a1845abffe10408c4ce46046d9232f8e8" 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>
@@ -1850,8 +1761,6 @@ template&lt;class T &gt; </div>
</table>
</div><div class="memdoc">
<p>swap elements i and j </p>
</div>
</div>
<a id="a64d1db4495becbc776ba36549ad93fd1"></a>
@@ -1889,8 +1798,6 @@ template&lt;class T &gt; </div>
</tr>
</table>
</div><div class="memdoc">
<p>Destroys all elements and fills them with values set by the defualt constructor. Count and capacity are not changed. </p>
<p>This call to memset is ok even when T has a vtable because in-place construction is used later. </p>
</div>
</div>
@@ -1917,8 +1824,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>pointer to array memory </p>
</div>
</div>
<a id="a867ba84ffce9dc8146dc5e7ce71d9ac8"></a>
@@ -1943,8 +1848,6 @@ template&lt;class T&gt; </div>
</table>
</div><div class="memdoc">
<p>actual length of m_a[] </p>
</div>
</div>
<a id="af361d7cf1705dccf62a534ddd0c48a69"></a>
@@ -1969,8 +1872,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 -->
@@ -1979,7 +1880,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:39 for openNURBS SDK Help by <a href="http://www.doxygen.org/index.html">
Generated on Fri Feb 2 2018 07:57:28 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