# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT


class _BytesIO(object):
  """ BytesIO([buffer]) -> object
  
  Create a buffered I/O implementation using an in-memory bytes
  buffer, ready for reading and writing. """

  def __init__(self, buffer=None):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

  def close(self):
    """ close() -> None.  Disable all I/O operations. """
    return None

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


  def flush(self):
    """ flush() -> None.  Does nothing. """
    return None

  def getvalue(self):
    """ getvalue() -> bytes.
    
    Retrieve the entire contents of the BytesIO object. """
    return None

  def isatty(self):
    """ isatty() -> False.
    
    Always returns False since BytesIO objects are not connected
    to a tty-like device. """
    return None

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

  def read(self, size=None):
    """ read([size]) -> read at most size bytes, returned as a string.
    
    If the size argument is negative, read until EOF is reached.
    Return an empty string at EOF. """
    return ""

  def read1(self, size):
    """ read1(size) -> read at most size bytes, returned as a string.
    
    If the size argument is negative or omitted, read until EOF is reached.
    Return an empty string at EOF. """
    return ""

  def readable(self):
    pass

  def readinto(self, bytearray):
    """ readinto(bytearray) -> int.  Read up to len(b) bytes into b.
    
    Returns number of bytes read (0 for EOF), or None if the object
    is set not to block as has no data to read. """
    return 1

  def readline(self, size=None):
    """ readline([size]) -> next line from the file, as a string.
    
    Retain newline.  A non-negative size argument limits the maximum
    number of bytes to return (an incomplete line may be returned then).
    Return an empty string at EOF.
     """
    return ""

  def readlines(self, size=None):
    """ readlines([size]) -> list of strings, each a line from the file.
    
    Call readline() repeatedly and return a list of the lines so read.
    The optional size argument, if given, is an approximate bound on the
    total number of bytes in the lines returned.
     """
    return []

  def seek(self, pos, whence=0):
    """ seek(pos, whence=0) -> int.  Change stream position.
    
    Seek to byte offset pos relative to position indicated by whence:
         0  Start of stream (the default).  pos should be >= 0;
         1  Current position - pos may be negative;
         2  End of stream - pos usually negative.
    Returns the new absolute position. """
    return ""

  def seekable(self):
    pass

  def tell(self):
    """ tell() -> current file position, an integer
     """
    return file(__file__)

  def truncate(self, size=None):
    """ truncate([size]) -> int.  Truncate the file to at most size bytes.
    
    Size defaults to the current file position, as returned by tell().
    Returns the new size.  Imply an absolute seek to the position size. """
    return file(__file__)

  def writable(self):
    pass

  def write(self, bytes):
    """ write(bytes) -> int.  Write bytes to file.
    
    Return the number of bytes written. """
    return file(__file__)

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

__doc__ = None
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python2.6/lib/Python.framework/Versions/2.6/lib/python2.6/lib-dynload/_bytesio.so'
__name__ = '_bytesio'
__package__ = None