secblock_8h-source.html

Crypto++是一个非常强大的密码学库,主要是功能全

00190 <span class="comment">//! a block of memory allocated using A</span>
00191 <span class="comment"></span><span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> A = AllocatorWithCleanup&lt;T&gt; &gt;
<a name="l00192"></a><a class="code" href="class_sec_block.html">00192</a> <span class="keyword">class </span><a class="code" href="class_sec_block.html">SecBlock</a>
00193 {
00194 <span class="keyword">public</span>:
00195         <span class="keyword">explicit</span> <a class="code" href="class_sec_block.html">SecBlock</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> size=0)
00196                 : m_size(size) {m_ptr = m_alloc.allocate(size, NULL);}
00197         <a class="code" href="class_sec_block.html">SecBlock</a>(<span class="keyword">const</span> <a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;t)
00198                 : m_size(t.m_size) {m_ptr = m_alloc.allocate(m_size, NULL); memcpy(m_ptr, t.m_ptr, m_size*<span class="keyword">sizeof</span>(T));}
00199         <a class="code" href="class_sec_block.html">SecBlock</a>(<span class="keyword">const</span> T *t, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> len)
00200                 : m_size(len)
00201         {
00202                 m_ptr = m_alloc.allocate(len, NULL);
00203                 <span class="keywordflow">if</span> (t == NULL)
00204                         memset(m_ptr, 0, len*<span class="keyword">sizeof</span>(T));
00205                 <span class="keywordflow">else</span>
00206                         memcpy(m_ptr, t, len*<span class="keyword">sizeof</span>(T));
00207         }
00208 
00209         ~<a class="code" href="class_sec_block.html">SecBlock</a>()
00210                 {m_alloc.deallocate(m_ptr, m_size);}
00211 
00212 <span class="preprocessor">#if defined(__GNUC__) || defined(__BCPLUSPLUS__)</span>
00213 <span class="preprocessor"></span>        operator const void *()<span class="keyword"> const</span>
00214 <span class="keyword">                </span>{<span class="keywordflow">return</span> m_ptr;}
00215         operator void *()
00216                 {<span class="keywordflow">return</span> m_ptr;}
00217 <span class="preprocessor">#endif</span>
00218 <span class="preprocessor"></span><span class="preprocessor">#if defined(__GNUC__)   // reduce warnings</span>
00219 <span class="preprocessor"></span>        operator const void *()
00220                 {<span class="keywordflow">return</span> m_ptr;}
00221 <span class="preprocessor">#endif</span>
00222 <span class="preprocessor"></span>
00223         operator const T *()<span class="keyword"> const</span>
00224 <span class="keyword">                </span>{<span class="keywordflow">return</span> m_ptr;}
00225         operator T *()
00226                 {<span class="keywordflow">return</span> m_ptr;}
00227 <span class="preprocessor">#if defined(__GNUC__)   // reduce warnings</span>
00228 <span class="preprocessor"></span>        operator const T *()
00229                 {<span class="keywordflow">return</span> m_ptr;}
00230 <span class="preprocessor">#endif</span>
00231 <span class="preprocessor"></span>
00232         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> I&gt;
00233         T *operator +(I offset)
00234                 {<span class="keywordflow">return</span> m_ptr+offset;}
00235 
00236         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> I&gt;
00237         <span class="keyword">const</span> T *operator +(I offset)<span class="keyword"> const</span>
00238 <span class="keyword">                </span>{<span class="keywordflow">return</span> m_ptr+offset;}
00239 
00240         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> I&gt;
00241         T&amp; operator[](I index)
00242                 {assert(index &gt;= 0 &amp;&amp; (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>)index &lt; m_size); <span class="keywordflow">return</span> m_ptr[index];}
00243 
00244         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> I&gt;
00245         <span class="keyword">const</span> T&amp; operator[](I index)<span class="keyword"> const</span>
00246 <span class="keyword">                </span>{assert(index &gt;= 0 &amp;&amp; (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>)index &lt; m_size); <span class="keywordflow">return</span> m_ptr[index];}
00247 
00248         <span class="keyword">typedef</span> <span class="keyword">typename</span> A::pointer iterator;
00249         <span class="keyword">typedef</span> <span class="keyword">typename</span> A::const_pointer const_iterator;
00250         <span class="keyword">typedef</span> <span class="keyword">typename</span> A::size_type size_type;
00251 
00252         iterator begin()
00253                 {<span class="keywordflow">return</span> m_ptr;}
00254         const_iterator begin()<span class="keyword"> const</span>
00255 <span class="keyword">                </span>{<span class="keywordflow">return</span> m_ptr;}
00256         iterator end()
00257                 {<span class="keywordflow">return</span> m_ptr+m_size;}
00258         const_iterator end()<span class="keyword"> const</span>
00259 <span class="keyword">                </span>{<span class="keywordflow">return</span> m_ptr+m_size;}
00260 
00261         <span class="keyword">typename</span> A::pointer data() {<span class="keywordflow">return</span> m_ptr;}
00262         <span class="keyword">typename</span> A::const_pointer data()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_ptr;}
00263 
00264         size_type size()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_size;}
00265         <span class="keywordtype">bool</span> empty()<span class="keyword"> const </span>{<span class="keywordflow">return</span> m_size == 0;}
00266 
00267         <span class="keywordtype">void</span> Assign(<span class="keyword">const</span> T *t, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> len)
00268         {
00269                 New(len);
00270                 memcpy(m_ptr, t, len*<span class="keyword">sizeof</span>(T));
00271         }
00272 
00273         <span class="keywordtype">void</span> Assign(<span class="keyword">const</span> <a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;t)
00274         {
00275                 New(t.m_size);
00276                 memcpy(m_ptr, t.m_ptr, m_size*<span class="keyword">sizeof</span>(T));
00277         }
00278 
00279         <a class="code" href="class_sec_block.html">SecBlock</a>&amp; operator=(<span class="keyword">const</span> <a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;t)
00280         {
00281                 Assign(t);
00282                 <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00283         }
00284 
00285         <span class="keywordtype">bool</span> operator==(<span class="keyword">const</span> <a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;t)<span class="keyword"> const</span>
00286 <span class="keyword">        </span>{
00287                 <span class="keywordflow">return</span> m_size == t.m_size &amp;&amp; memcmp(m_ptr, t.m_ptr, m_size*<span class="keyword">sizeof</span>(T)) == 0;
00288         }
00289 
00290         <span class="keywordtype">bool</span> operator!=(<span class="keyword">const</span> <a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;t)<span class="keyword"> const</span>
00291 <span class="keyword">        </span>{
00292                 <span class="keywordflow">return</span> !operator==(t);
00293         }
00294 
00295         <span class="keywordtype">void</span> New(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> newSize)
00296         {
00297                 m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, <span class="keyword">false</span>);
00298                 m_size = newSize;
00299         }
00300 
00301         <span class="keywordtype">void</span> CleanNew(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> newSize)
00302         {
00303                 New(newSize);
00304                 memset(m_ptr, 0, m_size*<span class="keyword">sizeof</span>(T));
00305         }
00306 
00307         <span class="keywordtype">void</span> Grow(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> newSize)
00308         {
00309                 <span class="keywordflow">if</span> (newSize &gt; m_size)
00310                 {
00311                         m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, <span class="keyword">true</span>);
00312                         m_size = newSize;
00313                 }
00314         }
00315 
00316         <span class="keywordtype">void</span> CleanGrow(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> newSize)
00317         {
00318                 <span class="keywordflow">if</span> (newSize &gt; m_size)
00319                 {
00320                         m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, <span class="keyword">true</span>);
00321                         memset(m_ptr+m_size, 0, (newSize-m_size)*<span class="keyword">sizeof</span>(T));
00322                         m_size = newSize;
00323                 }
00324         }
00325 
00326         <span class="keywordtype">void</span> resize(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> newSize)
00327         {
00328                 m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, <span class="keyword">true</span>);
00329                 m_size = newSize;
00330         }
00331 
00332         <span class="keywordtype">void</span> swap(<a class="code" href="class_sec_block.html">SecBlock&lt;T, A&gt;</a> &amp;b)
00333         {
00334                 std::swap(m_alloc, b.m_alloc);
00335                 std::swap(m_size, b.m_size);
00336                 std::swap(m_ptr, b.m_ptr);
00337         }
00338 
00339 <span class="comment">//private:</span>
00340         A m_alloc;
00341         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m_size;
00342         T *m_ptr;
00343 };
00344 
00345 <span class="keyword">typedef</span> <a class="code" href="class_sec_block.html">SecBlock&lt;byte&gt;</a> <a class="code" href="class_sec_block.html">SecByteBlock</a>;
00346 <span class="keyword">typedef</span> <a class="code" href="class_sec_block.html">SecBlock&lt;word&gt;</a> <a class="code" href="class_sec_block.html">SecWordBlock</a>;
00347 
00348 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> S, <span class="keyword">class</span> A = FixedSizeAllocatorWithCleanup&lt;T, S&gt; &gt;
00349 <span class="keyword">class </span>FixedSizeSecBlock : <span class="keyword">public</span> <a class="code" href="class_sec_block.html">SecBlock</a>&lt;T, A&gt;
00350 {
00351 <span class="keyword">public</span>:
00352         <span class="keyword">explicit</span> FixedSizeSecBlock() : <a class="code" href="class_sec_block.html">SecBlock</a>&lt;T, A&gt;(S) {}
00353 };
00354 
00355 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> S, <span class="keyword">class</span> A = FixedSizeAllocatorWithCleanup&lt;T, S, AllocatorWithCleanup&lt;T&gt; &gt; &gt;
00356 <span class="keyword">class </span>SecBlockWithHint : <span class="keyword">public</span> <a class="code" href="class_sec_block.html">SecBlock</a>&lt;T, A&gt;
00357 {
00358 <span class="keyword">public</span>:
00359         <span class="keyword">explicit</span> SecBlockWithHint(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> size) : <a class="code" href="class_sec_block.html">SecBlock</a>&lt;T, A&gt;(size) {}
00360 };
00361 
00362 <span class="keyword">template</span>&lt;<span class="keyword">class</span> T, <span class="keyword">class</span> U&gt;
00363 <span class="keyword">inline</span> <span class="keywordtype">bool</span> operator==(<span class="keyword">const</span> CryptoPP::AllocatorWithCleanup&lt;T&gt;&amp;, <span class="keyword">const</span> CryptoPP::AllocatorWithCleanup&lt;U&gt;&amp;) {<span class="keywordflow">return</span> (<span class="keyword">true</span>);}
00364 <span class="keyword">template</span>&lt;<span class="keyword">class</span> T, <span class="keyword">class</span> U&gt;
00365 <span class="keyword">inline</span> <span class="keywordtype">bool</span> operator!=(<span class="keyword">const</span> CryptoPP::AllocatorWithCleanup&lt;T&gt;&amp;, <span class="keyword">const</span> CryptoPP::AllocatorWithCleanup&lt;U&gt;&amp;) {<span class="keywordflow">return</span> (<span class="keyword">false</span>);}
00366 
00367 NAMESPACE_END
00368 
00369 NAMESPACE_BEGIN(std)
00370 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T, <span class="keyword">class</span> A&gt;
00371 <span class="keyword">inline</span> <span class="keywordtype">void</span> swap(CryptoPP::SecBlock&lt;T, A&gt; &amp;a, CryptoPP::SecBlock&lt;T, A&gt; &amp;b)
00372 {
00373         a.swap(b);
00374 }
00375 
00376 NAMESPACE_END
00377 
00378 <span class="preprocessor">#endif</span>
</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue Jul 8 23:34:24 2003 for Crypto++ by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 > 
</a>1.3.2 </small></address>
</body>
</html>