iframe-proxy | Sunbelt Computer Software

History

315 lines (213 loc) · 7.83 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

# This module is part of GitDB and is released under

# the New BSD License: https://opensource.org/license/bsd-3-clause/

"""Module with basic data structures - they are designed to be lightweight and fast"""

from gitdb.util import bin_to_hex

from gitdb.fun import (

type_id_to_type_map,

type_to_type_id_map

)

__all__ = ('OInfo', 'OPackInfo', 'ODeltaPackInfo',

'OStream', 'OPackStream', 'ODeltaPackStream',

'IStream', 'InvalidOInfo', 'InvalidOStream')

#{ ODB Bases

class OInfo(tuple):

"""Carries information about an object in an ODB, providing information

about the binary sha of the object, the type_string as well as the uncompressed size

in bytes.

It can be accessed using tuple notation and using attribute access notation::

assert dbi[0] == dbi.binsha

assert dbi[1] == dbi.type

assert dbi[2] == dbi.size

The type is designed to be as lightweight as possible."""

__slots__ = tuple()

def __new__(cls, sha, type, size):

return tuple.__new__(cls, (sha, type, size))

def __init__(self, *args):

tuple.__init__(self)

#{ Interface

@property

def binsha(self):

""":return: our sha as binary, 20 bytes"""

return self[0]

@property

def hexsha(self):

""":return: our sha, hex encoded, 40 bytes"""

return bin_to_hex(self[0])

@property

def type(self):

return self[1]

@property

def type_id(self):

return type_to_type_id_map[self[1]]

@property

def size(self):

return self[2]

#} END interface

class OPackInfo(tuple):

"""As OInfo, but provides a type_id property to retrieve the numerical type id, and

does not include a sha.

Additionally, the pack_offset is the absolute offset into the packfile at which

all object information is located. The data_offset property points to the absolute

location in the pack at which that actual data stream can be found."""

__slots__ = tuple()

def __new__(cls, packoffset, type, size):

return tuple.__new__(cls, (packoffset, type, size))

def __init__(self, *args):

tuple.__init__(self)

#{ Interface

@property

def pack_offset(self):

return self[0]

@property

def type(self):

return type_id_to_type_map[self[1]]

@property

def type_id(self):

return self[1]

@property

def size(self):

return self[2]

#} END interface

class ODeltaPackInfo(OPackInfo):

"""Adds delta specific information,

Either the 20 byte sha which points to some object in the database,

or the negative offset from the pack_offset, so that pack_offset - delta_info yields

the pack offset of the base object"""

__slots__ = tuple()

def __new__(cls, packoffset, type, size, delta_info):

return tuple.__new__(cls, (packoffset, type, size, delta_info))

#{ Interface

@property

def delta_info(self):

return self[3]

#} END interface

class OStream(OInfo):

"""Base for object streams retrieved from the database, providing additional

information about the stream.

Generally, ODB streams are read-only as objects are immutable"""

__slots__ = tuple()

def __new__(cls, sha, type, size, stream, *args, **kwargs):

"""Helps with the initialization of subclasses"""

return tuple.__new__(cls, (sha, type, size, stream))

def __init__(self, *args, **kwargs):

tuple.__init__(self)

#{ Stream Reader Interface

def read(self, size=-1):

return self[3].read(size)

@property

def stream(self):

return self[3]

#} END stream reader interface

class ODeltaStream(OStream):

"""Uses size info of its stream, delaying reads"""

def __new__(cls, sha, type, size, stream, *args, **kwargs):

"""Helps with the initialization of subclasses"""

return tuple.__new__(cls, (sha, type, size, stream))

#{ Stream Reader Interface

@property

def size(self):

return self[3].size

#} END stream reader interface

class OPackStream(OPackInfo):

"""Next to pack object information, a stream outputting an undeltified base object

is provided"""

__slots__ = tuple()

def __new__(cls, packoffset, type, size, stream, *args):

"""Helps with the initialization of subclasses"""

return tuple.__new__(cls, (packoffset, type, size, stream))

#{ Stream Reader Interface

def read(self, size=-1):

return self[3].read(size)

@property

def stream(self):

return self[3]

#} END stream reader interface

class ODeltaPackStream(ODeltaPackInfo):

"""Provides a stream outputting the uncompressed offset delta information"""

__slots__ = tuple()

def __new__(cls, packoffset, type, size, delta_info, stream):

return tuple.__new__(cls, (packoffset, type, size, delta_info, stream))

#{ Stream Reader Interface

def read(self, size=-1):

return self[4].read(size)

@property

def stream(self):

return self[4]

#} END stream reader interface

class IStream(list):

"""Represents an input content stream to be fed into the ODB. It is mutable to allow

the ODB to record information about the operations outcome right in this instance.

It provides interfaces for the OStream and a StreamReader to allow the instance

to blend in without prior conversion.

The only method your content stream must support is 'read'"""

__slots__ = tuple()

def __new__(cls, type, size, stream, sha=None):

return list.__new__(cls, (sha, type, size, stream, None))

def __init__(self, type, size, stream, sha=None):

list.__init__(self, (sha, type, size, stream, None))

#{ Interface

@property

def hexsha(self):

""":return: our sha, hex encoded, 40 bytes"""

return bin_to_hex(self[0])

def _error(self):

""":return: the error that occurred when processing the stream, or None"""

return self[4]

def _set_error(self, exc):

"""Set this input stream to the given exc, may be None to reset the error"""

self[4] = exc

error = property(_error, _set_error)

#} END interface

#{ Stream Reader Interface

def read(self, size=-1):

"""Implements a simple stream reader interface, passing the read call on

to our internal stream"""

return self[3].read(size)

#} END stream reader interface

#{ interface

def _set_binsha(self, binsha):

self[0] = binsha

def _binsha(self):

return self[0]

binsha = property(_binsha, _set_binsha)

def _type(self):

return self[1]

def _set_type(self, type):

self[1] = type

type = property(_type, _set_type)

def _size(self):

return self[2]

def _set_size(self, size):

self[2] = size

size = property(_size, _set_size)

def _stream(self):

return self[3]

def _set_stream(self, stream):

self[3] = stream

stream = property(_stream, _set_stream)

#} END odb info interface

class InvalidOInfo(tuple):

"""Carries information about a sha identifying an object which is invalid in

the queried database. The exception attribute provides more information about

the cause of the issue"""

__slots__ = tuple()

def __new__(cls, sha, exc):

return tuple.__new__(cls, (sha, exc))

def __init__(self, sha, exc):

tuple.__init__(self, (sha, exc))

@property

def binsha(self):

return self[0]

@property

def hexsha(self):

return bin_to_hex(self[0])

@property

def error(self):

""":return: exception instance explaining the failure"""

return self[1]

class InvalidOStream(InvalidOInfo):

"""Carries information about an invalid ODB stream"""

__slots__ = tuple()

#} END ODB Bases

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

FilesExpand file tree

base.py

Latest commit

History

base.py

File metadata and controls