com.github.siwenyan.potluck.SetMenuManagerSingleton 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.NGException;
import com.github.siwenyan.common.StringTools;
import com.github.siwenyan.dish_parser.*;

import java.util.*;

public class SetMenuManagerSingleton {
    public static final String CREATE_SET_MENU = "stepSet";
    public static final String SET_NAME_KEY = "name";
    public static final String PARAM_NAMES_KEY = "paramNames";
    public static final String PARAMS_KEY = "params";
    public static final String PARAM_NAME_SEPARATOR = ":";
    public static final String PARAM_SEPARATOR = "\\s*:\\s*";
    public static final String PARAM_INDICATOR = "%%";

    private static SetMenuManagerSingleton instance = new SetMenuManagerSingleton();
    private Map setMenus = new TreeMap();

    private SetMenuManagerSingleton() {
    }

    public static SetMenuManagerSingleton getInstance() {
        return instance;
    }

    public SetMenu get(String name) {
        return setMenus.get(name);
    }

    public SetMenu remove(String name) {
        return setMenus.remove(name);
    }

    public void put(String name, SetMenu setMenu) {
        this.setMenus.put(name, setMenu);
    }

    public boolean containsKey(String name) {
        return this.setMenus.containsKey(name);
    }

    public Set keySet() {
        return this.setMenus.keySet();
    }

    public void createSetMenu(ISupply supply) throws BadSmellException {
        ISupply forSetMenu = supply.getSupply(0);
        if (forSetMenu.getFlavor(0).getFlavorName().equals(CREATE_SET_MENU)) {
            IDish setDish = SimpleDish.cook(forSetMenu);
            String name = setDish.getStringElement(SET_NAME_KEY,
                    Constants.DEFAULT_KEY);

            if (name == null || name.trim().isEmpty()) {
                throw new BadSmellException(CREATE_SET_MENU + ": Missing "
                        + SET_NAME_KEY + ".");
            } else {
                SetMenu setMenu = new SetMenu();
                setMenu.setName(name);
                setMenu.setMenu(supply);

                String sParamNames = setDish.getStringElement(PARAM_NAMES_KEY);
                if (sParamNames == null || sParamNames.trim().isEmpty()) {
                    setDish.removeElement(SET_NAME_KEY);
                    SyntaxSimple.removeReservedParameters(setDish);
                    setDish.removeElement(Constants.DEFAULT_KEY);
                    if (setDish.size() > 0) {
                        setMenu.setDefaults(setDish);
                    } else {
                        // do nothing : params are optional
                    }
                } else {
                    sParamNames = sParamNames.trim();
                    List paramNames = SyntaxSimple.splitWithQuotedString(
                            sParamNames, SyntaxSimple.SYMBOL_QUOTE,
                            new String[]{PARAM_NAME_SEPARATOR},
                            Integer.MAX_VALUE, true, null);
                    setMenu.setEmptyDefaults(paramNames);
                }

                SetMenuManagerSingleton.getInstance().put(name, setMenu);
            }

        } else {
            throw new BadSmellException("Not a " + CREATE_SET_MENU
                    + " command.");
        }
    }

    public boolean exists(String name) {
        return setMenus.containsKey(name);
    }

    public List copy(String name, IDish paramsDish) throws NGException {
        if (!setMenus.containsKey(name)) {
            throw new NGException("No such Step Set: " + name);
        }

        SetMenu setMenu = setMenus.get(name);
        ISupply menu = setMenu.getMenu();
        menu.removeSupply(0);
        if (menu.size() <= 0) {
            throw new NGException("Steps are required for a Step Set.");
        }
        List rawLines = menu.getLines();

        String[][] paramsMap = setMenu.getDefaults();
        if (paramsMap == null || paramsMap.length <= 0) {
            return rawLines;
        }

        if (paramsDish.containsElement(PARAMS_KEY)) {
            String sParams = paramsDish.getStringElement(PARAMS_KEY).trim();
            List params = SyntaxSimple.splitWithQuotedString(sParams,
                    SyntaxSimple.SYMBOL_SQUOTE,
                    new String[]{Constants.OUTPUT_PARAM_SEPARATOR1}, 0,
                    true, null);
			/*
			if (params.size() != paramsMap.length) {
				throw new NGException(
						"Number of parameters doesn't match the number of parameter names.\r\n\t"
								+ sParams + "\r\n\t" + paramsMap.toString());
			}
			*/
            paramsMap = this.setParamsByParamsKey(paramsMap, params);
        } else {
            paramsMap = this.setParamsByName(paramsMap, paramsDish);
        }

        List newLines = new ArrayList(rawLines.size());
        for (String line : rawLines) {
            for (String[] paramNameValuePair : paramsMap) {
                String placeholder = PARAM_INDICATOR + paramNameValuePair[0]
                        + PARAM_INDICATOR;
                if (line.contains(placeholder)) {
                    line = StringTools.replaceAll(line, placeholder,
                            paramNameValuePair[1]);
                }
            }
            newLines.add(line);
        }

        return newLines;
    }

    private String[][] setParamsByName(String[][] paramsMap, IDish paramsDish) {
        String[][] newParamsMap = new String[paramsMap.length][2];
        for (int i = 0; i < paramsMap.length; i++) {
            newParamsMap[i][0] = paramsMap[i][0];
            if (paramsDish.containsElement(paramsMap[i][0])) {
                newParamsMap[i][1] = paramsDish
                        .getStringElement(paramsMap[i][0]);
            } else {
                newParamsMap[i][1] = paramsMap[i][1];
            }
        }
        return newParamsMap;
    }

    private String[][] setParamsByParamsKey(String[][] paramsMap,
                                            List params) {
        String[][] newParamsMap = new String[paramsMap.length][2];
        for (int i = 0; i < Math.min(params.size(), paramsMap.length); i++) {
            newParamsMap[i][0] = paramsMap[i][0];
            newParamsMap[i][1] = params.get(i);
        }

        return newParamsMap;
    }

}