Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package de.agilecoders.wicket.logging;
  
  
  import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

A specification of a ClientSideLoggingBehavior.Builder configuration.

SpecBuilder supports parsing a string configuration, which is useful for command-line configuration of a ClientSideLoggingBehavior.Builder.

The string syntax is a series of comma-separated keys or key-value pairs, each corresponding to a ClientSideLoggingBehavior.Builder method.

Author(s):
miha
Since:
0.1.2
 
 public class SpecBuilder {
     private static final ImmutableMap<StringValueParser<?>> VALUE_PARSERS = ImmutableMap.<StringValueParser<?>>builder()
             .put("replaceWicketLog"new BooleanParser(.))
             .put("replaceWindowOnError"new BooleanParser(.))
             .put("wrapWicketLog"new BooleanParser(.))
             .put("wrapWindowOnError"new BooleanParser(.))
             .put("logAdditionalErrors"new BooleanParser(.))
             .put("flushMessagesOnUnload"new BooleanParser(.))
             .put("collectClientInfos"new BooleanParser(.))
             .put("collectionTimer"new DurationParser(.))
             .put("maxQueueSize"new LongParser(.))
             .put("loggerName"new StringParser(.))
             .put("collectionType"new CollectionTypeParser(.))
             .build();

    
base interface for all value parser

Parameters:
<T> the return type of parse method
 
     static interface ValueParser<T> {
         T parse(String value);
     }

    
parse a give string specification

Parameters:
spec the specification to parse
Returns:
a SpecBuilder instance
 
     public static SpecBuilder parse(final String spec) {
         return new SpecBuilder(spec);
     }
 
     private static final Splitter propertySplitter = Splitter.on(',').omitEmptyStrings();
     private static final Splitter keyValueSplitter = Splitter.on('=').omitEmptyStrings().limit(2);
 
     private final String spec;
     private final Map<StringObjectdata;

    
Construct.

Parameters:
spec the specification to parse
 
     public SpecBuilder(String spec) {
         this. = spec;
         this. = toParsedData(parseKeyValues(spec));
     }
 
     private Map<StringObjecttoParsedData(Map<StringStringkeyValues) {
         final Map<StringObjectdata = new HashMap<>();
 
         for (Map.Entry<StringStringkeyValue : keyValues.entrySet()) {
             ValueParser parser = .get(keyValue.getKey());
             Object val = parser.parse(keyValue.getValue());
 
             if (val != null) {
                 data.put(keyValue.getKey(), val);
             }
         }
         return data;
     }
 
     private Map<StringStringparseKeyValues(String spec) {
         Map<StringStringmap = new HashMap<>();
         for (String prop : .split(spec)) {
             if (prop != null && prop.contains("=")) {
                 final List<StringkeyValue = Lists.newArrayList(.split(prop));
                 map.put(keyValue.get(0), keyValue.get(1));
             }
         }
 
         return map;
     }

    

Returns:
specification that is used to create data
    public String specification() {
        return ;
    }

    

Returns:
the parsed data
    public Map<StringObjectdata() {
        return new HashMap<>();
    }
    static class BooleanParser implements ValueParser<Boolean> {
        private final boolean defaultValue;
        BooleanParser(boolean defaultValue) {
            this. = defaultValue;
        }
        @Override
        public Boolean parse(String value) {
            boolean val = Strings.isTrue(value);
            return val ==  ? null : val;
        }
    }
    static class LongParser implements ValueParser<Long> {
        private final long defaultValue;
        LongParser(long defaultValue) {
            this. = defaultValue;
        }
        @Override
        public Long parse(String value) {
            Long val = Long.valueOf(value);
            return  == val ? null : val;
        }
    }
    static class DurationParser implements ValueParser<Long> {
        private final Duration defaultValue;
        DurationParser(long defaultValue) {
            this. = Duration.valueOf(defaultValue);
        }
        @Override
        public Long parse(String value) {
            Duration d = Duration.valueOf(value);
            return d == null || .equals(d) ? null : d.getMilliseconds();
        }
    }
    static class CollectionTypeParser implements ValueParser<String> {
        private final CollectionType defaultValue;
        CollectionTypeParser(CollectionType defaultValue) {
            this. = defaultValue;
        }
        @Override
        public String parse(String value) {
            CollectionType type = CollectionType.valueOf(value);
            return type == null || .equals(type) ? null : type.asString();
        }
    }
    static class StringParser implements ValueParser<String> {
        private final String defaultValue;
        StringParser(String defaultValue) {
            this. = defaultValue;
        }
        @Override
        public String parse(String value) {
            return .equals(value) ? null : value;
        }
    }
New to GrepCode? Check out our FAQ X