nl.basjes.parse.core

Class Parser<RECORD>

java.lang.Object

nl.basjes.parse.core.Parser<RECORD>

All Implemented Interfaces:

Serializable

public class Parser<RECORD>
extends Object
implements Serializable

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
Parser(Class<RECORD> clazz)

Method Summary

Modifier and Type	Method and Description
void	addDissector(Dissector dissector)
void	addDissectors(List<Dissector> dissectors)
void	addParseTarget(Method method, List<String> fieldValues)
void	addParseTarget(Method method, String fieldValue)
void	addParseTarget(String setterMethodName, String fieldValue)
void	addTypeRemapping(String input, String newType)
void	addTypeRemapping(String input, String newType, EnumSet<Casts> newCasts)
void	addTypeRemappings(Map<String,Set<String>> additionalTypeRemappings)
static String	cleanupFieldValue(String fieldValue)
Parsable<RECORD>	createParsable()
void	dropDissector(Class<? extends Dissector> dissectorClassToDrop)
void	failOnMissingDissectors() Reset back to the default of failing on missing dissectors.
Map<String,EnumSet<Casts>>	getAllCasts()
Set<Dissector>	getAllDissectors()
EnumSet<Casts>	getCasts(String name) Returns the casts possible for the specified path.
Set<String>	getNeeded()
List<String>	getPossiblePaths() This method is for use by the developer to query the parser about the possible paths that may be extracted.
List<String>	getPossiblePaths(int maxDepth) This method is for use by the developer to query the parser about the possible paths that may be extracted.
void	ignoreMissingDissectors() This method sets the flag to ignore the missing dissectors situation.
RECORD	parse(RECORD record, String value) Parse the value and call all configured setters in the provided instance of RECORD.
RECORD	parse(String value) Parse the value and return a new instance of RECORD.
void	setRootType(String newRootType)
void	setTypeRemappings(Map<String,Set<String>> pTypeRemappings)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Parser

public Parser(Class<RECORD> clazz)

Method Detail

getNeeded

public Set<String> getNeeded()

getCasts

public EnumSet<Casts> getCasts(String name)
                        throws MissingDissectorsException,
                               InvalidDissectorException

Returns the casts possible for the specified path. Before you call 'getCasts' the actual parser needs to be constructed. Simply calling getPossiblePaths does not build the actual parser. If you want to get the casts for all possible paths the code looks something like this:

 Parser<Object> dummyParser= new HttpdLoglineParser<>(Object.class, logformat);
 List<String> possiblePaths = dummyParser.getPossiblePaths();
 // Use a random method that has the right signature
 dummyParser.addParseTarget(String.class.getMethod("indexOf", String.class), possiblePaths);
 for (String path : possiblePaths) {
     LOG.info("{}     {}", path, dummyParser.getCasts(path));
 }
 

Parameters:

name - The name of the path for which you want the casts

Returns:

The set of casts that are valid for this name. Null if this name is unknown.

Throws:

MissingDissectorsException

InvalidDissectorException

getAllCasts

public Map<String,EnumSet<Casts>> getAllCasts()
                                       throws MissingDissectorsException,
                                              InvalidDissectorException

Throws:

MissingDissectorsException

InvalidDissectorException

addDissectors

public final void addDissectors(List<Dissector> dissectors)

addDissector

public final void addDissector(Dissector dissector)

dropDissector

public final void dropDissector(Class<? extends Dissector> dissectorClassToDrop)

getAllDissectors

public final Set<Dissector> getAllDissectors()

setRootType

public void setRootType(String newRootType)

ignoreMissingDissectors

public void ignoreMissingDissectors()

This method sets the flag to ignore the missing dissectors situation. This must be called before parsing the first line. The effect is that those fields that would have been classified as 'missing' will result in a null value (or better: the setter is never called) for all records.

failOnMissingDissectors

public void failOnMissingDissectors()

Reset back to the default of failing on missing dissectors.

addParseTarget

public void addParseTarget(String setterMethodName,
                           String fieldValue)
                    throws NoSuchMethodException

Throws:

NoSuchMethodException

addParseTarget

public void addParseTarget(Method method,
                           String fieldValue)

addParseTarget

public void addParseTarget(Method method,
                           List<String> fieldValues)

setTypeRemappings

public void setTypeRemappings(Map<String,Set<String>> pTypeRemappings)

addTypeRemappings

public void addTypeRemappings(Map<String,Set<String>> additionalTypeRemappings)

addTypeRemapping

public void addTypeRemapping(String input,
                             String newType)

addTypeRemapping

public void addTypeRemapping(String input,
                             String newType,
                             EnumSet<Casts> newCasts)

cleanupFieldValue

public static String cleanupFieldValue(String fieldValue)

parse

public RECORD parse(String value)
             throws DissectionFailure,
                    InvalidDissectorException,
                    MissingDissectorsException

Parse the value and return a new instance of RECORD. For this method to work the RECORD class may NOT be an inner class.

Throws:

DissectionFailure

InvalidDissectorException

MissingDissectorsException

parse

public RECORD parse(RECORD record,
                    String value)
             throws DissectionFailure,
                    InvalidDissectorException,
                    MissingDissectorsException

Parse the value and call all configured setters in the provided instance of RECORD.

Throws:

DissectionFailure

InvalidDissectorException

MissingDissectorsException

createParsable

public Parsable<RECORD> createParsable()

getPossiblePaths

public List<String> getPossiblePaths()

This method is for use by the developer to query the parser about the possible paths that may be extracted.

Returns:

A list of all possible paths that could be determined automatically.

getPossiblePaths

public List<String> getPossiblePaths(int maxDepth)

This method is for use by the developer to query the parser about the possible paths that may be extracted.

Parameters:

maxDepth - The maximum recursion depth

Returns:

A list of all possible paths that could be determined automatically.