source: java/main/src/main/java/com/framsticks/params/ParamBuilder.java @ 88

package com.framsticks.params;

import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.params.types.*;
import com.framsticks.util.Builder;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.lang.Strings;

import org.apache.log4j.Logger;

import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.List;

/**
 * The class ParamBuilder helps building Param objects.
 *
 * @author Mateusz Jarus <name.surname@gmail.com> (please replace name and
 *         surname with my personal data)
 *
 * @author Piotr Śniegowski
 */

@FramsClassAnnotation(name = "prop", id = "prop")
public class ParamBuilder implements Builder<Param> {
        private final static Logger log = Logger.getLogger(ParamBuilder.class.getName());

        private static final String ID_FIELD = "id";
        private static final String NAME_FIELD = "name";
        private static final String HELP_FIELD = "help";
        private static final String GROUP_FIELD = "group";
        private static final String TYPE_FIELD = "type";
        private static final String FLAGS_FIELD = "flags";

        /** The parameter id. */
        private String id;

        /**
         * The parameter internal id. It's set by a user to use user's own id in
         * code
         */
        private String internalId;

        /** The number of group, that parameter belongs to. */
        private Integer group = 0;

        /** The flags stored as a bit sum. */
        private Integer flags = 0;

        /** The parameter name. */
        private String name;

        /** The help (description) concerning parameter. */
        private String help;

        /** The type of parameter. */
        private Class<? extends Param> paramType;

        private Object min;

        private Object max;

        private Object def;

        private Integer extra;

        String containedTypeName;

        protected Class<?> storageType;

        protected FramsClassBuilder classBuilder;

        public ParamBuilder() {
                this(null);
        }


        /**
         * @param classBuilder
         */
        public ParamBuilder(FramsClassBuilder classBuilder) {
                this.classBuilder = classBuilder;
        }


        /**
         * @return the min
         */
        @ParamAnnotation
        public Object getMin() {
                return min;
        }

        /**
         * @return the max
         */
        @ParamAnnotation
        public Object getMax() {
                return max;
        }

        /**
         * @return the def
         */
        @ParamAnnotation
        public Object getDef() {
                return def;
        }

        public String getContainedTypeName() {
                return Strings.notEmpty(containedTypeName) ? containedTypeName : null;
        }

        /**
         * @return the enumValues
         */
        public List<String> getEnumValues() {
                return enumValues;
        }

        /**
         * @return the procedureSignature
         */
        public String getProcedureSignature() {
                return procedureSignature;
        }

        /**
         * @return the uid
         */
        public String getUid() {
                return uid;
        }

