Java Casts类代码示例

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
public void run() throws NoSuchMethodException, MissingDissectorsException, InvalidDissectorException {
    HttpdLoglineParser<MyRecord> parser = new HttpdLoglineParser<>(MyRecord.class, logFormat);

    List<String> allPossiblePaths = parser.getPossiblePaths();
    parser.addParseTarget(MyRecord.class.getMethod("setter", String.class, String.class), allPossiblePaths);

    System.out.println("class MyRecord {\n");

    for (String field : parser.getPossiblePaths()) {
        for (Casts cast : parser.getCasts(field)) {
            System.out.println("    @Field{\"" + field + "\"}\n" +
                    "    public void setter(String name, " + castToJavaType(cast) + " value) {\n" +
                    "        System.out.println(\"SETTER CALLED FOR \\\"\" + name + \"\\\" = \\\"\" + value + \"\\\"\");\n" +
                    "    }\n");
        }
    }
    System.out.println("}\n");
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(final String inputname, final String outputname) {
    String name = extractFieldName(inputname, outputname);
    if ("epoch".equals(name)) {
        wantTime = true;
        return Casts.STRING_OR_LONG;
    }
    if ("ip".equals(name)) {
        wantIp = true;
        return Casts.STRING_OR_LONG;
    }
    if ("processid".equals(name)) {
        wantProcessId = true;
        return Casts.STRING_OR_LONG;
    }
    if ("counter".equals(name)) {
        wantCounter = true;
        return Casts.STRING_OR_LONG;
    }
    if ("threadindex".equals(name)) {
        wantThreadIndex = true;
        return Casts.STRING_OR_LONG;
    }
    return null;
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
/**
 * This record will be used with a single parser. For each field that is to be parsed a setter will be called. It
 * registers a setter method for each field being parsed. It also builds the data writers to hold the data beings
 * parsed.
 *
 * @param parser
 * @param mapWriter
 * @param type
 * @param parserFieldName
 * @param drillFieldName
 * @throws NoSuchMethodException
 */
public void addField(final Parser<HttpdLogRecord> parser, final MapWriter mapWriter, final EnumSet<Casts> type, final String parserFieldName, final String drillFieldName) throws NoSuchMethodException {
  final boolean hasWildcard = parserFieldName.endsWith(HttpdParser.PARSER_WILDCARD);

  /**
   * This is a dynamic way to map the setter for each specified field type. <br/>
   * e.g. a TIME.STAMP may map to a LONG while a referrer may map to a STRING
   */
  if (hasWildcard) {
    final String cleanName = parserFieldName.substring(0, parserFieldName.length() - HttpdParser.PARSER_WILDCARD.length());
    LOG.debug("Adding WILDCARD parse target: {} as {}, with field name: {}", parserFieldName, cleanName, drillFieldName);
    parser.addParseTarget(this.getClass().getMethod("setWildcard", String.class, String.class), parserFieldName);
    parser.addParseTarget(this.getClass().getMethod("setWildcard", String.class, Double.class), parserFieldName);
    parser.addParseTarget(this.getClass().getMethod("setWildcard", String.class, Long.class), parserFieldName);
    wildcards.put(cleanName, mapWriter.map(drillFieldName));
  }
  else if (type.contains(Casts.DOUBLE)) {
    LOG.debug("Adding DOUBLE parse target: {}, with field name: {}", parserFieldName, drillFieldName);
    parser.addParseTarget(this.getClass().getMethod("set", String.class, Double.class), parserFieldName);
    doubles.put(parserFieldName, mapWriter.float8(drillFieldName));
  }
  else if (type.contains(Casts.LONG)) {
    LOG.debug("Adding LONG parse target: {}, with field name: {}", parserFieldName, drillFieldName);
    parser.addParseTarget(this.getClass().getMethod("set", String.class, Long.class), parserFieldName);
    longs.put(parserFieldName, mapWriter.bigInt(drillFieldName));
  }
  else {
    LOG.debug("Adding STRING parse target: {}, with field name: {}", parserFieldName, drillFieldName);
    parser.addParseTarget(this.getClass().getMethod("set", String.class, String.class), parserFieldName);
    strings.put(parserFieldName, mapWriter.varChar(drillFieldName));
  }
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
private String castToJavaType(Casts casts) {
    switch (casts) {
        case STRING:
            return "String";
        case LONG:
            return "Long";
        case DOUBLE:
            return "Double";
        default:
            return null;
    }
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(String inputname, String outputname) {
    if (dissectors.size() == 0) {
        return null;
    }

    EnumSet<Casts> result = EnumSet.noneOf(Casts.class); // Start empty
    for (Dissector dissector : dissectors) {
        result.addAll(dissector.prepareForDissect(inputname, outputname));
    }
    return result;
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
private List<TokenParser> createFirstAndLastTokenParsers(
    final String nLogFormatToken,
    final String nValueName,
    final String nValueType,
    final EnumSet<Casts> nCasts,
    final String nRegex) {
    return createFirstAndLastTokenParsers(nLogFormatToken, nValueName, nValueType, nCasts, nRegex, 0);
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(final String inputname, final String outputname) {
    String name = extractFieldName(inputname, outputname);
    switch (name) {
        case "value":   return Casts.STRING_ONLY;
        case "expires": return Casts.STRING_OR_LONG;
        case "path":    return Casts.STRING_ONLY;
        case "domain":  return Casts.STRING_ONLY;
        case "comment": return Casts.STRING_ONLY;
        default:        return Casts.STRING_ONLY;
    }
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
public NamedTokenParser(
        final String nLogFormatToken,
        final String nValueName,
        final String nValueType,
        final EnumSet<Casts> nCasts,
        final String nRegex) {
    this(nLogFormatToken, nValueName, nValueType, nCasts, nRegex, 0);
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
public NotImplementedTokenParser(final String nLogFormatToken, final String fieldPrefix, final String regEx, int nPrio) {
    super(nLogFormatToken,
        fieldPrefix + "_" + nLogFormatToken.toLowerCase(Locale.ENGLISH).replaceAll("[^a-z0-9_]", "_"),
        "NOT_IMPLEMENTED",
        Casts.STRING_ONLY,
        regEx,
        nPrio);
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(final String inputName, final String outputName) {
    requestedFields.add(outputName);
    for (Token token: logFormatTokens) {
        for (TokenOutputField tokenOutputField: token.getOutputFields()) {
            if (outputName.equals(tokenOutputField.getName())) {
                tokenOutputField.wasUsed();
                return tokenOutputField.getCasts();
            }
        }
    }
    return Casts.STRING_ONLY;
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
public TokenParser(final String nLogFormatToken,
        final String nValueName,
        final String nValueType,
        final EnumSet<Casts> nCasts,
        final String nRegex) {
    this(nLogFormatToken, nValueName, nValueType, nCasts, nRegex, 10);
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
public ParameterizedTokenParser(
        final String nLogFormatToken,
        final String nValueName,
        final String nValueType,
        final EnumSet<Casts> nCasts,
        final String nRegex,
        final int prio,
        final Dissector customDissector) {
    super(nLogFormatToken, nValueName, nValueType, nCasts, nRegex, prio, customDissector);

    // Compile the regular expression
    pattern = Pattern.compile(getLogFormatToken());
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public TokenParser addOutputField(String type, String name, EnumSet<Casts> casts) {
    if (getOutputFields().isEmpty()) {
        return super.addOutputField(type, name, casts);
    }
    throw new UnsupportedOperationException("A ParameterizedTokenParser only supports ONE outputfield.");
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(String inputname, String outputname) {
    String name = extractFieldName(inputname, outputname);
    if ("width".equals(name)) {
        wantWidth = true;
        return Casts.STRING_OR_LONG;
    }
    if ("height".equals(name)) {
        wantHeight = true;
        return Casts.STRING_OR_LONG;
    }
    return null;
}
 

import nl.basjes.parse.core.Casts; //导入依赖的package包/类
@Override
public EnumSet<Casts> prepareForDissect(final String inputname, final String outputname) {
    String name = extractFieldName(inputname, outputname);
    if ("protocol".equals(name)) {
        wantProtocol = true;
        return Casts.STRING_ONLY;
    }
    if ("userinfo".equals(name)) {
        wantUserinfo = true;
        return Casts.STRING_ONLY;
    }
    if ("host".equals(name)) {
        wantHost = true;
        return Casts.STRING_ONLY;
    }
    if ("port".equals(name)) {
        wantPort = true;
        return Casts.STRING_OR_LONG;
    }
    if ("path".equals(name)) {
        wantPath = true;
        return Casts.STRING_ONLY;
    }
    if ("query".equals(name)) {
        wantQuery = true;
        return Casts.STRING_ONLY;
    }
    if ("ref".equals(name)) {
        wantRef = true;
        return Casts.STRING_ONLY;
    }
    return null;
}