Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  *
       3                 :            :  * Copyright 2006,2007 Savarese Software Research Corporation
       4                 :            :  *
       5                 :            :  * Licensed under the Apache License, Version 2.0 (the "License");
       6                 :            :  * you may not use this file except in compliance with the License.
       7                 :            :  * You may obtain a copy of the License at
       8                 :            :  *
       9                 :            :  *     http://www.savarese.com/software/ApacheLicense-2.0
      10                 :            :  *
      11                 :            :  * Unless required by applicable law or agreed to in writing, software
      12                 :            :  * distributed under the License is distributed on an "AS IS" BASIS,
      13                 :            :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14                 :            :  * See the License for the specific language governing permissions and
      15                 :            :  * limitations under the License.
      16                 :            :  */
      17                 :            : 
      18                 :            : #include <ssrc/spread/ScatterMessage.h>
      19                 :            : 
      20                 :            : __BEGIN_NS_SSRC_SPREAD
      21                 :            : 
      22                 :            : /**
      23                 :            :  * Handles auto-resizing prior to a receive.  Each message part that
      24                 :            :  * is a Message instance is resized to its capacity so that it may be
      25                 :            :  * completely filled if necessary.  The size of the ScatterMessage is
      26                 :            :  * adjusted accordingly.
      27                 :            :  */
      28                 :          8 : void ScatterMessage::init_pre_receive() {
      29                 :          8 :   int size = _messages.size();
      30                 :            : 
      31         [ +  + ]:         17 :   for(int i = 0; i < size; ++i) {
      32                 :          9 :     value_type & value = _messages[i];
      33                 :          9 :     Message *m = value.first;
      34                 :            : 
      35         [ -  + ]:          9 :     if(value.second >= _scatter.num_elements)
      36                 :          0 :       break;
      37                 :            : 
      38                 :          9 :     _size-=m->size();
      39                 :          9 :     m->resize(m->capacity());
      40                 :          9 :     _size+=m->size();
      41                 :          9 :     _scatter.elements[value.second].len = m->size();
      42                 :            :   }
      43                 :          8 : }
      44                 :            : 
      45                 :            : /**
      46                 :            :  * Handles auto-resizing after a receive.  Each message part that is a
      47                 :            :  * Message instance is resized to reflect the number of bytes that was
      48                 :            :  * stored in it by the receive.  The type, service, endian mismatch,
      49                 :            :  * and sender of eatch Message is set to that of the message (copied
      50                 :            :  * from the ScatterMessage).
      51                 :            :  *
      52                 :            :  * @param bytes_received The total number of bytes received.  May be
      53                 :            :  * negative in case of an error.
      54                 :            :  */
      55                 :          8 : void ScatterMessage::init_post_receive(int bytes_received) {
      56                 :          8 :   int index = 0, i, len;
      57                 :          8 :   int size = _messages.size();
      58                 :            :   Message *m;
      59                 :            : 
      60         [ +  + ]:          8 :   if(bytes_received > 0)
      61                 :          7 :     _size = bytes_received;
      62                 :            :   else
      63                 :          1 :     _size = 0;
      64                 :            : 
      65 [ +  + ][ +  + ]:         15 :   for(i = 0; i < size && bytes_received > 0; ++i) {
                 [ +  + ]
      66                 :          7 :     value_type & value = _messages[i];
      67                 :          7 :     int mindex = value.second;
      68         [ -  + ]:          7 :     if(mindex >= _scatter.num_elements)
      69                 :          0 :       break;
      70                 :            : 
      71         [ -  + ]:          7 :     while(index < mindex)
      72                 :          0 :       bytes_received-=_scatter.elements[index++].len;
      73                 :            : 
      74         [ -  + ]:          7 :     if(bytes_received <= 0)
      75                 :          0 :       break;
      76                 :            : 
      77                 :          7 :     len = _scatter.elements[mindex].len;
      78                 :          7 :     m   = value.first;
      79                 :            : 
      80                 :          7 :     m->set_type(type());
      81                 :          7 :     m->set_service(service());
      82                 :          7 :     m->set_endian_mismatch(endian_mismatch());
      83                 :          7 :     m->set_sender(_sender);
      84                 :            : 
      85         [ +  + ]:          7 :     if(len <= bytes_received)
      86                 :          1 :       m->resize(len);
      87                 :            :     else
      88                 :          6 :       m->resize(bytes_received);
      89                 :            : 
      90                 :          7 :     bytes_received-=len;
      91                 :            :   }
      92                 :            : 
      93                 :            :   // Anything left over gets a size of zero.
      94         [ +  + ]:         10 :   for(; i < size; ++i) {
      95                 :          2 :     m = _messages[i].first;
      96                 :          2 :     m->resize(0);
      97                 :          2 :     m->set_type(type());
      98                 :          2 :     m->set_service(service());
      99                 :          2 :     m->set_endian_mismatch(endian_mismatch());
     100                 :          2 :     m->set_sender(_sender);
     101                 :            :   }
     102                 :          8 : }
     103                 :            : 
     104                 :            : /**
     105                 :            :  * Adds a message part to the ScatterMessage with a designated number
     106                 :            :  * of bytes indicating either the capacity of the buffer (for
     107                 :            :  * receiving) or the length of its contents (for sending).
     108                 :            :  *
     109                 :            :  * @param data A pointer to the data buffer to add.
     110                 :            :  * @param size The number of bytes to be filled in to or read from the
     111                 :            :  * data buffer.
     112                 :            :  * @return true if the message part was added, false if there's no
     113                 :            :  * more parts can be added.
     114                 :            :  */
     115                 :         21 : bool ScatterMessage::add(const void *data, const unsigned int size) {
     116                 :         21 :   int i = _scatter.num_elements;
     117                 :            : 
     118         [ -  + ]:         21 :   if(i >= MaxScatterElements)
     119                 :          0 :     return false;
     120                 :            : 
     121                 :         21 :   ++_scatter.num_elements;
     122                 :            :   _scatter.elements[i].buf = 
     123                 :         21 :     const_cast<char *>(static_cast<const char *>(data));
     124                 :         21 :   _scatter.elements[i].len = size;
     125                 :         21 :   _size+=size;
     126                 :            : 
     127                 :         21 :   return true;
     128                 :            : }
     129                 :            : 
     130                 :            : __END_NS_SSRC_SPREAD