com.github.siwenyan.potluck.SimpleDish Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of potluck Show documentation
Si Wenyan potluck framework
The newest version!
package com.github.siwenyan.potluck;

import com.github.siwenyan.common.*;
import com.github.siwenyan.dish_parser.*;

import java.util.*;

public class SimpleDish implements IDish {

    private ISupply supply = null;

    // private Flavor flavor = null;

    private Map elements = new LinkedHashMap();

    public static IDish cook(ISupply supply) throws BadSmellException {
        if (supply == null || supply.isEmpty()) {
            throw new BadSmellException("No Command.");
        }
        String raw = supply.getLine(0);
        if (raw == null || raw.trim().equals("")) {
            return null;
        }

        SimpleDish simpleDish = new SimpleDish();
        simpleDish.supply = supply;
        String[] parts = SyntaxSimple.slideFlavor(raw);
        // simpleDish.setFlavor(new Flavor(parts[0]));

        if (parts.length == 2) {
            try {
                String part1 = parts[1].trim();
                if (!part1.isEmpty()) {
                    Map params = splitParams(parts[1].trim());
                    simpleDish.addAllElements(params);
                }
            } catch (BadSmellException e) {
                throw new BadSmellException(raw + "\r\n" + e.getMessage());
            }
        }

        return simpleDish;

    }

    private static Map splitParams(String sParams) throws BadSmellException {
        Map params = new LinkedHashMap();

        StringNorm norm = new StringNorm(SyntaxSimple.NORM_TEXT_PLACEHOLDER);
        List packages = SyntaxSimple.splitWithQuotedString(sParams, SyntaxSimple.SYMBOL_QUOTE,
                new String[]{" ", "\t", "\r", "\n", SyntaxSimple.SYMBOL_EQUAL}, Integer.MAX_VALUE, false, norm);
        if (!SyntaxSimple.PATTERN_MATCH_NORM_PATAMS.matcher(norm.toString()).matches()) {
            throw new BadSmellException("Bad Syntax: [" + sParams + "]. (NORM[" + norm + "])");
        }

        int size = packages.size();
        if (size % 2 == 1) {
            String primeParam = packages.remove(0).trim();
            primeParam = StringTools.peel(primeParam, SyntaxSimple.SYMBOL_QUOTE);
            params.put(Constants.DEFAULT_KEY, primeParam);
            size--;
        }

        for (int i = 0; i < size; i += 2) {
            String one = packages.get(i).trim();
            String two = packages.get(i + 1).trim();
            String key = StringTools.peel(one, SyntaxSimple.SYMBOL_QUOTE);
            String value = StringTools.peel(two, SyntaxSimple.SYMBOL_QUOTE);
            if (key.isEmpty()) {
                throw new BadSmellException("Empty parameter name: [" + one + SyntaxSimple.SYMBOL_QUOTE + two + "].");
            }
            params.put(key, value);
        }

        return params;
    }

    public Flavor getFlavor() {
        return this.supply.getFlavor(0);
    }

    /*
     * @Override public void setFlavor(Flavor flavor) { this.flavor = flavor; }
     */

    public void setElements(Map elements) {
        this.elements.clear();
        if (elements != null) {
            for (String key : elements.keySet()) {
                this.elements.put(key, elements.get(key));
            }
        }
    }

    public void setElement(String name, Object element) {
        elements.put(name, element);
    }

    public Object getElement(String name) {
        return this.elements.get(name);
    }

    public String getStringElement(String... optKey) {
        if (optKey == null || optKey.length <= 0) {
            return "";
        }
        for (String key : optKey) {
            Object element = this.getElement(key);
            if (element == null || !(element instanceof String)) {
                continue;
            }
            String value = (String) element;
            return value;
        }
        return "";
    }

    public void addAllElements(Map params) {
        elements.putAll(params);
    }

    @Override
    public String toString() {
        String str = "";

        str += this.getFlavor();

        if (this.elements.size() > 0) {
            Iterator ki = this.elements.keySet().iterator();
            String key = ki.next();
            String value = (String) this.elements.get(key);
            str += Constants.OUTPUT_FLAVOR_SEPARATOR + SyntaxSimple.SYMBOL_QUOTE + key + SyntaxSimple.SYMBOL_QUOTE
                    + Constants.OUTPUT_PARAMNAME_SEPARATOR + SyntaxSimple.SYMBOL_QUOTE + value
                    + SyntaxSimple.SYMBOL_QUOTE;

            while (ki.hasNext()) {
                key = ki.next();
                value = (String) this.elements.get(key);
                str += Constants.OUTPUT_PARAM_SEPARATOR + SyntaxSimple.SYMBOL_QUOTE + key + SyntaxSimple.SYMBOL_QUOTE
                        + Constants.OUTPUT_PARAMNAME_SEPARATOR + SyntaxSimple.SYMBOL_QUOTE + value
                        + SyntaxSimple.SYMBOL_QUOTE;
            }
        }

        return str;
    }

    public boolean containsElement(String key) {
        return this.elements.containsKey(key);
    }

    public Set getElementKeySet() {
        return this.elements.keySet();
    }

    public Set getElementKeySet(String partialName) {
        Set keySet = this.getElementKeySet();
        Set resultKeySet = new LinkedHashSet(1);
        for (String key : keySet) {
            if (key.indexOf(partialName) >= 0) {
                resultKeySet.add(key);
            }
        }
        return resultKeySet;
    }

    public boolean hasElements() {
        return this.elements.size() > 0;
    }

    public Object removeElement(String key) {
        return this.elements.remove(key);
    }

    public ISupply getSupply() {
        return this.supply;
    }

    public int size() {
        return elements.size();
    }

    public int getPositiveIntegerElement(String... optKey) {
        String sElement = this.getStringElement(optKey);
        return StringTools.parsePositiveInteger(sElement);
    }

    @Override
    public Map asOptions() {
        return new LinkedHashMap<>(this.elements);
    }

}