Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.store.csv;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class FieldTypeParser {

    private static final Logger LOGGER = LoggerFactory.getLogger(FieldTypeParser.class);

    public String name = null;

    public int type = DataTypes.STRING;

    public int size = 0;

    public int geomType = Geometry.TYPES.GEOMETRY;

    public int geomSubtype = Geometry.SUBTYPES.GEOM2D;

    public Map<String, String> tags = new HashMap<>();

    public Map<String, String> typetags = new HashMap<>();

    public Map<String, String> assignments = new HashMap<>();

    public Map<String, String> typeAssignments = new HashMap<>();

    // Valores obtenidos desde la deteccion automatica desde los datos

    public AutomaticDetectionOfTypes.DetectedValue detectedValue = null;

    private String typename = "string";

    private final String fullFileName;

    private final String providerName;

    FieldTypeParser(String providerName, String fullFileName) {

        this.providerName = providerName;

        this.fullFileName = fullFileName;

    }

    public String getProviderName() {

        return this.providerName;

    }

    public String getFullFileName() {

        return this.fullFileName;

    }

    public void clear() {

        this.name = null;

        this.type = DataTypes.UNKNOWN;

        this.size = 0;

        this.tags = new HashMap<>();

        this.typetags = new HashMap<>();

        this.assignments = new HashMap<>();

        this.typeAssignments = new HashMap<>();

    }

    public void copyFrom(FieldTypeParser other) {

        this.name = other.name;

        this.type = other.type;

        this.size = other.size;

        this.tags = new HashMap<>();

        this.tags.putAll(other.tags);

        this.typetags = new HashMap<>();

        this.typetags.putAll(other.typetags);

        this.assignments = new HashMap<>();

        this.assignments.putAll(other.assignments);

        this.typeAssignments = new HashMap<>();

        this.typeAssignments.putAll(other.typeAssignments);

    }

    private int getType(String value) {

        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

        return dataTypesManager.getType(typename);

    }

    private String[] split(String value, String separators) {

        int firstSeparatorPosition = 1000000;

        Character sep = null;

        for (char ch : separators.toCharArray()) {

            int pos = value.indexOf(ch);

            if (pos > 0 && pos < firstSeparatorPosition) {

                sep = ch;

                firstSeparatorPosition = pos;

            }

        }

        if (sep == null) {

            return new String[]{value};

        }

        return value.split("[" + sep + "]");

    }

    @SuppressWarnings(value = "UseSpecificCatch")

    public boolean parse(String value) {

        String[] args;

        if (value.contains("__")) {

            args = value.split("__");

        } else {

            args = split(value, ":/#@!;-");

            if (args.length == 1) {

                this.name = value;

                return true;

            }

        }

        int n = 0;

        this.name = StringUtils.trim(args[n++]);

        if (n >= args.length) {

            return true;

        }

        this.typename = StringUtils.trim(args[n++]);

        this.type = this.getType(this.typename);

        if (this.type == DataTypes.INVALID) {

            this.geomType = GeometryUtils.getGeometryType(this.typename);

            if (this.geomType == Geometry.TYPES.UNKNOWN) {

                this.type = DataTypes.STRING;

                LOGGER.info("Type '" + this.typename + "' not valid for attribute '" + value + "' in '" + getProviderName() + "' file '" + getFullFileName() + "'.");

            } else {

                this.typename = "GEOMETRY";

                this.type = DataTypes.GEOMETRY;

            }

        }

        this.size = 0;

        while (n < args.length) {

            String option = StringUtils.trim(args[n++].toLowerCase());

            switch (option) {

                case "size":

                    try {

                        this.size = Integer.parseInt(args[n++]);

                    } catch (Exception ex) {

                        LOGGER.warn("Ignore incorrect field size for field " + value + " in '" + getProviderName() + "' file '" + getFullFileName() + "'.", ex);

                    }

                    break;

                case "tag":

                    {

                        String x = StringUtils.trim(args[n++]);

                        int pos = x.indexOf("=");

                        if (pos < 0) {

                            this.tags.put(x, null);

                        } else {

                            this.tags.put(StringUtils.trim(StringUtils.substring(x, 0, pos)), StringUtils.trim(StringUtils.substring(x, pos + 1)));

                        }

                        break;

                    }

                case "typetag":

                    {

                        String x = StringUtils.trim(args[n++]);

                        int pos = x.indexOf("=");

                        if (pos < 0) {

                            this.typetags.put(x, null);

                        } else {

                            this.typetags.put(StringUtils.trim(StringUtils.substring(x, 0, pos)), StringUtils.trim(StringUtils.substring(x, pos + 1)));

                        }

                        break;

                    }

                case "set":

                    {

                        String x = StringUtils.trim(args[n++]);

                        int pos = x.indexOf("=");

                        if (pos < 0) {

                            this.assignments.put(x, null);

                        } else {

                            this.assignments.put(StringUtils.trim(StringUtils.substring(x, 0, pos)), StringUtils.trim(StringUtils.substring(x, pos + 1)));

                        }

                        break;

                    }

                case "typeset":

                    {

                        String x = StringUtils.trim(args[n++]);

                        int pos = x.indexOf("=");

                        if (pos < 0) {

                            this.typeAssignments.put(x, null);

                        } else {

                            this.typeAssignments.put(StringUtils.trim(StringUtils.substring(x, 0, pos)), StringUtils.trim(StringUtils.substring(x, pos + 1)));

                        }

                        break;

                    }

                default:

                    if (StringUtils.isNumeric(option) && this.size == 0) {

                        try {

                            this.size = Integer.parseInt(option);

                        } catch (Exception ex) {

                            LOGGER.warn("Ignore incorrect field size for field " + value + " in '" + getProviderName() + "' file '" + getFullFileName() + "'.", ex);

                        }

                        break;

                    }

                    LOGGER.warn("Illegal argumente '" + option + "' for field '" + this.name + "' in '" + getProviderName() + "' file '" + getFullFileName() + "' (" + value + ").");

            }

        }

        return true;

    }

}