queue_8cpp-source.html

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

00352         <span class="comment">// TODO: make this more efficient</span>
00353         ByteQueueNode *newHead = <span class="keyword">new</span> ByteQueueNode(length);
00354         newHead-&gt;next = m_head;
00355         m_head = newHead;
00356         m_head-&gt;Put(inString, length);
00357 }
00358 
00359 <span class="keyword">const</span> byte * ByteQueue::Spy(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> &amp;contiguousSize)<span class="keyword"> const</span>
00360 <span class="keyword"></span>{
00361         contiguousSize = m_head-&gt;m_tail - m_head-&gt;m_head;
00362         <span class="keywordflow">if</span> (contiguousSize == 0 &amp;&amp; m_lazyLength &gt; 0)
00363         {
00364                 contiguousSize = m_lazyLength;
00365                 <span class="keywordflow">return</span> m_lazyString;
00366         }
00367         <span class="keywordflow">else</span>
00368                 <span class="keywordflow">return</span> m_head-&gt;buf + m_head-&gt;m_head;
00369 }
00370 
<a name="l00371"></a><a class="code" href="class_byte_queue.html#_d_e_r_set_encodera6">00371</a> byte * <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera6">ByteQueue::CreatePutSpace</a>(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> &amp;size)
00372 {
00373         <span class="keywordflow">if</span> (m_lazyLength &gt; 0)
00374                 FinalizeLazyPut();
00375 
00376         <span class="keywordflow">if</span> (m_tail-&gt;m_tail == m_tail-&gt;MaxSize())
00377         {
00378                 m_tail-&gt;next = <span class="keyword">new</span> ByteQueueNode(size &lt; m_nodeSize ? m_nodeSize : STDMAX(m_nodeSize, 1024U));
00379                 m_tail = m_tail-&gt;next;
00380         }
00381 
00382         size = m_tail-&gt;MaxSize() - m_tail-&gt;m_tail;
00383         <span class="keywordflow">return</span> m_tail-&gt;buf + m_tail-&gt;m_tail;
00384 }
00385 
00386 <a class="code" href="class_byte_queue.html">ByteQueue</a> &amp; ByteQueue::operator=(<span class="keyword">const</span> <a class="code" href="class_byte_queue.html">ByteQueue</a> &amp;rhs)
00387 {
00388         Destroy();
00389         CopyFrom(rhs);
00390         <span class="keywordflow">return</span> *<span class="keyword">this</span>;
00391 }
00392 
00393 <span class="keywordtype">bool</span> ByteQueue::operator==(<span class="keyword">const</span> <a class="code" href="class_byte_queue.html">ByteQueue</a> &amp;rhs)<span class="keyword"> const</span>
00394 <span class="keyword"></span>{
00395         <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> currentSize = CurrentSize();
00396 
00397         <span class="keywordflow">if</span> (currentSize != rhs.<a class="code" href="class_byte_queue.html#_d_e_r_set_encodera15">CurrentSize</a>())
00398                 <span class="keywordflow">return</span> <span class="keyword">false</span>;
00399 
00400         Walker walker1(*<span class="keyword">this</span>), walker2(rhs);
00401         byte b1, b2;
00402 
00403         <span class="keywordflow">while</span> (walker1.Get(b1) &amp;&amp; walker2.Get(b2))
00404                 <span class="keywordflow">if</span> (b1 != b2)
00405                         <span class="keywordflow">return</span> <span class="keyword">false</span>;
00406 
00407         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00408 }
00409 
00410 byte ByteQueue::operator[](<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> i)<span class="keyword"> const</span>
00411 <span class="keyword"></span>{
00412         <span class="keywordflow">for</span> (ByteQueueNode *current=m_head; current; current=current-&gt;next)
00413         {
00414                 <span class="keywordflow">if</span> (i &lt; current-&gt;CurrentSize())
00415                         <span class="keywordflow">return</span> (*current)[i];
00416                 
00417                 i -= current-&gt;CurrentSize();
00418         }
00419 
00420         assert(i &lt; m_lazyLength);
00421         <span class="keywordflow">return</span> m_lazyString[i];
00422 }
00423 
00424 <span class="keywordtype">void</span> ByteQueue::swap(<a class="code" href="class_byte_queue.html">ByteQueue</a> &amp;rhs)
00425 {
00426         std::swap(m_nodeSize, rhs.<a class="code" href="class_byte_queue.html#_byte_queuer0">m_nodeSize</a>);
00427         std::swap(m_head, rhs.<a class="code" href="class_byte_queue.html#_byte_queuer1">m_head</a>);
00428         std::swap(m_tail, rhs.<a class="code" href="class_byte_queue.html#_byte_queuer2">m_tail</a>);
00429         std::swap(m_lazyString, rhs.<a class="code" href="class_byte_queue.html#_byte_queuer3">m_lazyString</a>);
00430         std::swap(m_lazyLength, rhs.<a class="code" href="class_byte_queue.html#_byte_queuer4">m_lazyLength</a>);
00431 }
00432 
00433 <span class="comment">// ********************************************************</span>
00434 
00435 <span class="keywordtype">void</span> ByteQueue::Walker::IsolatedInitialize(<span class="keyword">const</span> <a class="code" href="class_name_value_pairs.html">NameValuePairs</a> &amp;parameters)
00436 {
00437         m_node = m_queue.m_head;
00438         m_position = 0;
00439         m_offset = 0;
00440         m_lazyString = m_queue.m_lazyString;
00441         m_lazyLength = m_queue.m_lazyLength;
00442 }
00443 
00444 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera8">ByteQueue::Walker::Get</a>(byte &amp;outByte)
00445 {
00446         <a class="code" href="class_array_sink.html">ArraySink</a> sink(&amp;outByte, 1);
00447         <span class="keywordflow">return</span> <a class="code" href="class_buffered_transformation.html#_zlib_decompressorz7_10">TransferTo</a>(sink, 1);
00448 }
00449 
00450 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera8">ByteQueue::Walker::Get</a>(byte *outString, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> getMax)
00451 {
00452         <a class="code" href="class_array_sink.html">ArraySink</a> sink(outString, getMax);
00453         <span class="keywordflow">return</span> <a class="code" href="class_buffered_transformation.html#_zlib_decompressorz7_10">TransferTo</a>(sink, getMax);
00454 }
00455 
00456 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera10">ByteQueue::Walker::Peek</a>(byte &amp;outByte)<span class="keyword"> const</span>
00457 <span class="keyword"></span>{
00458         <a class="code" href="class_array_sink.html">ArraySink</a> sink(&amp;outByte, 1);
00459         <span class="keywordflow">return</span> <a class="code" href="class_buffered_transformation.html#_zlib_decompressorz7_12">CopyTo</a>(sink, 1);
00460 }
00461 
00462 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera10">ByteQueue::Walker::Peek</a>(byte *outString, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> peekMax)<span class="keyword"> const</span>
00463 <span class="keyword"></span>{
00464         <a class="code" href="class_array_sink.html">ArraySink</a> sink(outString, peekMax);
00465         <span class="keywordflow">return</span> <a class="code" href="class_buffered_transformation.html#_zlib_decompressorz7_12">CopyTo</a>(sink, peekMax);
00466 }
00467 
00468 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> <a class="code" href="class_byte_queue.html#_d_e_r_set_encodera12">ByteQueue::Walker::TransferTo2</a>(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &amp;target, <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> &amp;transferBytes, <span class="keyword">const</span> std::string &amp;channel, <span class="keywordtype">bool</span> blocking)
00469 {
00470         <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> bytesLeft = transferBytes;
00471         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> blockedBytes = 0;
00472 
00473         <span class="keywordflow">while</span> (m_node)
00474         {
00475                 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> len = STDMIN(bytesLeft, (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>)m_node-&gt;CurrentSize()-m_offset);
00476                 blockedBytes = target.<a class="code" href="class_buffered_transformation.html#_zlib_decompressorz13_8">ChannelPut2</a>(channel, m_node-&gt;buf+m_node-&gt;m_head+m_offset, len, 0, blocking);
00477 
00478                 <span class="keywordflow">if</span> (blockedBytes)
00479                         <span class="keywordflow">goto</span> done;
00480 
00481                 m_position += len;
00482                 bytesLeft -= len;
00483 
00484                 <span class="keywordflow">if</span> (!bytesLeft)
00485                 {
00486                         m_offset += len;
00487                         <span class="keywordflow">goto</span> done;
00488                 }
00489 
00490                 m_node = m_node-&gt;next;
00491                 m_offset = 0;
00492         }
00493 
00494         <span class="keywordflow">if</span> (bytesLeft &amp;&amp; m_lazyLength)
00495         {
00496                 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> len = (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>)STDMIN(bytesLeft, (<span class="keywordtype">unsigned</span> <span class="keywordtype">long</span>)m_lazyLength);
00497                 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> blockedBytes = target.<a class="code" href="class_buffered_transformation.html#_zlib_decompressorz13_8">ChannelPut2</a>(channel, m_lazyString, len, 0, blocking);
00498                 <span class="keywordflow">if</span> (blockedBytes)
00499                         <span class="keywordflow">goto</span> done;
00500 
00501                 m_lazyString += len;
00502                 m_lazyLength -= len;
00503                 bytesLeft -= len;
00504         }
00505 
00506 done:
00507         transferBytes -= bytesLeft;
00508         <span class="keywordflow">return</span> blockedBytes;
00509 }
00510 
00511 <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ByteQueue::Walker::CopyRangeTo2(<a class="code" href="class_buffered_transformation.html">BufferedTransformation</a> &amp;target, <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> &amp;begin, <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> end, <span class="keyword">const</span> std::string &amp;channel, <span class="keywordtype">bool</span> blocking)<span class="keyword"> const</span>
00512 <span class="keyword"></span>{
00513         Walker walker(*<span class="keyword">this</span>);
00514         walker.Skip(begin);
00515         <span class="keywordtype">unsigned</span> <span class="keywordtype">long</span> transferBytes = end-begin;
00516         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> blockedBytes = walker.TransferTo2(target, transferBytes, channel, blocking);
00517         begin += transferBytes;
00518         <span class="keywordflow">return</span> blockedBytes;
00519 }
00520 
00521 NAMESPACE_END
00522 
00523 <span class="preprocessor">#endif</span>
</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue Jul 8 23:34:22 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>