Convert this recorded RPC into a string.
490363
def serialize(self):
        """"""

        return "{},{: <26},{:2d},{:#06x},{:#04x},{:5.0f},{: <40},{: <40},{}".\
            format(self.connection, self.start_stamp.isoformat(), self.address, self.rpc_id,
                   self.status, self.runtime * 1000, self.call, self.response, self.error)
696110
def encode(self, V, P, X, CC, seqNum, M, PT, SSRC, payload):
        """"""
        timestamp = int(time())
        header = bytearray(HEADER_SIZE)
        # Fill the header bytearray with RTP header fields
        # ...
        header[0] = header[0] | V << 6; 
        header[0] = header[0] | P << 5; 
        header[0] = header[0] | X << 4; 
        header[0] = header[0] | CC; 
        header[1] = header[1] | M << 7; 
        header[1] = header[1] | PT; 
        header[2] = (seqNum >> 8) & 0xFF; 
        header[3] = seqNum & 0xFF; 
        header[4] = (timestamp >> 24) & 0xFF; 
        header[5] = (timestamp >> 16) & 0xFF;
        header[6] = (timestamp >> 8) & 0xFF;
        header[7] = timestamp & 0xFF;
        header[8] = (SSRC >> 24) & 0xFF; 
        header[9] = (SSRC >> 16) & 0xFF;
        header[10] = (SSRC >> 8) & 0xFF;
        header[11] = SSRC & 0xFF

        self.header = header
        
        # Get the payload
        # ...
        self.payload = payload
190619
def to_string(comp_type):
    '''

    '''
    if comp_type == NONE:
        return NONE
    elif comp_type== PERIODIC_EC_SHARED:
        return PERIODC_EC_SHARED
    elif comp_type == PERIODIC_STATE_SHARED:
        return PERIODIC_STATE_SHARED
    elif comp_type == GROUPING:
        return GROUPING
    elif comp_type == FSM_EC_SHARED:
        return FSM_EC_SHARED
    elif comp_type == FSM_STATE_SHARED:
        return FSM_STATE_SHARED
    else:
        raise InvalidCompositeTypeError(type_string)
1134084
def get_as_string(self, key):
        
        value = self.get(key)
        return StringConverter.to_string(value)
622072
def to_string(self):
        '''
        
        '''
        node = list()
        node.append(quote_if_necessary(str(self.name)))
        node.append(' [')
        flag = False
        for a in self.attr:
            flag = True
            node.append(a)
            node.append('=')
            node.append(quote_if_necessary(str(self.attr[a])))
            node.append(', ')
        if flag is True:
            node = node[:-1]
        node.append(']')
        return ''.join(node)
690665
def bt_addr_to_string(addr):
    """"""
    addr_str = array.array('B', addr)
    addr_str.reverse()
    hex_str = hexlify(addr_str.tostring()).decode('ascii')
    # insert ":" seperator between the bytes
    return ':'.join(a+b for a, b in zip(hex_str[::2], hex_str[1::2]))
991572
def to_str(self):
        '''
        
        '''
        dflt = super(DataportenAccount, self).to_str()
        return '%s (%s)' % (
            self.account.extra_data.get('name', ''),
            dflt,
        )
840941
def to_string(self):
        """"""
        suffix = '%s %s' % (self.type, self.name)
        if self.initial_value:
            suffix += ' = ' + self.initial_value
        return suffix
480446
def to_string(self, verbose=0):
        """"""
        lines = []
        app = lines.append
        for i, cycle in enumerate(self):
            app("")
            app("RELAXATION STEP: %d" % (i + 1))
            app(cycle.to_string(verbose=verbose))

        return "\n".join(lines)
257281
def r(self):
        """"""
        r_args = [_to_r(self.args), _to_r(self.kwargs)]
        # remove empty strings from the call args
        r_args = ",".join([x for x in r_args if x != ""])
        return "{}({})".format(self.name, r_args)
641975
def as_string(self, forsigning=False):
		
		ret = OutBuffer()
		self.serialize(ret, forsigning)
		return ret.getvalue()
595458
def to_str(self):
        ''''''
        pairs = []
        for name, value in self.get_all():
            if value and self._wrap_width:
                pairs.append('{0}:{1}'.format(
                    name,
                    '\r\n'.join(textwrap.wrap(
                        value, width=self._wrap_width,
                        drop_whitespace=False, initial_indent=' ',
                        subsequent_indent=' '
                    ))
                ))
            elif value:
                pairs.append('{0}: {1}'.format(name, value))
            else:
                pairs.append('{0}:'.format(name))

        pairs.append('')
        return '\r\n'.join(pairs)
11302
def to_text_format(self):
        ''''''
        return '\n'.join(itertools.chain(
            (self.fetch_date.strftime('%Y%m%d%H%M%S'), ),
            (rr.to_text() for rr in self.resource_records),
            (),
        ))
1147204
def to_string(self):
        
        fmt = '<BBH'
        first = struct.pack(
            fmt,
            self._mode,
            self._cr_timeout,
            self._auto_eject_time
        )

        #crc = 0xffff - yubico_util.crc16(first)
        #second = first + struct.pack('<H', crc)
        return first
890108
def pprint(self):
        

        s = u"ASF (%s) %d bps, %s Hz, %d channels, %.2f seconds" % (
            self.codec_type or self.codec_name or u"???", self.bitrate,
            self.sample_rate, self.channels, self.length)
        return s
125204
def to_str(data):
    
    if isinstance(data, bytes):
        return codecs.decode(data, TEXT_ENCODING)
    return data
830389
String
rrToString() {
	StringBuffer sb = new StringBuffer();
	sb.append(next);
	int length = bitmap.length();
	for (short i = 0; i < length; i++)
		if (bitmap.get(i)) {
			sb.append(" ");
			sb.append(Type.string(i));
		}
	return sb.toString();
}