from ctypes import c_void_p

 from types import NoneType

 from django.contrib.gis.geos.error import GEOSException, GEOSIndexError

 # Trying to import GDAL libraries, if available.  Have to place in

 # try/except since this package may be used outside GeoDjango.

 try:

     from django.contrib.gis import gdal

 except ImportError:

     # A 'dummy' gdal module.

     class GDALInfo(object):

         HAS_GDAL = False

         GEOJSON = False

     gdal = GDALInfo()

 # NumPy supported?

 try:

     import numpy

 except ImportError:

     numpy = False

 class GEOSBase(object):

     """

     Base object for GEOS objects that has a pointer access property

     that controls access to the underlying C pointer.

     """

     # Initially the pointer is NULL.

     _ptr = None

     # Default allowed pointer type.

     ptr_type = c_void_p

     # Pointer access property.

     def _get_ptr(self):

         # Raise an exception if the pointer isn't valid don't

         # want to be passing NULL pointers to routines --

         # that's very bad.

         if self._ptr: return self._ptr

         else: raise GEOSException('NULL GEOS %s pointer encountered.' % self.__class__.__name__)

     def _set_ptr(self, ptr):

         # Only allow the pointer to be set with pointers of the

         # compatible type or None (NULL).

         if isinstance(ptr, int):

             self._ptr = self.ptr_type(ptr)

         elif isinstance(ptr, (self.ptr_type, NoneType)):

             self._ptr = ptr

         else:

             raise TypeError('Incompatible pointer type')

     # Property for controlling access to the GEOS object pointers.  Using

     # this raises an exception when the pointer is NULL, thus preventing

     # the C library from attempting to access an invalid memory location.

     ptr = property(_get_ptr, _set_ptr)

 class ListMixin(object):

     _canSetSingle = False

     def _setSingle_rebuild(self, index, value):

         self._checkindex(index)

         self._setSlice(slice(index, index + 1, 1), [value])        

     _setSingle = _setSingle_rebuild

     def _checkindex(self, index):

         if index < 0 or index >= len(self):

             raise GEOSIndexError('invalid index: %s' % str(index))

     def _checkAllowedTypes(self, items):

         # Ensuring that only the permitted geometries are allowed in this collection

         if hasattr(self, '_allowed'):

             if False in [isinstance(geom, self._allowed) for geom in items]:

                 raise TypeError('Invalid Geometry type encountered in the arguments.')

     def __getitem__(self, index):

         "Gets the coordinates of the point(s) at the specified index/slice."

         if isinstance(index, slice):

             return [self._getItemExternal(i) for i in xrange(*index.indices(len(self)))]

         else:

             if index < 0:

                 index += len(self)

             return self._getItemExternal(index)

     def __delitem__(self, index):

         "Delete the point(s) at the specified index/slice."

         if not isinstance(index, (int, long, slice)):

             raise TypeError("%s is not a legal index" % index)

         # calculate new length and dimensions

         origLen     = len(self)

         if isinstance(index, (int, long)):

             if index < 0: index += origLen

             if not 0 <= index < origLen:

                 raise GEOSIndexError('invalid index: %d' % index)

             indexRange  = [index]

         else:

             indexRange  = range(*index.indices(origLen))

         newLen      = origLen - len(indexRange)

         newItems    = ( self._getItemInternal(i)

                         for i in xrange(origLen)

                         if i not in indexRange )

         self._setCollection(newLen, newItems)

     def __setitem__(self, index, geom):

         "Sets the Geometry at the specified index."

         if isinstance(index, slice):

             self._setSlice(index, geom)

         else:

             if index < 0: index += len(self)

             self._setSingle(index, geom)

     def _setSlice(self, index, values):

         "Assign values to a slice of the object"

         try:

             iter(values)

         except TypeError:

             raise TypeError('can only assign an iterable to a slice')

         self._checkAllowedTypes(values)

         origLen     = len(self)

         valueList   = list(values)

         start, stop, step = index.indices(origLen)

         stop = max(0, stop) # stop will be -1 if out-of-bounds

                             # negative index is given

         # CAREFUL: index.step and step are not the same!

         # step will never be None

         #

         if index.step is None:

             self._assignSimpleSlice(start, stop, valueList)

         else:

             self._assignExtendedSlice(start, stop, step, valueList)

     def _assignExtendedSlice(self, start, stop, step, valueList):

         'Assign an extended slice by rebuilding entire list'

         indexList   = range(start, stop, step)

         # extended slice, only allow assigning slice of same size

         if len(valueList) != len(indexList):

             raise ValueError('attempt to assign sequence of size %d '

                              'to extended slice of size %d'

                              % (len(valueList), len(indexList)))

         # we're not changing the length of the sequence

         newLen  = len(self)

         newVals = dict(zip(indexList, valueList))

         def newItems():

             for i in xrange(newLen):

                 if i in newVals:

                     yield newVals[i]

                 else:

                     yield self._getItemInternal(i)

         self._setCollection(newLen, newItems())

     def _assignExtendedSlice_no_rebuild(self, start, stop, step, valueList):

         'Assign an extended slice by re-assigning individual items'

         indexList   = range(start, stop, step)

         # extended slice, only allow assigning slice of same size

         if len(valueList) != len(indexList):

             raise ValueError('attempt to assign sequence of size %d '

                              'to extended slice of size %d'

                              % (len(valueList), len(indexList)))

         for i, val in zip(indexList, valueList):

             self._setSingle(i, val)

     def _assignSimpleSlice(self, start, stop, valueList):

         'Assign a simple slice; Can assign slice of any length'

         origLen = len(self)

         newLen  = origLen - stop + start + len(valueList)

         def newItems():

             for i in xrange(origLen + 1):

                 if i == start:

                     for val in valueList:

                         yield val

                 if i < origLen:

                     if i < start or i >= stop:

                         yield self._getItemInternal(i)

         self._setCollection(newLen, newItems())

     def append(self, val):

         "Standard list append method"

         self[len(self):] = [val]

     def extend(self, vals):

         "Standard list extend method"

         self[len(self):] = vals

     def insert(self, index, val):

         "Standard list insert method"

         if not isinstance(index, (int, long)):

             raise TypeError("%s is not a legal index" % index)

         self[index:index] = [val]

     def pop(self, index=-1):

         "Standard list pop method"

         result = self[index]

         del self[index]

         return result

     def index(self, val):

         "Standard list index method"

         for i in xrange(0, len(self)):

             if self[i] == val: return i

         raise ValueError('%s not in geometry' % str(val))

     def remove(self, val):

         "Standard list remove method"

         del self[self.index(val)]

     def count(self):

         "Standard list count method"

         return len(self)