/* ****************************************************************************

*

* Copyright (c) Microsoft Corporation.

*

* This source code is subject to terms and conditions of the Apache License, Version 2.0. A

* copy of the license can be found in the License.html file at the root of this distribution. If

* you cannot locate the Apache License, Version 2.0, please send an email to

* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound

* by the terms of the Apache License, Version 2.0.

*

* You must not remove this notice, or any other, from this software.

*

*

* ***************************************************************************/

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Text;

using Microsoft.Scripting.Runtime;

using IronPython.Runtime;

using IronPython.Runtime.Exceptions;

using IronPython.Runtime.Operations;

using IronPython.Runtime.Types;

[assembly: PythonModule("cStringIO", typeof(IronPython.Modules.PythonStringIO))]

namespace IronPython.Modules {

class StringStream {

private StringBuilder _data; // builder used for reading/writing

private string _lastValue; // a cached copy of the builder in string form

private int _position; // our current position in the builder

public StringStream(string data) {

_data = new StringBuilder(_lastValue = data);

_position = 0;

}

public bool EOF {

get { return _position >= _data.Length; }

}

public int Position {

get { return _position; }

}

public string Data {

get {

if (_lastValue == null) {

_lastValue = _data.ToString();

}

return _lastValue;

}

}

public string Prefix {

get {

return _data.ToString(0, _position);

}

}

public string Read(int i) {

if (_position + i > _data.Length) {

i = _data.Length - _position;

}

string ret = _data.ToString(_position, i);

_position += i;

return ret;

}

public string ReadLine(int size) {

if (size < 0) {

size = Int32.MaxValue;

}

int i = _position;

int count = 0;

while (i < _data.Length && count < size) {

char c = _data[i];

if (c == '\n' || c == '\r') {

i++;

if (c == '\r' && _position < _data.Length && _data[i] == '\n') {

i++;

}

// preserve newline character like StringIO

string res = _data.ToString(_position, i - _position);

_position = i;

return res;

}

i++;

count++;

}

if (i > _position) {

string res = _data.ToString(_position, i - _position);

_position = i;

return res;

}

return "";

}

public string ReadToEnd() {

if (_position < _data.Length) {

string res = _data.ToString(_position, _data.Length - _position);

_position = _data.Length;

return res;

}

return String.Empty;

}

public void Reset() {

_position = 0;

}

public int Seek(int offset, SeekOrigin origin) {

switch (origin) {

case SeekOrigin.Begin:

_position = offset; break;

case SeekOrigin.Current:

_position = _position + offset; break;

case SeekOrigin.End:

_position = _data.Length + offset; break;

default:

throw new ValueErrorException("origin");

}

return _position;

}

public void Truncate() {

_lastValue = null;

_data.Length = _position;

}

public void Truncate(int size) {

_lastValue = null;

if (size > _data.Length) {

size = _data.Length;

} else if (size < 0) {

throw PythonOps.IOError("(22, 'Negative size not allowed')");

}

_data.Length = size;

_position = size;

}

internal void Write(string s) {

if (_data.Length < _position) {

_data.Length = _position;

}

_lastValue = null;

if (_position == _data.Length) {

_data.Append(s);

} else {

// replace the existing text

_data.Remove(_position, Math.Min(s.Length, _data.Length - _position));

_data.Insert(_position, s);

}

_position += s.Length;

}

}

public static class PythonStringIO {

public static PythonType InputType = DynamicHelpers.GetPythonTypeFromType(typeof(StringI));

public static PythonType OutputType = DynamicHelpers.GetPythonTypeFromType(typeof(StringO));

public const string __doc__ = "Provides file like objects for reading and writing to strings.";

[PythonType, PythonHidden]

public class StringI : IEnumerator<string>, IEnumerator {

private StringStream _sr;

private string _enumValue;

internal StringI(string data) {

_sr = new StringStream(data);

}

public void close() {

_sr = null;

}

public bool closed {

get {

return _sr == null;

}

}

public void flush() {

ThrowIfClosed();

}

public string getvalue() {

ThrowIfClosed();

return _sr.Data;

}

public string getvalue(bool usePos) {

return _sr.Prefix;

}

public bool isatty() {

ThrowIfClosed();

return false;

}

public object __iter__() {

return this;

}

public string next() {

ThrowIfClosed();

if (_sr.EOF) {

throw PythonOps.StopIteration();

}

return readline();

}

public string read() {

ThrowIfClosed();

return _sr.ReadToEnd();

}

public string read(int s) {

ThrowIfClosed();

return (s < 0) ? _sr.ReadToEnd() : _sr.Read(s);

}

public string readline() {

ThrowIfClosed();

return _sr.ReadLine(-1);

}

public string readline(int size) {

ThrowIfClosed();

return _sr.ReadLine(size);

}

public List readlines() {

ThrowIfClosed();

List list = PythonOps.MakeList();

while (!_sr.EOF) {

list.AddNoLock(readline());

}

return list;

}

public List readlines(int size) {

ThrowIfClosed();

List list = PythonOps.MakeList();

while (!_sr.EOF) {

string line = readline();

list.AddNoLock(line);

if (line.Length >= size) break;

size -= line.Length;

}

return list;

}

public void reset() {

ThrowIfClosed();

_sr.Reset();

}

public void seek(int position) {

seek(position, 0);

}

public void seek(int position, int mode) {

ThrowIfClosed();

SeekOrigin so;

switch (mode) {

case 1: so = SeekOrigin.Current; break;

case 2: so = SeekOrigin.End; break;

default: so = SeekOrigin.Begin; break;

}

_sr.Seek(position, so);

}

public int tell() {

ThrowIfClosed();

return _sr.Position;

}

public void truncate() {

ThrowIfClosed();

_sr.Truncate();

}

public void truncate(int size) {

ThrowIfClosed();

_sr.Truncate(size);

}

private void ThrowIfClosed() {

if (closed) {

throw PythonOps.ValueError("I/O operation on closed file");

}

}

#region IEnumerator Members

object IEnumerator.Current {

get { return _enumValue; }

}

bool IEnumerator.MoveNext() {

if (!_sr.EOF) {

_enumValue = readline();

return true;

}

_enumValue = null;

return false;

}

void IEnumerator.Reset() {

throw new NotImplementedException();

}

#endregion

#region IEnumerator<string> Members

string IEnumerator<string>.Current {

get { return _enumValue; }

}

#endregion

#region IDisposable Members

void IDisposable.Dispose() {

}

#endregion

}

[PythonType, PythonHidden, DontMapIEnumerableToContains]

public class StringO : IEnumerator<string>, IEnumerator {

private StringStream _sr = new StringStream("");

private int _softspace;

private string _enumValue;

internal StringO() {

}

public object __iter__() {

return this;

}

public void close() {

if (_sr != null) { _sr = null; }

}

public bool closed {

get {

return _sr == null;

}

}

public void flush() {

}

public string getvalue() {

ThrowIfClosed();

return _sr.Data;

}

public string getvalue(bool usePos) {

ThrowIfClosed();

return _sr.Prefix;

}

public bool isatty() {

ThrowIfClosed();

return false;

}

public string next() {

ThrowIfClosed();

if (_sr.EOF) {

throw PythonOps.StopIteration();

}

return readline();

}

public string read() {

ThrowIfClosed();

return _sr.ReadToEnd();

}

public string read(int i) {

ThrowIfClosed();

return (i < 0) ? _sr.ReadToEnd() : _sr.Read(i);

}

public string readline() {

ThrowIfClosed();

return _sr.ReadLine(-1);

}

public string readline(int size) {

ThrowIfClosed();

return _sr.ReadLine(size);

}

public List readlines() {

ThrowIfClosed();

List list = PythonOps.MakeList();

while (!_sr.EOF) {

list.AddNoLock(readline());

}

return list;

}

public List readlines(int size) {

ThrowIfClosed();

List list = PythonOps.MakeList();

while (!_sr.EOF) {

string line = readline();

list.AddNoLock(line);

if (line.Length >= size) break;

size -= line.Length;

}

return list;

}

public void reset() {

ThrowIfClosed();

_sr.Reset();

}

public void seek(int position) {

seek(position, 0);

}

public void seek(int offset, int origin) {

ThrowIfClosed();

SeekOrigin so;

switch (origin) {

case 1: so = SeekOrigin.Current; break;

case 2: so = SeekOrigin.End; break;

default: so = SeekOrigin.Begin; break;

}

_sr.Seek(offset, so);

}

public int softspace {

get { return _softspace; }

set { _softspace = value; }

}

public int tell() {

ThrowIfClosed();

return _sr.Position;

}

public void truncate() {

ThrowIfClosed();

_sr.Truncate();

}

public void truncate(int size) {

ThrowIfClosed();

_sr.Truncate(size);

}

public void write(string s) {

if (s == null) {

throw PythonOps.TypeError("write argument must be a string or read-only character buffer, not None");

}

ThrowIfClosed();

_sr.Write(s);

}

public void write([NotNull]PythonBuffer buffer) {

_sr.Write(buffer.ToString());

}

public void writelines(object o) {

IEnumerator e = PythonOps.GetEnumerator(o);

while (e.MoveNext()) {

string s = e.Current as string;

if (s == null) {

throw PythonOps.TypeError("string expected");

}

write(s);

}

}

private void ThrowIfClosed() {

if (closed) {

throw PythonOps.ValueError("I/O operation on closed file");

}

}

#region IEnumerator Members

object IEnumerator.Current {

get { return _enumValue; }

}

bool IEnumerator.MoveNext() {

if (!_sr.EOF) {

_enumValue = readline();

return true;

}

_enumValue = null;

return false;

}

void IEnumerator.Reset() {

throw new NotImplementedException();

}

#endregion

#region IEnumerator<string> Members

string IEnumerator<string>.Current {

get { return _enumValue; }

}

#endregion

#region IDisposable Members

void IDisposable.Dispose() {

}

#endregion

}

public static object StringIO() {

return new StringO();

}

public static object StringIO(string data) {

return new StringI(data);

}

}

}