Repository navigation
Expand file tree
/
Copy pathBZ2File.cs
More file actions
217 lines (175 loc) · 7.52 KB
/
Copy pathBZ2File.cs
File metadata and controls
217 lines (175 loc) · 7.52 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
//
// Copyright 2012 Jeff Hardy
//
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using Ionic.BZip2;
using IronPython.Runtime;
using Microsoft.Scripting.Runtime;
using IronPython.Runtime.Operations;
using Microsoft.Scripting.Utils;
namespace IronPython.Modules.Bz2 {
public static partial class Bz2Module {
[PythonType]
public class BZ2File : PythonFile {
public const string __doc__ =
@"BZ2File(name [, mode='r', buffering=0, compresslevel=9]) -> file object
Open a bz2 file. The mode can be 'r' or 'w', for reading (default) or
writing. When opened for writing, the file will be created if it doesn't
exist, and truncated otherwise. If the buffering argument is given, 0 means
unbuffered, and larger numbers specify the buffer size. If compresslevel
is given, must be a number between 1 and 9.
";
public int buffering { get; private set; }
public int compresslevel { get; private set; }
private Stream bz2Stream;
public BZ2File(CodeContext context) : base(context) { }
public void __init__(CodeContext context,
string filename,
[DefaultParameterValue("r")]string mode,
[DefaultParameterValue(0)]int buffering,
[DefaultParameterValue(DEFAULT_COMPRESSLEVEL)]int compresslevel) {
var pythonContext = context.LanguageContext;
this.buffering = buffering;
this.compresslevel = compresslevel;
if (!mode.Contains("b") && !mode.Contains("U")) {
// bz2 files are always written in binary mode, unless they are in univeral newline mode
mode = mode + 'b';
}
if (mode.Contains("w")) {
var underlyingStream = File.Open(filename, FileMode.Create, FileAccess.Write);
if (mode.Contains("p")) {
this.bz2Stream = new ParallelBZip2OutputStream(underlyingStream);
} else {
this.bz2Stream = new BZip2OutputStream(underlyingStream);
}
} else {
this.bz2Stream = new BZip2InputStream(File.OpenRead(filename));
}
this.__init__(bz2Stream, pythonContext.DefaultEncoding, filename, mode);
}
[Documentation(@"close() -> None or (perhaps) an integer
Close the file. Sets data attribute .closed to true. A closed file
cannot be used for further I/O operations. close() may be called more
than once without error.
")]
public new void close() {
base.close();
}
[Documentation(@"read([size]) -> string
Read at most size uncompressed bytes, returned as a string. If the size
argument is negative or omitted, read until EOF is reached.
")]
public new string read() {
ThrowIfClosed();
return base.read();
}
public new string read(int size) {
ThrowIfClosed();
return base.read(size);
}
[Documentation(@"readline([size]) -> string
Return the next line from the file, as a string, retaining newline.
A non-negative size argument will limit the maximum number of bytes to
return (an incomplete line may be returned then). Return an empty
string at EOF.
")]
public new string readline() {
ThrowIfClosed();
return base.readline();
}
public new string readline(int sizehint) {
ThrowIfClosed();
return base.readline(sizehint);
}
[Documentation(@"readlines([size]) -> list
Call readline() repeatedly and return a list of lines read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.
")]
public new List readlines() {
if (this.closed) throw PythonOps.ValueError("I/O operation on closed file");
return base.readlines();
}
public new List readlines(int sizehint) {
if (this.closed) throw PythonOps.ValueError("I/O operation on closed file");
return base.readlines(sizehint);
}
[Documentation(@"xreadlines() -> self
For backward compatibility. BZ2File objects now include the performance
optimizations previously implemented in the xreadlines module.
")]
public new BZ2File xreadlines() {
return this;
}
[Documentation(@"seek(offset [, whence]) -> None
Move to new file position. Argument offset is a byte count. Optional
argument whence defaults to 0 (offset from start of file, offset
should be >= 0); other values are 1 (move relative to current position,
positive or negative), and 2 (move relative to end of file, usually
negative, although many platforms allow seeking beyond the end of a file).
Note that seeking of bz2 files is emulated, and depending on the parameters
the operation may be extremely slow.
")]
public new void seek(long offset, [DefaultParameterValue(0)]int whence) {
throw new NotImplementedException();
//if (this.closed) throw PythonOps.ValueError("I/O operation on closed file");
//base.seek(offset, whence);
}
[Documentation(@"tell() -> int
Return the current file position, an integer (may be a long integer).
")]
public new object tell() {
throw new NotImplementedException();
//if (this.closed) throw PythonOps.ValueError("I/O operation on closed file");
//return base.tell();
}
[Documentation(@"write(data) -> None
Write the 'data' string to file. Note that due to buffering, close() may
be needed before the file on disk reflects the data written.
")]
public new void write([BytesConversion]IList<byte> data) {
ThrowIfClosed();
base.write(data);
}
public new void write(object data) {
ThrowIfClosed();
base.write(data);
}
public new void write(string data) {
ThrowIfClosed();
base.write(data);
}
public new void write(PythonBuffer data) {
ThrowIfClosed();
base.write(data);
}
[Documentation(@"writelines(sequence_of_strings) -> None
Write the sequence of strings to the file. Note that newlines are not
added. The sequence can be any iterable object producing strings. This is
equivalent to calling write() for each string.
")]
public new void writelines(object sequence_of_strings) {
ThrowIfClosed();
base.writelines(sequence_of_strings);
}
public void __del__() {
this.close();
}
[Documentation("__enter__() -> self.")]
public new object __enter__() {
ThrowIfClosed();
return this;
}
[Documentation("__exit__(*excinfo) -> None. Closes the file.")]
public new void __exit__(params object[] excinfo) {
this.close();
}
}
}
}