Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.feature.impl.featurereference;

import java.lang.ref.WeakReference;

import java.util.Arrays;

import java.util.Base64;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.json.JSONArray;

import org.json.JSONObject;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureReference implements

                FeatureReferenceProviderServices, Persistent {

        private Object oid;

        private Integer myHashCode = null;

        private Object[] pk;

        private String[] pkNames;

        private WeakReference storeRef;

        private boolean isNewFeature;

        private String featureTypeId;

        private static final int OID_INDEX = 0;

        private static final int MYHASHCODE_INDEX = 1;

        private static final int ISNEWFEATURE_INDEX = 2;

        private static final int FEATURETYPEID_INDEX = 3;

        private static final int PKNAMES_SIZE_INDEX = 4;

        private static final int PKNAMES_INDEX = 5;

        private static final int PK_INDEX = 6;

        /**

     * Constructor used by the persistence manager. Don't use directly.

     * After to invoke this method, the persistence manager calls 

     * the the method {@link #loadFromState(PersistentState)} to set 

     * the values of the internal attributes that this class needs to work.

     */

        public DefaultFeatureReference() {

                super();                

        }

        public DefaultFeatureReference(DefaultFeature feature) {

                this(feature.getStore(), feature.getData());

        }

        public DefaultFeatureReference(FeatureStore store,

                        FeatureProvider fdata) {

                this.isNewFeature = fdata.isNew();

                this.oid = null;

                this.pk = null;

                this.storeRef = new WeakReference(store);

                this.featureTypeId = fdata.getType().getId();

                if (fdata.getType().hasOID() || isNewFeature) {

                        this.oid = fdata.getOID();

                        if (this.oid == null) {

                                // FIXME Exception

                                throw new RuntimeException("Missing OID");

                        }

                } else {

                        this.calculatePK(fdata);

                        if (this.pk == null) {

                                // FIXME Exception

                                throw new RuntimeException("Missing pk attributes");

                        }

                }

        }

        /*

         * Use only for Persistent.setState

         */

//        public DefaultFeatureReference(FeatureStore store) {

//                this.isNewFeature = false;

//                this.oid = null;

//                this.pk = null;

//                this.storeRef = new WeakReference(store);

//        }

        public DefaultFeatureReference(FeatureStore store, Object oid) {

                // FIXME featureTypeId is needed !!!

                this.isNewFeature = false;

                this.oid = oid;

                this.pk = null;

                this.storeRef = new WeakReference(store);

        }

        public DefaultFeatureReference(FeatureStore store, String code) {

            this.storeRef = new WeakReference(store);

            String json = new String(Base64.getDecoder().decode(code.getBytes()));

            JSONArray x = new JSONArray(json);

            this.oid = x.get(OID_INDEX);

            if( x.get(MYHASHCODE_INDEX)==JSONObject.NULL ) {

                this.myHashCode = null;

            } else {

                this.myHashCode = x.getInt(MYHASHCODE_INDEX);

            }

            this.isNewFeature = x.getBoolean(ISNEWFEATURE_INDEX);

            this.featureTypeId = x.getString(FEATURETYPEID_INDEX);

            int pkNames_size = x.getInt(PKNAMES_SIZE_INDEX);

            if( pkNames_size<0 ) {

                this.pk = null;

                this.pkNames = null;

            } else {

                this.pk = new Object[pkNames_size];

                this.pkNames = new String[pkNames_size];

                JSONArray xx = x.getJSONArray(PKNAMES_INDEX);

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

                    this.pkNames[i] = xx.getString(i);

                }

                xx = x.getJSONArray(PKNAMES_INDEX);

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

                    this.pk[i] = xx.get(i);

                }

            }

//            JSONObject x = new JSONObject(json);

//            this.oid = x.get("oid");

//            this.myHashCode = x.getInt("myHashCode");

//            this.isNewFeature = x.getBoolean("isNewFeature");

//            this.featureTypeId = x.getString("featureTypeId");

//            int pkNames_size = x.getInt("pkNames_size");

//            if( pkNames_size<0 ) {

//                this.pk = null;

//                this.pkNames = null;

//            } else {

//                this.pk = new Object[pkNames_size];

