source: java/main/src/main/java/com/framsticks/communication/Request.java @ 98

package com.framsticks.communication;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.framsticks.communication.queries.*;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.lang.Pair;

/**
 * Class stores information about query sent to manager.
 */
public abstract class Request {

        public abstract String getCommand();

        protected abstract StringBuilder construct(StringBuilder buffer);




        public static void quoteValue(StringBuilder builder, String value) {
                String quote = ((value.indexOf(' ') > 0) || (value.length() == 0) ? "\"" : "");
                builder.append(quote).append(value).append(quote);
        }

        public static Request parse(CharSequence type, CharSequence rest) {
                final Request request = Request.createRequestByTypeString(type.toString());
                request.parseRest(rest);
                return request;
        }

        public static Request createRequestByTypeString(String type) {
                switch (type) {
                        case "get": return new GetRequest();
                        case "set": return new SetRequest();
                        case "info": return new InfoRequest();
                        case "call": return new CallRequest();
                        case "reg": return new RegistrationRequest();
                        case "use": return new UseRequest();
                        case "version": return new VersionRequest();
                }
                throw new FramsticksException().msg("unknown request type").arg("type", type);
        }

        public abstract CharSequence parseRest(CharSequence rest);

        @Override
        public String toString() {
                // return getCommand();
                return "request " + stringRepresentation();
        }

        public String stringRepresentation() {
                return construct(new StringBuilder().append(getCommand()).append(" ")).toString();
        }

        public static final Pattern EVENT_PATTERN = Pattern.compile("^\\s*(\\S+)\\s*(\\S+)");

        public static final Pattern STRING_BREAKER_PATTERN = Pattern.compile("^\\s*(?:(?:\\\"([^\"]*)\\\")|([^ ]+))\\s*(.*)$");
        public static final Pattern IDENTIFIER_BREAKER_PATTERN = Pattern.compile("^\\s*([^ ]+)\\s*(.*)$");

        // public static Matcher match(Pattern pattern, CharSequence line) {
        //      Matcher matcher = pattern.matcher(line);
        //      if (!matcher.matches()) {
        //              return null;
        //              // throw new FramsticksException().msg("failed to take").arg("pattern", pattern).arg("line", line);
        //      }
        //      return matcher;
        // }

        public static Pair<CharSequence, CharSequence> takeIdentifier(CharSequence line) {
                Matcher matcher = IDENTIFIER_BREAKER_PATTERN.matcher(line);
                if (!matcher.matches()) {
                        return null;
                }
                return new Pair<CharSequence, CharSequence>(line.subSequence(matcher.start(1), matcher.end(1)), line.subSequence(matcher.start(2), matcher.end(2)));
        }

        public static CharSequence takeGroup(CharSequence input, Matcher matcher, int group) {
                // return (matcher.start(group) == matcher.end(group)) ? null : input.subSequence(matcher.start(group), matcher.end(group));
                return input.subSequence(matcher.start(group), matcher.end(group));
        }

        public static Pair<CharSequence, CharSequence> takeString(CharSequence line) {
                Matcher matcher = STRING_BREAKER_PATTERN.matcher(line);
                if (!matcher.matches()) {
                        return null;
                }
                assert ((matcher.start(1) == -1) != (matcher.start(2) == -1));
                return new Pair<CharSequence, CharSequence>(takeGroup(line, matcher, (matcher.start(1) != -1 ? 1 : 2)), takeGroup(line, matcher, 3));
        }

        protected static final Pattern REQUEST_ID_BREAKER_PATTERN = Pattern.compile("^\\s*([0-9]+)\\s*(.*)$");

        protected final static Pair<Integer, CharSequence> takeRequestId(boolean withId, CharSequence line) {
                if (withId) {
                        Matcher matcher = REQUEST_ID_BREAKER_PATTERN.matcher(line);
                        if (!matcher.matches()) {
                                return null;
                        }
                        return new Pair<Integer, CharSequence>(Integer.valueOf(takeGroup(line, matcher, 1).toString()), takeGroup(line, matcher, 2));
                }
                return new Pair<Integer, CharSequence>(null, line);
        }

        public static StringBuilder quoteArgumentIfNeeded(StringBuilder builder, Object argument) {
                String r = argument.toString();
                if (r.indexOf(' ') != -1) {
                        builder.append('"').append(r).append('"');
                } else {
                        builder.append(r);
                }
                return builder;
        }

}