Application: gvSIG desktop » gvSIG scripting

from org.gvsig.fmap.dal.feature.impl import DefaultFeatureStore

class FeatureStore(DefaultFeatureStore):

  """Represents gvsig store. It's used as Table/Layer objects store  

  (org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore)

  def __init__(self,store):

    WrapperToJava.__init__(self, store)

    #self.data = None

    self.fset = None

  def features(self, expresion = None, sortBy="", asc=True):

    """Returns layer features set (FeatureSet class), with all layer features, 

    or selected featured if there are (could be empty feature set) or None if

    gets an Exception.

    :param expresion: filter to apply to the feature set to select

        determinates features that match with expression

    :type expresion: string

    :param sortBy: name of attribute to sort

    :type sortby: string

    :param: asc: order

    :type asc: boolean

    :return: FeatureSet

    if expresion == None and sortBy =="":

      self.fset = self.getFeatureSet()         

    else:

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        query = self.createFeatureQuery()

        if sortBy != "":

            order = FeatureQueryOrder()

            order.add(sortBy, asc)

            query.setOrder(order)

        if expresion != None:

            query.setFilter(datamanager.createExpresion(expresion))

        self.fset = self.getFeatureSet(query)

      except Exception, e:

        return None

    return FeatureSet(self.fset)    

  def edit(self):

    """Set store in edition mode"""     

    if not self.isEditing():

        self().edit() 

  def append(self, *valuesList, **values):

    Creates a new feature from given values and insert it in the feature 

    set. If an error occurs raises RuntimeException.

    :param values: dictionary with name property value or list named params

    :type values: dict

      if len(valuesList) ==1:

        values.update(valuesList[0])

        self.edit() 

      for k,v in values.iteritems():

        repr(values), 

  def updateSchema(self, schema):

    Updates store FeatureType. If an error occurs raises 

    RuntimeException.

    """

    try:

      self().update(schema._javaobj)

    except Throwable, ex:

      raise RuntimeException(repr(ex))

  def update(self, feature):

    Updates exist feature in the layer featureSet

    :param editableFeature: editableFeature

    :type editableFeature: Java editableFeature

    """

      self.edit() 

    if not isinstance(feature, EditableFeature):

      feature = feature._javaobj

    self.fset.update(feature)

  def getSchema(self):

    """Returns store data attributtes"""

    return Schema(self.getDefaultFeatureType())

    Finish store edition saving changes. If an error occurs raises Throwable 

    Exception.

      raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))

    """Finish store edition withoout saving changes and disposes itself"""

    self.cancelEditing() 

    self.dispose()

  def getSelection(self):

    """Returns store features selected set"""

    return FeatureSet(self().getSelection())

class FeatureSet(WrapperToJava):

  """Represents gvSIG FeatureSet 

  (org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet)

  """

  def __init__(self,featureSet):

    WrapperToJava.__init__(self,featureSet)

  def getCount(self):

    """Returns the number of elements in the featureSet"""

    return self.getSize()

  def update(self, feature):

    Updates exist feature in the featureSet

    :param editableFeature: editableFeature

    :type editableFeature: Java editableFeature

    if not isinstance(feature, EditableFeature) and \

            not isinstance(feature, DefaultEditableFeature):

      feature = feature._javaobj

    self().update(feature)

  def __iter__(self):

    return  Iterator(self.fastIterator())

class Selection(FeatureSet):

  """Manage selected features set from a store. Represents gvSIG 

  org.gvsig.fmap.dal.feature.impl.DefaultFeatureSelection.  

  """

  def __init__(self, featureSet):

    FeatureSet.__init__(self, featureSet)

  def select(self, selection):

    """Inserts features in the features selection set"""

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self._javaobj.select(selection._javaobj)

    else:

      self._javaobj.select(selection)

  def deselect(self, selection):

    """Removes features in the features selection set"""

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self._javaobj.deselect(selection._javaobj)

    else:

      self._javaobj.deselect(selection)

  def isSelected(feature):

    """Returns True if given feature is selected"""

    if isinstance(feature, Feature):

      self._javaobj.isSelect(feature._javaobj)

    else:

      self._javaobj.isSelect(feature)

  def getCount(self):

    """Returns the number of elements in the selection"""

    return self.getSelectedCount()

