Calculates the request payload size
492534
def calculate_size(name, uuid, callable, address):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_str(uuid)
    data_size += calculate_size_data(callable)
    data_size += calculate_size_address(address)
    return data_size
240872
def size(self):
        ""
        if getattr(self, '_size', None) is None:
            self._size = getattr(self.node, 'size', 0)
        return self._size
867538
def get_size(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.get_size.__func__.__name__,
                                                                 self.__class__.__name__))
984725
def calculate_size(name, txn_id, thread_id, key, value):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_str(txn_id)
    data_size += LONG_SIZE_IN_BYTES
    data_size += calculate_size_data(key)
    data_size += calculate_size_data(value)
    return data_size
195698
def Size(self):
        
        corrected_hashes = list(map(lambda i: UInt256(data=binascii.unhexlify(i)), self.HashStart))
        return GetVarSize(corrected_hashes) + self.hash_stop.Size
1337057
def calc_log_size(request, calc_id):
    
    try:
        response_data = logs.dbcmd('get_log_size', calc_id)
    except dbapi.NotFound:
        return HttpResponseNotFound()
    return HttpResponse(content=json.dumps(response_data), content_type=JSON)
867504
public static int minimumRequestSize(Request request) {

    // Header and payload are common inside a Frame at the protocol level

    // Frame header has a fixed size of 9 for protocol version >= V3, which includes Frame flags
    // size
    int size = FrameCodec.headerEncodedSize();

    if (!request.getCustomPayload().isEmpty()) {
      // Custom payload is not supported in v3, but assume user won't have a custom payload set if
      // they use this version
      size += PrimitiveSizes.sizeOfBytesMap(request.getCustomPayload());
    }

    return size;
  }
303080
def calculate_size(name, replace_existing_values):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += BOOLEAN_SIZE_IN_BYTES
    return data_size
316564
def transfer_size(self):
        """"""
        ts = self.attributes['transfer_size']
        if isinstance(ts, six.string_types):
            ts = shlex.split(ts)
        ts = [str(e) for e in ts]
        return ts
1279349
def calculate_size(name, max_size):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    return data_size
1304705
def calculate_content_length(self):
        """"""
        try:
            self._ensure_sequence()
        except RuntimeError:
            return None
        return sum(len(x) for x in self.response)
669125
def calculate_size(name, interceptor):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(interceptor)
    return data_size
203171
def calculate_size(name, listener_flags, local_only):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    data_size += BOOLEAN_SIZE_IN_BYTES
    return data_size
368506
def size(self):
        '''
            
        '''
        t = self._type
        if t.startswith('uint'):
            return int(t[len('uint'):])
        if t.startswith('int'):
            return int(t[len('int'):])
        if t == 'bool':
            return int(8)
        if t == 'address':
            return int(160)
        if t.startswith('bytes'):
            return int(t[len('bytes'):])
        return None
1034665
def Size(self):
        

        return s.uint8 + GetVarSize(self.Key) + GetVarSize(self.Field) + GetVarSize(self.Value)
688513
def _calc_size(self):
        
        return sum(os.path.getsize(filename)
            for filename in self.walk()
        )
83497
def calculate_size(name, value):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(value)
    return data_size