//                this.pkNames = new String[pkNames_size];

//                JSONArray xx = x.getJSONArray("pkNames");

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

//                    this.pkNames[i] = xx.getString(i);

//                }

//                xx = x.getJSONArray("pk");

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

//                    this.pk[i] = xx.get(i);

//                }

//            }

        }

        private DefaultFeatureStore getStore() {

                return (DefaultFeatureStore) this.storeRef.get();

        }

        public void calculatePK(FeatureProvider fdata) { // Usado en los test de BBDD

            FeatureAttributeDescriptor[] pkattrs = fdata.getType().getPrimaryKey();

            if( ArrayUtils.isEmpty(pkattrs) ) {

                this.pk = null;

                this.pkNames = null;

                return ;

            }

            this.pk = new Object[pkattrs.length];

            this.pkNames = new String[pkattrs.length];

            int n = 0;

            for (FeatureAttributeDescriptor pkattr : pkattrs) {

//                if( pkattr.isAutomatic() ) {

//                    this.pk = null;

//                    this.pkNames = null;

//                    return ;

//                }

                this.pk[n] = fdata.get(pkattr.getIndex());

                this.pkNames[n] = pkattr.getName();

                n++;

            }

    }

    @Override

    public Feature getFeature() throws DataException {

        return this.getStore().getFeatureByReference(this);

    }

    @Override

    public Feature getFeatureQuietly() {

        try {

            return this.getFeature();

        } catch(Exception ex) {

            return null;

        }

    }

    @Override

        public Feature getFeature(FeatureType featureType) throws DataException {

                return this.getStore().getFeatureByReference(this, featureType);

        }

    @Override

        public Object getOID() {

                return this.oid;

        }

    @Override

        public boolean isNewFeature() {

                return this.isNewFeature;

        }

    @Override

        public boolean equals(Object obj) {

                if (!(obj instanceof DefaultFeatureReference)) {

                        return false;

                }

                DefaultFeatureReference other = (DefaultFeatureReference) obj;

                FeatureStore otherStore = (FeatureStore) other.storeRef.get();

                FeatureStore myrStore = (FeatureStore) this.storeRef.get();

                if (otherStore == null || myrStore == null) {

                        return false;

                }

                if (!myrStore.equals(otherStore)) {

                        return false;

                }

                if (myHashCode != null && other.myHashCode != null) {

                        return myHashCode.equals(other.myHashCode);

                }

                if (this.oid != null) {

                        return this.oid.equals(other.oid);

                }

                if(pk != null) {

                        if(other.pk == null) {

                                return false;

                        }

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

                            if (!this.pk[i].equals(other.pk[i])) {

                                    return false;

                            }

                    }

                }

                return true;

        }

    @Override

        public int hashCode() {

                if (this.oid != null) {

                        return this.oid.hashCode();

                }

                if (myHashCode == null) {

                        StringBuilder buff = new StringBuilder();

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

                                buff.append(Objects.hashCode(this.pk[i]));

                                buff.append("##");

                        }

                        myHashCode = buff.toString().hashCode();

                }

                return myHashCode;

        }

    @Override

        public String[] getKeyNames() {

                return pkNames;

        }

    @Override

        public Object getKeyValue(String name) {

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

                        if (pkNames[i].equalsIgnoreCase(name)) {

                                return pk[i];

                        }

                }

                // FIXME exception????

                return null;

        }

    @Override

        public String getFeatureTypeId() {

                return featureTypeId;

        }

        // *** Persistence ***

    @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                this.oid = state.get("oid");

                this.myHashCode = (Integer) state.get("myHashCode");

                this.storeRef = new WeakReference(state.get("store"));

                this.isNewFeature = state.getBoolean("isNewFeature");

                this.featureTypeId = state.getString("featureTypeId");

                List pkList = (List) state.get("pk");

                if (pkList != null) {

                        List pkNamesList = (List) state.get("pkNames");

                        if (pkNamesList == null || pkList.size() != pkNamesList.size()) {

                                throw new PersistenceException("bad pkNames value");

                        }

                        this.pk = pkList.toArray();

            this.pkNames =

                (String[]) pkNamesList.toArray(new String[pkList.size()]);

                } else {

                        this.pk = null;

                        this.pkNames = null;

                }

        }

    @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("oid", oid);

                state.set("myHashCode", myHashCode);

                state.set("isNewFeature", isNewFeature);

                state.set("store", (Persistent) storeRef.get());

                state.set("featureTypeId", featureTypeId);

                if (pk == null) {

                        state.setNull("pk");

                        state.setNull("pkNames");

                } else {

                        state.set("pk", pk);

                        state.set("pkNames", pkNames);

                }

        }

        @Override

        public String getCode() {

//            JSONObject x = new JSONObject();

////            x.put("store", (Persistent) storeRef.get());

//            x.put("oid", oid);

//            x.put("myHashCode", myHashCode);

//            x.put("isNewFeature", isNewFeature);

//            x.put("featureTypeId", featureTypeId);

//            if( this.pk == null ) {

//                x.put("pkNames_size", -1);

//                x.put("pkNames", JSONObject.NULL);

//                x.put("pk", JSONObject.NULL);

//            } else {

//                x.put("pkNames_size", pkNames.length);

//                x.put("pkNames", new JSONArray(this.pkNames));

//                x.put("pk", new JSONArray(this.pk));

//            }

//

            Object[] data = new Object[7];

            data[OID_INDEX] = this.oid;

            data[MYHASHCODE_INDEX] = this.myHashCode;

            data[ISNEWFEATURE_INDEX] = this.isNewFeature;

            data[FEATURETYPEID_INDEX] = this.featureTypeId;

            if( this.pk == null ) {

                data[PKNAMES_SIZE_INDEX] = -1;

                data[PKNAMES_INDEX] = JSONObject.NULL;

                data[PK_INDEX] = JSONObject.NULL;

            } else {

                data[PKNAMES_SIZE_INDEX] = pkNames.length;

                data[PKNAMES_INDEX] = new JSONArray(this.pkNames);

                data[PK_INDEX] = new JSONArray(this.pk);            

            }            

            String s = new JSONArray(data).toString();

            String r = Base64.getEncoder().encodeToString(s.getBytes());

            return r;

        }

        public static void registerPersistent() {

                DynStruct definition = ToolsLocator.getPersistenceManager().addDefinition(

                                DefaultFeatureReference.class, 

                                "Reference", 

                                "DefaultFeatureReference Persistent definition", 

                                null, 

                                null

                        );

                definition.addDynFieldObject("oid")

                        .setClassOfValue(Object.class)

                        .setMandatory(false)

                        .setPersistent(true);

                definition.addDynFieldBoolean("isNewFeature")

                        .setMandatory(true)

                        .setPersistent(true);

                definition.addDynFieldObject("store")

                        .setClassOfValue(FeatureStore.class)

                        .setMandatory(true)

                        .setPersistent(true);

                definition.addDynFieldInt("myHashCode")

                        .setMandatory(false)

                        .setPersistent(true);

                definition.addDynFieldString("featureTypeId")

                        .setMandatory(true)

                        .setPersistent(true);

                definition.addDynFieldArray("pk")

                        .setClassOfItems(Object.class)

                        .setMandatory(false)

                        .setPersistent(true);

        definition.addDynFieldArray("pkNames")

                        .setClassOfItems(String.class)

                        .setMandatory(false)

                        .setPersistent(true);

        }

    @Override

        public String toString() {

        StringBuilder builder = new StringBuilder();

        builder.append("FeatureReference: oid = ");

        builder.append(oid);

        if( myHashCode!=null ) {

            builder.append(", myHashCode = ");

            builder.append(myHashCode);

        } 

        if( pk!=null ) {

            builder.append(", pks = ");

            builder.append(Arrays.asList(pk));

        }

        if( pkNames!=null ) {

            builder.append(", pkNames = ");

            builder.append(Arrays.asList(pkNames));

        }

        if( isNewFeature ) {

            builder.append(", isNew = ");

            builder.append(isNewFeature);

        }

        if( featureTypeId!=null ) {

            builder.append(", featureTypeId = ");

            builder.append(featureTypeId);

        }

        return builder.toString();

        }

}