← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/pack.py

  • Committer: Matt Nordhoff
  • Date: 2009-04-04 02:50:01 UTC
  • mfrom: (4253 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: mnordhoff@mattnordhoff.com-20090404025001-z1403k0tatmc8l91
Merge bzr.dev, fixing conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/pack.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Container format for Bazaar data.
18
18
 
34
34
 
35
35
def _check_name(name):
36
36
    """Do some basic checking of 'name'.
37
 
    
 
37
 
38
38
    At the moment, this just checks that there are no whitespace characters in a
39
39
    name.
40
40
 
47
47
 
48
48
def _check_name_encoding(name):
49
49
    """Check that 'name' is valid UTF-8.
50
 
    
 
50
 
51
51
    This is separate from _check_name because UTF-8 decoding is relatively
52
52
    expensive, and we usually want to avoid it.
53
53
 
61
61
 
62
62
class ContainerSerialiser(object):
63
63
    """A helper class for serialising containers.
64
 
    
 
64
 
65
65
    It simply returns bytes from method calls to 'begin', 'end' and
66
66
    'bytes_record'.  You may find ContainerWriter to be a more convenient
67
67
    interface.
138
138
 
139
139
    def add_bytes_record(self, bytes, names):
140
140
        """Add a Bytes record with the given names.
141
 
        
 
141
 
142
142
        :param bytes: The bytes to insert.
143
143
        :param names: The names to give the inserted bytes. Each name is
144
144
            a tuple of bytestrings. The bytestrings may not contain
241
241
            names1, callable1 = record_iter.next()
242
242
            names2, callable2 = record_iter.next()
243
243
            bytes1 = callable1(None)
244
 
        
 
244
 
245
245
        As it will give incorrect results and invalidate the state of the
246
246
        ContainerReader.
247
247
 
252
252
        """
253
253
        self._read_format()
254
254
        return self._iter_records()
255
 
    
 
255
 
256
256
    def iter_record_objects(self):
257
257
        """Iterate over the container, yielding each record as it is read.
258
258
 
267
267
        """
268
268
        self._read_format()
269
269
        return self._iter_record_objects()
270
 
    
 
270
 
271
271
    def _iter_records(self):
272
272
        for record in self._iter_record_objects():
273
273
            yield record.read()
342
342
        except ValueError:
343
343
            raise errors.InvalidRecordError(
344
344
                "%r is not a valid length." % (length_line,))
345
 
        
 
345
 
346
346
        # Read the list of names.
347
347
        names = []
348
348
        while True:
411
411
            self._state_handler()
412
412
            cur_buffer_length = len(self._buffer)
413
413
 
414
 
    def read_pending_records(self):
415
 
        records = self._parsed_records
416
 
        self._parsed_records = []
417
 
        return records
418
 
    
 
414
    def read_pending_records(self, max=None):
 
415
        if max:
 
416
            records = self._parsed_records[:max]
 
417
            del self._parsed_records[:max]
 
418
            return records
 
419
        else:
 
420
            records = self._parsed_records
 
421
            self._parsed_records = []
 
422
            return records
 
423
 
419
424
    def _consume_line(self):
420
425
        """Take a line out of the buffer, and return the line.
421
426
 
468
473
            for name_part in name_parts:
469
474
                _check_name(name_part)
470
475
            self._current_record_names.append(name_parts)
471
 
            
 
476
 
472
477
    def _state_expecting_body(self):
473
478
        if len(self._buffer) >= self._current_record_length:
474
479
            body_bytes = self._buffer[:self._current_record_length]