# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT
# OVERRIDES FILE: static-pi-files/2.2/cStringIOoverride.py

""" A simple fast partial StringIO replacement.

This module provides a simple useful replacement for
the StringIO module that is written in C.  It does not provide the
full generality of StringIO, but it provides enough for most
applications and is especially useful in conjunction with the
pickle module.

Usage:

  from cStringIO import StringIO

  an_output_stream=StringIO()
  an_output_stream.write(some_stuff)
  ...
  value=an_output_stream.getvalue()

  an_input_stream=StringIO(a_string)
  spam=an_input_stream.readline()
  spam=an_input_stream.read(5)
  an_input_stream.seek(0)           # OK, start over
  spam=an_input_stream.read()       # and read it all
  
If someone else wants to provide a more complete implementation,
go for it. :-)  

cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp
 """

class InputType(object):
  """ Simple type for treating strings as input file streams """

  def close(self):
    """ close(): explicitly release resources held. """
    pass

  closed = property(None, None, None,
                    """ True if the file is closed """
                    )


  def flush(self):
    """ flush(): does nothing. """
    pass

  def getvalue(self, use_pos=None):
    """ getvalue([use_pos]) -- Get the string value.
    If use_pos is specified and is a true value, then the string returned
    will include only the text up to the current file position.
     """
    return ""

  def isatty(self):
    """ isatty(): always returns 0 """
    pass

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

  def read(self, s=None):
    """ read([s]) -- Read s characters, or the rest of the string """
    return ""

  def readline(self):
    """ readline() -- Read one line """
    return None

  def readlines(self):
    """ readlines() -- Read all lines """
    return None

  def reset(self):
    """ reset() -- Reset the file position to the beginning """
    return file(__file__)

  def seek(self, position):
    """ seek(position)       -- set the current position
    seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF """
    return None

  def tell(self):
    """ tell() -- get the current position. """
    return None

  def truncate(self):
    """ truncate(): truncate the file at the current position. """
    pass

class OutputType(object):
  """ Simple type for output to strings. """

  def close(self):
    """ close(): explicitly release resources held. """
    pass

  closed = property(None, None, None,
                    """ True if the file is closed """
                    )


  def flush(self):
    """ flush(): does nothing. """
    pass

  def getvalue(self, use_pos=None):
    """ getvalue([use_pos]) -- Get the string value.
    If use_pos is specified and is a true value, then the string returned
    will include only the text up to the current file position.
     """
    return ""

  def isatty(self):
    """ isatty(): always returns 0 """
    pass

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

  def read(self, s=None):
    """ read([s]) -- Read s characters, or the rest of the string """
    return ""

  def readline(self):
    """ readline() -- Read one line """
    return None

  def readlines(self):
    """ readlines() -- Read all lines """
    return None

  def reset(self):
    """ reset() -- Reset the file position to the beginning """
    return file(__file__)

  def seek(self, position):
    """ seek(position)       -- set the current position
    seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF """
    return None

  softspace = None

  def tell(self):
    """ tell() -- get the current position. """
    return None

  def truncate(self):
    """ truncate(): truncate the file at the current position. """
    pass

  def write(self, s):
    """ write(s) -- Write a string to the file
    
    Note (hack:) writing None resets the buffer """
    return ""

  def writelines(self, sequence_of_strings):
    """ writelines(sequence_of_strings) -> None.  Write the 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. """
    return ""

