← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/xml8.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/xml8.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
import cStringIO
18
18
import re
24
24
    revision as _mod_revision,
25
25
    trace,
26
26
    )
27
 
from bzrlib.xml_serializer import SubElement, Element, Serializer
 
27
from bzrlib.xml_serializer import (
 
28
    Element,
 
29
    SubElement,
 
30
    XMLSerializer,
 
31
    escape_invalid_chars,
 
32
    )
28
33
from bzrlib.inventory import ROOT_ID, Inventory, InventoryEntry
29
34
from bzrlib.revision import Revision
30
35
from bzrlib.errors import BzrError
92
97
    # to check if None, rather than try/KeyError
93
98
    text = _map.get(unicode_or_utf8_str)
94
99
    if text is None:
95
 
        if unicode_or_utf8_str.__class__ == unicode:
 
100
        if unicode_or_utf8_str.__class__ is unicode:
96
101
            # The alternative policy is to do a regular UTF8 encoding
97
102
            # and then escape only XML meta characters.
98
103
            # Performance is equivalent once you use cache_utf8. *However*
128
133
    # This is fairly optimized because we know what cElementTree does, this is
129
134
    # not meant as a generic function for all cases. Because it is possible for
130
135
    # an 8-bit string to not be ascii or valid utf8.
131
 
    if a_str.__class__ == unicode:
 
136
    if a_str.__class__ is unicode:
132
137
        return _encode_utf8(a_str)
133
138
    else:
134
 
        return _get_cached_ascii(a_str)
 
139
        return intern(a_str)
135
140
 
136
141
 
137
142
def _clear_cache():
139
144
    _to_escaped_map.clear()
140
145
 
141
146
 
142
 
class Serializer_v8(Serializer):
 
147
class Serializer_v8(XMLSerializer):
143
148
    """This serialiser adds rich roots.
144
149
 
145
150
    Its revision format number matches its inventory number.
160
165
        """Extension point for subclasses to check during serialisation.
161
166
 
162
167
        :param inv: An inventory about to be serialised, to be checked.
163
 
        :raises: AssertionError if an error has occured.
 
168
        :raises: AssertionError if an error has occurred.
164
169
        """
165
170
        if inv.revision_id is None:
166
 
            raise AssertionError()
 
171
            raise AssertionError("inv.revision_id is None")
167
172
        if inv.root.revision is None:
168
 
            raise AssertionError()
 
173
            raise AssertionError("inv.root.revision is None")
169
174
 
170
175
    def _check_cache_size(self, inv_size, entry_cache):
171
176
        """Check that the entry_cache is large enough.
211
216
 
212
217
    def write_inventory(self, inv, f, working=False):
213
218
        """Write inventory to a file.
214
 
        
 
219
 
215
220
        :param inv: the inventory to write.
216
221
        :param f: the file to write. (May be None if the lines are the desired
217
222
            output).
341
346
            root.set('timezone', str(rev.timezone))
342
347
        root.text = '\n'
343
348
        msg = SubElement(root, 'message')
344
 
        msg.text = rev.message
 
349
        msg.text = escape_invalid_chars(rev.message)[0]
345
350
        msg.tail = '\n'
346
351
        if rev.parent_ids:
347
352
            pelts = SubElement(root, 'parents')
366
371
            prop_elt.tail = '\n'
367
372
        top_elt.tail = '\n'
368
373
 
369
 
    def _unpack_inventory(self, elt, revision_id=None, entry_cache=None):
 
374
    def _unpack_inventory(self, elt, revision_id=None, entry_cache=None,
 
375
                          return_from_cache=False):
370
376
        """Construct from XML Element"""
371
377
        if elt.tag != 'inventory':
372
378
            raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
379
385
            revision_id = cache_utf8.encode(revision_id)
380
386
        inv = inventory.Inventory(root_id=None, revision_id=revision_id)
381
387
        for e in elt:
382
 
            ie = self._unpack_entry(e, entry_cache=entry_cache)
 
388
            ie = self._unpack_entry(e, entry_cache=entry_cache,
 
389
                                    return_from_cache=return_from_cache)
383
390
            inv.add(ie)
384
391
        self._check_cache_size(len(inv), entry_cache)
385
392
        return inv
386
393
 
387
 
    def _unpack_entry(self, elt, entry_cache=None):
 
394
    def _unpack_entry(self, elt, entry_cache=None, return_from_cache=False):
388
395
        elt_get = elt.get
389
396
        file_id = elt_get('file_id')
390
397
        revision = elt_get('revision')
422
429
        if entry_cache is not None and revision is not None:
423
430
            key = (file_id, revision)
424
431
            try:
425
 
                # We copy it, because some operatations may mutate it
 
432
                # We copy it, because some operations may mutate it
426
433
                cached_ie = entry_cache[key]
427
434
            except KeyError:
428
435
                pass
429
436
            else:
430
437
                # Only copying directory entries drops us 2.85s => 2.35s
431
 
                # if cached_ie.kind == 'directory':
432
 
                #     return cached_ie.copy()
433
 
                # return cached_ie
 
438
                if return_from_cache:
 
439
                    if cached_ie.kind == 'directory':
 
440
                        return cached_ie.copy()
 
441
                    return cached_ie
434
442
                return cached_ie.copy()
435
443
 
436
444
        kind = elt.tag