def _createCutAndFlushRecord(self, blockettes, record_type): """ Takes all blockettes of a record and return a list of finished records. If necessary it will cut the record and return two or more flushed records. The returned records also include the control header type code and the record continuation code. Therefore the returned record will have the length self.record_length - 6. Other methods are responsible for writing the sequence number. It will always return a list with records. """ length = self.record_length - 8 return_records = [] # Loop over all blockettes. record = '' for blockette in blockettes: blockette.compact = self.compact rec_len = len(record) # Never split a blockette’s “length/blockette type” section across # records. if rec_len + 7 > length: # Flush the rest of the record if necessary. record += ' ' * (length - rec_len) return_records.append(record) record = '' rec_len = 0 blockette_str = blockette.getSEED() # Calculate how much of the blockette is too long. overhead = rec_len + len(blockette_str) - length # If negative overhead: Write blockette. if overhead <= 0: record += blockette_str # Otherwise finish the record and start one or more new ones. else: record += blockette_str[:len(blockette_str) - overhead] # The record so far not written. rest_of_the_record = blockette_str[(len(blockette_str) - overhead):] # Loop over the number of records to be written. for _i in xrange( int(math.ceil(len(rest_of_the_record) / float(length)))): return_records.append(record) record = '' # It doesn't hurt to index a string more than its length. record = record + \ rest_of_the_record[_i * length: (_i + 1) * length] if len(record) > 0: return_records.append(record) # Flush last record return_records[-1] = return_records[-1] + ' ' * \ (length - len(return_records[-1])) # Add control header and continuation code. return_records[0] = record_type + ' ' + return_records[0] for _i in range(len(return_records) - 1): return_records[_i + 1] = record_type + '*' + return_records[_i + 1] return return_records