cStringIO_CAPI = None
# BEGIN MANUAL OVERRIDES FROM static-pi-files/2.2/cStringIOoverride.py
class StringIO:
  """ class StringIO([buffer])
  
      When a StringIO object is created, it can be initialized to an existing
      string by passing the string to the constructor. If no string is given,
      the StringIO will start empty.
  
      The StringIO object can accept either Unicode or 8-bit strings, but
      mixing the two may take some care. If both are used, 8-bit strings that
      cannot be interpreted as 7-bit ASCII (that use the 8th bit) will cause
      a UnicodeError to be raised when getvalue() is called.
       """

    def __init__(self, buf = ''):
        # Force self.buf to be a string or unicode
        if not isinstance(buf, basestring):
            buf = str(buf)
        self.buf = buf
        self.len = len(buf)
        self.buflist = []
        self.pos = 0
        self.closed = False
        self.softspace = 0

    def close(self):
        """Free the memory buffer.
        """
        if not self.closed:
            self.closed = True
            del self.buf, self.pos

    def flush(self):
        """Flush the internal buffer
        """
        _complain_ifclosed(self.closed)

    def getvalue(self):
        """
        Retrieve the entire contents of the "file" at any time before
        the StringIO object's close() method is called.

        The StringIO object can accept either Unicode or 8-bit strings,
        but mixing the two may take some care. If both are used, 8-bit
        strings that cannot be interpreted as 7-bit ASCII (that use the
        8th bit) will cause a UnicodeError to be raised when getvalue()
        is called.
        """
        _complain_ifclosed(self.closed)
        if self.buflist:
            self.buf += ''.join(self.buflist)
            self.buflist = []
        return self.buf

    def isatty(self):
        """Returns False because StringIO objects are not connected to a
        tty-like device.
        """
        _complain_ifclosed(self.closed)
        return False

    def next(self):
        """A file object is its own iterator, for example iter(f) returns f
        (unless f is closed). When a file is used as an iterator, typically
        in a for loop (for example, for line in f: print line), the next()
        method is called repeatedly. This method returns the next input line,
        or raises StopIteration when EOF is hit.
        """
        _complain_ifclosed(self.closed)
        r = self.readline()
        if not r:
            raise StopIteration
        return r

    def read(self, n = -1):
        """Read at most size bytes from the file
        (less if the read hits EOF before obtaining size bytes).

        If the size argument is negative or omitted, read all data until EOF
        is reached. The bytes are returned as a string object. An empty
        string is returned when EOF is encountered immediately.
        """
        _complain_ifclosed(self.closed)
        if self.buflist:
            self.buf += ''.join(self.buflist)
            self.buflist = []
        if n is None or n < 0:
            newpos = self.len
        else:
            newpos = min(self.pos+n, self.len)
        r = self.buf[self.pos:newpos]
        self.pos = newpos
        return r

    def readline(self, length=None):
        r"""Read one entire line from the file.

        A trailing newline character is kept in the string (but may be absent
        when a file ends with an incomplete line). If the size argument is
        present and non-negative, it is a maximum byte count (including the
        trailing newline) and an incomplete line may be returned.

        An empty string is returned only when EOF is encountered immediately.

        Note: Unlike stdio's fgets(), the returned string contains null
        characters ('\0') if they occurred in the input.
        """
        _complain_ifclosed(self.closed)
        if self.buflist:
            self.buf += ''.join(self.buflist)
            self.buflist = []
        i = self.buf.find('\n', self.pos)
        if i < 0:
            newpos = self.len
        else:
            newpos = i+1
        if length is not None and length >= 0:
            if self.pos + length < newpos:
                newpos = self.pos + length
        r = self.buf[self.pos:newpos]
        self.pos = newpos
        return r

    def readlines(self, sizehint = 0):
        """Read until EOF using readline() and return a list containing the
        lines thus read.

        If the optional sizehint argument is present, instead of reading up
        to EOF, whole lines totalling approximately sizehint bytes (or more
        to accommodate a final whole line).
        """
        total = 0
        lines = []
        line = self.readline()
        while line:
            lines.append(line)
            total += len(line)
            if 0 < sizehint <= total:
                break
            line = self.readline()
        return lines

    def seek(self, pos, mode = 0):
        """Set the file's current position.

        The mode argument is optional and defaults to 0 (absolute file
        positioning); other values are 1 (seek relative to the current
        position) and 2 (seek relative to the file's end).

        There is no return value.
        """
        _complain_ifclosed(self.closed)
        if self.buflist:
            self.buf += ''.join(self.buflist)
            self.buflist = []
        if mode == 1:
            pos += self.pos
        elif mode == 2:
            pos += self.len
        self.pos = max(0, pos)

    def tell(self):
        """Return the file's current position."""
        _complain_ifclosed(self.closed)
        return self.pos

    def truncate(self, size=None):
        """Truncate the file's size.

        If the optional size argument is present, the file is truncated to
        (at most) that size. The size defaults to the current position.
        The current file position is not changed unless the position
        is beyond the new file size.

        If the specified size exceeds the file's current size, the
        file remains unchanged.
        """
        _complain_ifclosed(self.closed)
        if size is None:
            size = self.pos
        elif size < 0:
            raise IOError(EINVAL, "Negative size not allowed")
        elif size < self.pos:
            self.pos = size
        self.buf = self.getvalue()[:size]
        self.len = size

    def write(self, s):
        """Write a string to the file.

        There is no return value.
        """
        _complain_ifclosed(self.closed)
        if not s: return
        # Force s to be a string or unicode
        if not isinstance(s, basestring):
            s = str(s)
        spos = self.pos
        slen = self.len
        if spos == slen:
            self.buflist.append(s)
            self.len = self.pos = spos + len(s)
            return
        if spos > slen:
            self.buflist.append('\0'*(spos - slen))
            slen = spos
        newpos = spos + len(s)
        if spos < slen:
            if self.buflist:
                self.buf += ''.join(self.buflist)
            self.buflist = [self.buf[:spos], s, self.buf[newpos:]]
            self.buf = ''
            if newpos > slen:
                slen = newpos
        else:
            self.buflist.append(s)
            slen = newpos
        self.len = slen
        self.pos = newpos

    def writelines(self, iterable):
        """Write a sequence of strings to the file. The sequence can be any
        iterable object producing strings, typically a list of strings. There
        is no return value.

        (The name is intended to match readlines(); writelines() does not add
        line separators.)
        """
        write = self.write
        for line in iterable:
            write(line)

__builtins__ = {}
__doc__ = None
__file__ = '/Users/Shared/src/ide/build-files/static-pi-files/2.2/cStringIOoverride.py'
__name__ = 'cStringIOoverride'
__package__ = None

# END MANUAL OVERRIDES