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

""" Functions to convert between Python values and C structs represented
as Python strings. It uses format strings (explained below) as compact
descriptions of the lay-out of the C structs and the intended conversion
to/from Python values.

The optional first format char indicates byte order, size and alignment:
  @: native order, size & alignment (default)
  =: native order, std. size & alignment
  <: little-endian, std. size & alignment
  >: big-endian, std. size & alignment
  !: same as >

The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  ?: _Bool (requires C99; if not available, char is used instead)
  h:short; H:unsigned short; i:int; I:unsigned int;
  l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
  s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
  P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
  q:long long; Q:unsigned long long
Whitespace between formats is ignored.

The variable struct.error is an exception raised on errors.
 """

class Struct(object):
  """ Compiled struct object """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  format = property(None, None, None,
                    """ struct format string """
                    )


  def pack(self, v1, v2, *args):
    """ S.pack(v1, v2, ...) -> string
    
    Return a string containing values v1, v2, ... packed according to this
    Struct's format. See struct.__doc__ for more on format strings. """
    return ""

  def pack_into(self, buffer, offset, v1, v2, *args):
    """ S.pack_into(buffer, offset, v1, v2, ...)
    
    Pack the values v1, v2, ... according to this Struct's format, write 
    the packed bytes into the writable buffer buf starting at offset.  Note
    that the offset is not an optional argument.  See struct.__doc__ for 
    more on format strings. """
    pass

  size = property(None, None, None,
                  """ struct size in bytes """
                  )


  def unpack(self, str):
    """ S.unpack(str) -> (v1, v2, ...)
    
    Return tuple containing values unpacked according to this Struct's format.
    Requires len(str) == self.size. See struct.__doc__ for more on format
    strings. """
    return ()

  def unpack_from(self, buffer, offset=None):
    """ S.unpack_from(buffer[, offset]) -> (v1, v2, ...)
    
    Return tuple containing values unpacked according to this Struct's format.
    Unlike unpack, unpack_from can unpack values from any object supporting
    the buffer API, not just str. Requires len(buffer[offset:]) >= self.size.
    See struct.__doc__ for more on format strings. """
    return ()

_PY_STRUCT_FLOAT_COERCE = 1
_PY_STRUCT_OVERFLOW_MASKING = 1
_PY_STRUCT_RANGE_CHECKING = 1
__doc__ = """Functions to convert between Python values and C structs represented
as Python strings. It uses format strings (explained below) as compact
descriptions of the lay-out of the C structs and the intended conversion
to/from Python values.

The optional first format char indicates byte order, size and alignment:
  @: native order, size & alignment (default)
  =: native order, std. size & alignment
  <: little-endian, std. size & alignment
  >: big-endian, std. size & alignment
  !: same as >

The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  ?: _Bool (requires C99; if not available, char is used instead)
  h:short; H:unsigned short; i:int; I:unsigned int;
  l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
  s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
  P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
  q:long long; Q:unsigned long long
Whitespace between formats is ignored.

The variable struct.error is an exception raised on errors.
"""
__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/_struct.so'
__name__ = '_struct'
__package__ = None
__version__ = '0.2'

def _clearcache():
  """ Clear the internal cache. """
  pass

def calcsize():
  """ Return size of C struct described by format string fmt. """
  pass

class error(Exception):

  pass

def pack():
  """ Return string containing values v1, v2, ... packed according to fmt. """
  pass

def pack_into():
  """ Pack the values v1, v2, ... according to fmt.
  Write the packed bytes into the writable buffer buf starting at offset. """
  pass

def unpack():
  """ Unpack the string containing packed C structure data, according to fmt.
  Requires len(string) == calcsize(fmt). """
  pass

def unpack_from():
  """ Unpack the buffer, containing packed C structure data, according to
  fmt, starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt). """
  pass