Application: gvSIG desktop

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

public class DefaultFeatureType 

        extends ArrayList<FeatureAttributeDescriptor> 

        implements 

            FeatureType,

            Persistent,

            DynClass, 

            org.gvsig.tools.lang.Cloneable 

    {

	public DefaultFeatureType() {

            // Usado en la persistencia.

            this.id = id = "default";

        }

	protected DefaultFeatureType(FeatureStore store, String id) {

            this();

            if (StringUtils.isEmpty(id)) {

                id = "default";

            }

            this.id = id;

            setStore(store);

            this(store, (String)null);

            this(other.getStore(), (String)null);

            initialize(other, true);

            this(other.getStore(), (String)null);

            initialize(other, copyAttributes);

    public void setStore(FeatureStore store) {

        if( store == null ) {

            this.storeRef = null; 

        } else {

            this.storeRef = new WeakReference(store);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

//        FIXME: rules

        hasEvaluators = state.getBoolean("hasEvaluators");

        hasEmulators = state.getBoolean("hasEmulators");

        defaultGeometryAttributeName = state.getString("defaultGeometryAttributeName");

        defaultTimeAttributeName = state.getString("defaultTimeAttributeName");

        defaultGeometryAttributeIndex = state.getInt("defaultGeometryAttributeIndex");

        defaultTimeAttributeIndex = state.getInt("defaultTimeAttributeIndex");

        id = state.getString("id");

        hasOID = state.getBoolean("hasOID");

        allowAtomaticValues = state.getBoolean("allowAtomaticValues");

        requiredFields = state.getBoolean("requiredFields");

        internalID = state.getString("internalID");

        List<FeatureAttributeDescriptor> elements = state.getList("elements");

        for (FeatureAttributeDescriptor element : elements) {

            ((DefaultFeatureAttributeDescriptor)element).setFeatureType(this);

            super.add(element);

        }

        List<String> thePk = state.getList("pk");

        if( thePk==null ) {

            this.pk = null;

        } else {

            this.pk = new FeatureAttributeDescriptor[thePk.size()];

            for (int i = 0; i < pk.length; i++) {

                pk[i] = this.getAttributeDescriptor(thePk.get(i));

            }

        }

        this.fixAll();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

//        FIXME: rules

        state.set("hasEvaluators", hasEvaluators);

        state.set("hasEmulators", hasEmulators);

        state.set("defaultGeometryAttributeName", defaultGeometryAttributeName);

        state.set("defaultTimeAttributeName", defaultTimeAttributeName);

        state.set("defaultGeometryAttributeIndex", defaultGeometryAttributeIndex);

        state.set("defaultTimeAttributeIndex", defaultTimeAttributeIndex);

        state.set("id", id);

        state.set("hasOID", hasOID);

        state.set("allowAtomaticValues", allowAtomaticValues);

        List<String> thePk = null;

        if( this.pk!=null ) {

            thePk = new ArrayList<>();

            for (FeatureAttributeDescriptor attrdesc : this.pk) {

                thePk.add(attrdesc.getName());

            }

        }

        state.set("pk",thePk);

        state.set("requiredFields", requiredFields);

        state.set("internalID", internalID);

        List<FeatureAttributeDescriptor> elements = new ArrayList<>();

        elements.addAll(this);

        state.set("elements", elements);

    }

    private static final String FEATTYPE_PERSISTENCE_DEFINITION_NAME = "FeatureType";

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(FEATTYPE_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultFeatureType.class,

                    FEATTYPE_PERSISTENCE_DEFINITION_NAME,

                    FEATTYPE_PERSISTENCE_DEFINITION_NAME

                        + " persistent definition",

                    null,

                    null

            );

//            definition.addDynFieldObject("rules");

            definition.addDynFieldBoolean("hasEvaluators");

            definition.addDynFieldBoolean("hasEmulators");

            definition.addDynFieldString("defaultGeometryAttributeName");

            definition.addDynFieldString("defaultTimeAttributeName");

            definition.addDynFieldInt("defaultGeometryAttributeIndex");

            definition.addDynFieldInt("defaultTimeAttributeIndex");

            definition.addDynFieldString("id");

            definition.addDynFieldBoolean("hasOID");

            definition.addDynFieldBoolean("allowAtomaticValues");

            definition.addDynFieldArray("pk")

                    .setClassOfItems(String.class);

            definition.addDynFieldBoolean("requiredFields");

            definition.addDynFieldString("internalID"); 

            definition.addDynFieldList("elements")

                    .setClassOfItems(FeatureAttributeDescriptor.class); 

        }

    }