class Feature(WrapperToJava):

  """Represents feature data It's a wrapper from gvSIG 

  org.gvsig.fmap.dal.feature.impl.DefaultFeature class

  """

  def __init__(self,feature):

    WrapperToJava.__init__(self,feature)

    self.featureNoEditable = None

  def geometry(self):

    """Returns feature geometry"""

    return self.getDefaultGeometry()

  def getValues(self):

    """Returns dictionary with the pair name, value, feature attributes"""

    descriptor = self.getType()

    items = dict()

    for attr in descriptor.getAttributeDescriptors():

      name = attr.getName()

      value = self.get(attr.getName())

      items[name] = value

    return items 

  def edit(self):

    """Returns editable feature instance"""

    if not isinstance(self._javaobj, EditableFeature):

      self.featureNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

  def __getitem__(self,key):

    return self.get(key)

  def __getattr__(self,name):

    #

    #FIX console error when try to introspect feature object

    if name in ('__methods__'):

        return dict()

    elif name in ('__members__'):

        return self.getValues().keys()

    elif name == '__dict__':

        return self.getValues()      

    try:

      v = getattr(self._javaobj, name, None)

      if v == None:

        v = self().get(name)        

      return v

    except Throwable, ex:

      raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))    

class Schema(WrapperToJava):

  """Stores data properties definition. Represents gvSIG FeatureType

  (org.gvsig.fmap.dal.feature.impl.DefaultFeatureType)

  """

  def __init__(self, featureType):

    WrapperToJava.__init__(self,featureType)

    self.featureTypeNoEditable = None

  def append(self, name, type, size=None, default=None, precision=4):

    """Adds new property to feature properties definition. If error occurs 

    raises RuntimeError.    

    :param name: Feature property name

    :type name: String

    :param type: Feature property type

    :type name: String

    :param size: Feature property size

    :type size: int

    :param default: Feature property default value

    :return: new atribute

    """

    if not isinstance(self._javaobj, EditableFeatureType):

        self.modify()

    if isinstance(type, str):

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        dataTypes = application.getDataTypesManager()

        type = dataTypes.getType(type) #dataType constant value from string

      except:

        raise RuntimeError(

            "Feature Property Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    if isinstance(type, int):

      try:

        type = dataTypes.get(type)

      except:

        raise RuntimeError(

            "Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    attribute = self.add(name, type.getType())

    if size != None: 

      attribute.setSize(size)

    if default != None:

      attribute.setDefaultValue(default)

    if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT):

      attribute.setPrecision(precision)

    if type.getType() == DataTypes.GEOMETRY and self.getDefaultGeometryAttributeName()==None:

      self.setDefaultGeometryAttributeName(name)

    return attribute

  def __getitem__(self, name):

    return self.getAttributeDescriptor(name)

  def get(self, name, default=None):

    """Returns a feature attribute descriptor that contains information about 

    one feature attribute, such as its name, data type or precision. 

    :param name: Attribute name

    :type name: string

    :param default: Value to return if no attribute name found. 

    :return: AttributeDescriptor

    """

    x = self.getAttributeDescriptor(name)

    if x == None:

      return default

    return x

  def getAttrNames(self):

    """Returns a list with attributes names"""

    if not self.getAttributeDescriptors():

      return None

    return [attr.getName() for attr in self.getAttributeDescriptors()]

  def getCopy(self):

    """Returns a itself clone"""

    return Schema(self().getCopy())

  def modify(self):

    """Sets edit mode"""

    if not isinstance(self._javaobj, EditableFeatureType):

      self.featureTypeNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()