← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Aaron Bentley
  • Date: 2007-01-26 04:00:12 UTC
  • mfrom: (2245 +trunk)
  • mto: (2255.6.1 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: aaron.bentley@utoronto.ca-20070126040012-j80k7qhvj80dyp9j
merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
37
37
    lockable_files,
38
38
    lockdir,
39
39
    osutils,
 
40
    registry,
40
41
    revision as _mod_revision,
41
42
    symbol_versioning,
42
43
    transactions,
98
99
 
99
100
        returns the sha1 of the serialized inventory.
100
101
        """
 
102
        _mod_revision.check_not_reserved_id(revid)
101
103
        assert inv.revision_id is None or inv.revision_id == revid, \
102
104
            "Mismatch between inventory revision" \
103
105
            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)
129
131
                       If supplied its signature_needed method will be used
130
132
                       to determine if a signature should be made.
131
133
        """
 
134
        _mod_revision.check_not_reserved_id(rev_id)
132
135
        if config is not None and config.signature_needed():
133
136
            if inv is None:
134
137
                inv = self.get_inventory(rev_id)
1143
1146
        self._serializer = xml7.serializer_v7
1144
1147
 
1145
1148
 
 
1149
class RepositoryFormatRegistry(registry.Registry):
 
1150
    """Registry of RepositoryFormats.
 
1151
    """
 
1152
    
 
1153
 
 
1154
format_registry = RepositoryFormatRegistry()
 
1155
"""Registry of formats, indexed by their identifying format string."""
 
1156
 
 
1157
 
1146
1158
class RepositoryFormat(object):
1147
1159
    """A repository format.
1148
1160
 
1167
1179
    parameterisation.
1168
1180
    """
1169
1181
 
1170
 
    _default_format = None
1171
 
    """The default format used for new repositories."""
1172
 
 
1173
 
    _formats = {}
1174
 
    """The known formats."""
1175
 
 
1176
1182
    def __str__(self):
1177
1183
        return "<%s>" % self.__class__.__name__
1178
1184
 
1179
1185
    @classmethod
1180
1186
    def find_format(klass, a_bzrdir):
1181
 
        """Return the format for the repository object in a_bzrdir."""
 
1187
        """Return the format for the repository object in a_bzrdir.
 
1188
        
 
1189
        This is used by bzr native formats that have a "format" file in
 
1190
        the repository.  Other methods may be used by different types of 
 
1191
        control directory.
 
1192
        """
1182
1193
        try:
1183
1194
            transport = a_bzrdir.get_repository_transport(None)
1184
1195
            format_string = transport.get("format").read()
1185
 
            return klass._formats[format_string]
 
1196
            return format_registry.get(format_string)
1186
1197
        except errors.NoSuchFile:
1187
1198
            raise errors.NoRepositoryPresent(a_bzrdir)
1188
1199
        except KeyError:
1189
1200
            raise errors.UnknownFormatError(format=format_string)
1190
1201
 
1191
 
    def _get_control_store(self, repo_transport, control_files):
1192
 
        """Return the control store for this repository."""
1193
 
        raise NotImplementedError(self._get_control_store)
 
1202
    @classmethod
 
1203
    @deprecated_method(symbol_versioning.zero_fourteen)
 
1204
    def set_default_format(klass, format):
 
1205
        klass._set_default_format(format)
 
1206
 
 
1207
    @classmethod
 
1208
    def _set_default_format(klass, format):
 
1209
        """Set the default format for new Repository creation.
 
1210
 
 
1211
        The format must already be registered.
 
1212
        """
 
1213
        format_registry.default_key = format.get_format_string()
 
1214
 
 
1215
    @classmethod
 
1216
    def register_format(klass, format):
 
1217
        format_registry.register(format.get_format_string(), format)
 
1218
 
 
1219
    @classmethod
 
1220
    def unregister_format(klass, format):
 
1221
        format_registry.remove(format.get_format_string())
1194
1222
    
1195
1223
    @classmethod
1196
1224
    def get_default_format(klass):
1197
1225
        """Return the current default format."""
1198
 
        return klass._default_format
 
1226
        return format_registry.get(format_registry.default_key)
 
1227
 
 
1228
    def _get_control_store(self, repo_transport, control_files):
 
1229
        """Return the control store for this repository."""
 
1230
        raise NotImplementedError(self._get_control_store)
1199
1231
 
1200
1232
    def get_format_string(self):
1201
1233
        """Return the ASCII format string that identifies this format.
1283
1315
        """
1284
1316
        raise NotImplementedError(self.open)
1285
1317
 
1286
 
    @classmethod
1287
 
    def register_format(klass, format):
1288
 
        klass._formats[format.get_format_string()] = format
1289
 
 
1290
 
    @classmethod
1291
 
    @deprecated_method(symbol_versioning.zero_fourteen)
1292
 
    def set_default_format(klass, format):
1293
 
        klass._set_default_format(format)
1294
 
 
1295
 
    @classmethod
1296
 
    def _set_default_format(klass, format):
1297
 
        klass._default_format = format
1298
 
 
1299
 
    @classmethod
1300
 
    def unregister_format(klass, format):
1301
 
        assert klass._formats[format.get_format_string()] is format
1302
 
        del klass._formats[format.get_format_string()]
1303
 
 
1304
1318
 
1305
1319
class PreSplitOutRepositoryFormat(RepositoryFormat):
1306
1320
    """Base class for the pre split out repository formats."""
1428
1442
    def _get_text_store(self, transport, control_files):
1429
1443
        """See RepositoryFormat._get_text_store()."""
1430
1444
 
1431
 
 
1432
1445
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1433
1446
    """Bzr control format 5.
1434
1447
 
1858
1871
# formats which have no format string are not discoverable
1859
1872
# and not independently creatable, so are not registered.
1860
1873
RepositoryFormat.register_format(RepositoryFormat7())
1861
 
# KEEP in sync with bzrdir.format_registry default
 
1874
# KEEP in sync with bzrdir.format_registry default, which controls the overall
 
1875
# default control directory format
1862
1876
_default_format = RepositoryFormatKnit1()
1863
1877
RepositoryFormat.register_format(_default_format)
1864
1878
RepositoryFormat.register_format(RepositoryFormatKnit2())