        /**
         * Build Param based on provided data.
         *
         * @return Param object
         * @throws Exception
         *             when Param getType is not defined
         */
        public Param finish() {
                try {
                        if (paramType == null) {
                                throw new FramsticksException().msg("trying to finish incomplete param");
                        }

                        return paramType.getConstructor(ParamBuilder.class).newInstance(this);
                } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException | FramsticksException e) {
                        throw new FramsticksException().msg("failed to create param").cause(e).arg("name", name);
                }
        }

        @ParamAnnotation
        public ParamBuilder id(String id) {
                this.id = id;
                return this;
        }

        public <T extends Param> ParamBuilder type(Class<T> type) {
                assert type != null;
                this.paramType = type;
                return this;
        }

        // public <T extends Param> ParamBuilder type(T param) {
        //      return internalSetType(param.getClass(), param);
        // }


        /**
         * @return the id
         */
        @ParamAnnotation
        public String getId() {
                return id;
        }

        /**
         * @return the internalId
         */
        public String getInternalId() {
                return internalId;
        }

        public ParamBuilder setInternalId(String internalId) {
                this.internalId = internalId;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder group(Integer group) {
                this.group = group;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder flags(Integer flags) {
                this.flags = flags;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder name(String name) {
                this.name = name;
                return this;
        }

        protected <T extends Number> void parseMinMaxDefNumber(Class<T> type, String second, String third) {
                if (second != null) {
                        min = second;
                }
                if (third != null) {
                        max = third;
                }
        }

        protected List<String> enumValues;

        public ParamBuilder enums(List<String> values) {
                enumValues = values;
                return type(EnumParam.class);
        }

        protected String procedureSignature;

        protected String uid;

        @ParamAnnotation
        public ParamBuilder type(String type) {
                // typeString = type;
                assert type != null;

                log.trace("parsing type: " + type);

                String[] typeSplitted = type.split(" ");
                String first = typeSplitted[0];
                String second = typeSplitted.length > 1 ? typeSplitted[1] : null;
                String third = typeSplitted.length > 2 ? typeSplitted[2] : null;

                switch (first.charAt(0)) {
                        case 'o': {
                                containedTypeName = second != null ? second : first.substring(1);
                                type(ObjectParam.class);
                                break;
                        }
                        case 'p': {
                                procedureSignature = type.substring(1);
                                type(ProcedureParam.class);
                                break;
                        }
                        case 'd': {

                                int tildeIndex = type.indexOf("~");
                                if (tildeIndex != -1) {
                                        enums(Arrays.asList(type.substring(tildeIndex + 1).split("~")));
                                } else {
                                        if (first.length() >= 2) {
                                                switch (first.charAt(1)) {
                                                        case 'b': {
                                                                type(BinaryParam.class);
                                                                break;
                                                        }
                                                        case 'c': {
                                                                type(ColorParam.class);
                                                                break;
                                                        }
                                                        default: {
                                                                log.error("unknown type: " + first);
                                                                return this;
                                                        }
                                                }
                                        }
                                        if ("0".equals(second) && "1".equals(third)) {
                                                type(BooleanParam.class);
                                        }
                                        if (paramType == null) {
                                                type(DecimalParam.class);
                                        }
                                }
                                if (DecimalParam.class.isAssignableFrom(this.paramType)) {
                                        parseMinMaxDefNumber(Integer.class, second, third);
                                }
                                break;
                        }
                        case 'f': {
                                type(FloatParam.class);
                                parseMinMaxDefNumber(Double.class, second, third);
                                break;
                        }
                        case 'x': {
                                type(UniversalParam.class);
                                break;
                        }
                        case 's': {
                                type(StringParam.class);
                                min(second);
                                max(third);
                                break;
                        }
                        case 'e': {
                                type(EventParam.class);
                                break;
                        }
                        case 'l': {
                                containedTypeName = second;
                                if (third != null) {
                                        type(UniqueListParam.class);
                                        uid = third;
                                } else {
                                        type(ArrayListParam.class);
                                }
                                break;
                        }
                        default:{
                                log.error("unknown type: " + first);
                                return this;
                        }
                }
                return this;
        }

        @ParamAnnotation
        public ParamBuilder help(String help) {
                this.help = help;
                return this;
        }

        /**
         * @return the group
         */
        @ParamAnnotation
        public Integer getGroup() {
                return group;
        }

        /**
         * @return the flags
         */
        @ParamAnnotation
        public Integer getFlags() {
                return flags;
        }

        /**
         * @return the name
         */
        @ParamAnnotation
        public String getName() {
                return name;
        }

        /**
         * @return the help
         */
        @ParamAnnotation
        public String getHelp() {
                return help;
        }

        @ParamAnnotation
        public String getType() {
                return "?";
        }

        @ParamAnnotation(id = "xtra")
        public Integer getExtra() {
                return extra;
        }

        /**
         * @return the paramType
         */
        public Class<? extends Param> getParamType() {
                return paramType;
        }

        @ParamAnnotation(id = "xtra")
        public ParamBuilder extra(Integer extra) {
                this.extra = extra;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder min(Object min) {
                this.min = min;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder max(Object max) {
                this.max = max;
                return this;
        }

        @ParamAnnotation
        public ParamBuilder def(Object def) {
                this.def = def;
                return this;
        }


        public Param build(String line) throws Exception {
                String[] paramEntryValues = line.split(",");

                if (paramEntryValues.length == 0) {
                        log.warn("field empty or wrong format (" + line
                                        + ") - omitting");
                        return null;
                }

                for (int i = 0; i < paramEntryValues.length; ++i) {
                        paramEntryValues[i] = paramEntryValues[i].trim();
                }

                try {
                        id(paramEntryValues[0]);
                        group(Integer.valueOf(paramEntryValues[1]));
                        flags(Flags.read(paramEntryValues[2]));
                        name(paramEntryValues[3]);
                        type(paramEntryValues[4]);
                        help(paramEntryValues[6]);
                } catch (IndexOutOfBoundsException e) {
                        /** everything is ok, parameters have just finished*/
                } catch (NumberFormatException ex) {
                        log.warn("wrong format of entry: " + line
                                        + ", omitting");
                        return null;
                }
                return finish();
        }

        public void setField(String key, String value) {
                switch (key) {
                        case ID_FIELD:
                                id(value);
                                break;
                        case NAME_FIELD:
                                name(value);
                                break;
                        case TYPE_FIELD:
                                type(value);
                                break;
                        case FLAGS_FIELD:
                                flags(Flags.read(value));
                                break;
                        case HELP_FIELD:
                                help(value);
                                break;
                        case GROUP_FIELD:
                                group(Integer.valueOf(value));
                                break;
                        default:
                                log.error("unknown field for Param: " + key);
                                break;
                }
        }

        public ParamBuilder fillDef(Object def) {
                if (this.def == null) {
                        return def(def);
                }
                return this;
        }

        public ParamBuilder fillStorageType(Class<?> storageType) {
                if (this.storageType == null) {
                        this.storageType = storageType;
                }
                return this;
        }


        public Class<?> getStorageType() {
                return storageType;
        }
}