private Match _findFormat(AccessorForReader paramAccessorForReader) { Object localObject1 = null; Object localObject2 = null; for (ObjectReader localObjectReader : this._readers) { paramAccessorForReader.reset(); MatchStrength localMatchStrength = localObjectReader.getFactory().hasFormat(paramAccessorForReader); if ((localMatchStrength != null) && (localMatchStrength.ordinal() >= this._minimalMatch.ordinal()) && ((localObject1 == null) || (localObject2.ordinal() < localMatchStrength.ordinal()))) { localObject1 = localObjectReader; localObject2 = localMatchStrength; if (localMatchStrength.ordinal() >= this._optimalMatch.ordinal()) break; } } return paramAccessorForReader.createMatcher(localObject1, localObject2); }
private DataFormatReaders(ObjectReader[] paramArrayOfObjectReader, MatchStrength paramMatchStrength1, MatchStrength paramMatchStrength2, int paramInt) { this._readers = paramArrayOfObjectReader; this._optimalMatch = paramMatchStrength1; this._minimalMatch = paramMatchStrength2; this._maxInputLookahead = paramInt; }
protected Match(InputStream paramInputStream, byte[] paramArrayOfByte, int paramInt1, int paramInt2, ObjectReader paramObjectReader, MatchStrength paramMatchStrength) { this._originalStream = paramInputStream; this._bufferedData = paramArrayOfByte; this._bufferedStart = paramInt1; this._bufferedLength = paramInt2; this._match = paramObjectReader; this._matchStrength = paramMatchStrength; }
private static MatchStrength tryMatch(InputAccessor paramInputAccessor, String paramString, MatchStrength paramMatchStrength) { int i = 0; int j = paramString.length(); while (i < j) { if (!paramInputAccessor.hasMoreBytes()) return MatchStrength.INCONCLUSIVE; if (paramInputAccessor.nextByte() != paramString.charAt(i)) return MatchStrength.NO_MATCH; i++; } return paramMatchStrength; }
private static MatchStrength tryMatch(InputAccessor acc, String matchStr, MatchStrength fullMatchStrength) throws IOException { for (int i = 0, len = matchStr.length(); i < len; ++i) { if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } if (acc.nextByte() != matchStr.charAt(i)) { return MatchStrength.NO_MATCH; } } return fullMatchStrength; }
public MatchStrength hasFormat(InputAccessor acc) throws IOException { // since we can't keep this abstract, only implement for "vanilla" instance if (getClass() == JsonFactory.class) { return hasJSONFormat(acc); } return null; }
/** * Sub-classes need to override this method (as of 1.8) */ @Override public MatchStrength hasFormat(InputAccessor acc) throws IOException { if (getClass() == MappingJsonFactory.class) { return hasJSONFormat(acc); } return null; }
/** * Sub-classes need to override this method (as of 1.8) */ @Override public MatchStrength hasFormat(InputAccessor acc) throws IOException { if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } byte b = acc.nextByte(); // Very first thing, a UTF-8 BOM? if (b == UTF8_BOM_1) { // yes, looks like UTF-8 BOM if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } if (acc.nextByte() != UTF8_BOM_2) { return MatchStrength.NO_MATCH; } if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } if (acc.nextByte() != UTF8_BOM_3) { return MatchStrength.NO_MATCH; } if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } b = acc.nextByte(); } if (b == '{' || Character.isLetter((char) b) || Character.isDigit((char) b)) { return MatchStrength.WEAK_MATCH; } return MatchStrength.INCONCLUSIVE; }
/** * Creates a single data input stream from either file or InputStream depending on which one is present. Preference * for file if both present. Additionally also detects input data format of the result stream, throws * IllegalArgumentException if unable to determine data format. * * @param stream InputStream of the data if present * @param inputFile Path to file to use as input * @param addRootElementToXml To add vespafeed root element around the input data stream * @throws IOException on errors. */ public FormatInputStream(InputStream stream, Optional<String> inputFile, boolean addRootElementToXml) throws IOException { final DataFormatDetector dataFormatDetector = new DataFormatDetector(new JsonFactory(), new XmlFactory()); final DataFormatMatcher formatMatcher; if (inputFile.isPresent()) { try (FileInputStream fileInputStream = new FileInputStream(inputFile.get())) { formatMatcher = dataFormatDetector.findFormat(fileInputStream); } inputStream = new FileInputStream(inputFile.get()); } else { if (stream.available() == 0) { System.out.println("No data in stream yet and no file specified, waiting for data."); } inputStream = stream.markSupported() ? stream : new BufferedInputStream(stream); inputStream.mark(DataFormatDetector.DEFAULT_MAX_INPUT_LOOKAHEAD); formatMatcher = dataFormatDetector.findFormat(inputStream); inputStream.reset(); } if (addRootElementToXml) { inputStream = addVespafeedTag(inputStream); format = Format.XML; return; } if (formatMatcher.getMatchStrength() == MatchStrength.INCONCLUSIVE || formatMatcher.getMatchStrength() == MatchStrength.NO_MATCH) { throw new IllegalArgumentException("Could not detect input format"); } switch (formatMatcher.getMatchedFormatName().toLowerCase()) { case "json": format = Format.JSON; break; case "xml": format = Format.XML; break; default: throw new IllegalArgumentException("Unknown data format"); } }
public DataFormatReaders(ObjectReader[] paramArrayOfObjectReader) { this(paramArrayOfObjectReader, MatchStrength.SOLID_MATCH, MatchStrength.WEAK_MATCH, 64); }
public DataFormatReaders withMinimalMatch(MatchStrength paramMatchStrength) { if (paramMatchStrength == this._minimalMatch) return this; return new DataFormatReaders(this._readers, this._optimalMatch, paramMatchStrength, this._maxInputLookahead); }
public DataFormatReaders withOptimalMatch(MatchStrength paramMatchStrength) { if (paramMatchStrength == this._optimalMatch) return this; return new DataFormatReaders(this._readers, paramMatchStrength, this._minimalMatch, this._maxInputLookahead); }
public DataFormatReaders.Match createMatcher(ObjectReader paramObjectReader, MatchStrength paramMatchStrength) { return new DataFormatReaders.Match(this._in, this._buffer, this._bufferedStart, this._bufferedEnd - this._bufferedStart, paramObjectReader, paramMatchStrength); }
public MatchStrength getMatchStrength() { if (this._matchStrength == null) return MatchStrength.INCONCLUSIVE; return this._matchStrength; }
public MatchStrength hasFormat(InputAccessor paramInputAccessor) { if (getClass() == MappingJsonFactory.class) return hasJSONFormat(paramInputAccessor); return null; }
public static MatchStrength hasJSONFormat(InputAccessor paramInputAccessor) { if (!paramInputAccessor.hasMoreBytes()) return MatchStrength.INCONCLUSIVE; byte b1 = paramInputAccessor.nextByte(); byte b2 = b1; if (b1 == -17) { if (!paramInputAccessor.hasMoreBytes()) return MatchStrength.INCONCLUSIVE; if (paramInputAccessor.nextByte() != -69) return MatchStrength.NO_MATCH; if (!paramInputAccessor.hasMoreBytes()) return MatchStrength.INCONCLUSIVE; if (paramInputAccessor.nextByte() != -65) return MatchStrength.NO_MATCH; if (!paramInputAccessor.hasMoreBytes()) return MatchStrength.INCONCLUSIVE; b2 = paramInputAccessor.nextByte(); } int i = skipSpace(paramInputAccessor, b2); if (i < 0) return MatchStrength.INCONCLUSIVE; if (i == 123) { int m = skipSpace(paramInputAccessor); if (m < 0) return MatchStrength.INCONCLUSIVE; if ((m == 34) || (m == 125)) return MatchStrength.SOLID_MATCH; return MatchStrength.NO_MATCH; } if (i == 91) { int k = skipSpace(paramInputAccessor); if (k < 0) return MatchStrength.INCONCLUSIVE; if ((k == 93) || (k == 91)) return MatchStrength.SOLID_MATCH; return MatchStrength.SOLID_MATCH; } MatchStrength localMatchStrength = MatchStrength.WEAK_MATCH; if (i == 34) return localMatchStrength; if ((i <= 57) && (i >= 48)) return localMatchStrength; if (i == 45) { int j = skipSpace(paramInputAccessor); if (j < 0) return MatchStrength.INCONCLUSIVE; if ((j <= 57) && (j >= 48)) return localMatchStrength; return MatchStrength.NO_MATCH; } if (i == 110) return tryMatch(paramInputAccessor, "ull", localMatchStrength); if (i == 116) return tryMatch(paramInputAccessor, "rue", localMatchStrength); if (i == 102) return tryMatch(paramInputAccessor, "alse", localMatchStrength); return MatchStrength.NO_MATCH; }
public MatchStrength hasFormat(InputAccessor paramInputAccessor) { if (getClass() == JsonFactory.class) return hasJSONFormat(paramInputAccessor); return null; }
public MatchStrength hasJSONFormat(InputAccessor paramInputAccessor) { return ByteSourceJsonBootstrapper.hasJSONFormat(paramInputAccessor); }
public static MatchStrength hasSmileFormat(InputAccessor acc) throws IOException { // Ok: ideally we start with the header -- if so, we are golden if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } // We always need at least two bytes to determine, so byte b1 = acc.nextByte(); if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } byte b2 = acc.nextByte(); // First: do we see 3 "magic bytes"? If so, we are golden if (b1 == SmileConstants.HEADER_BYTE_1) { // yeah, looks like marker if (b2 != SmileConstants.HEADER_BYTE_2) { return MatchStrength.NO_MATCH; } if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } return (acc.nextByte() == SmileConstants.HEADER_BYTE_3) ? MatchStrength.FULL_MATCH : MatchStrength.NO_MATCH; } // Otherwise: ideally either Object or Array: if (b1 == SmileConstants.TOKEN_LITERAL_START_OBJECT) { /* Object is bit easier, because now we need to get new name; i.e. can * rule out name back-refs */ if (b2 == SmileConstants.TOKEN_KEY_LONG_STRING) { return MatchStrength.SOLID_MATCH; } int ch = (int) b2 & 0xFF; if (ch >= 0x80 && ch < 0xF8) { return MatchStrength.SOLID_MATCH; } return MatchStrength.NO_MATCH; } // Array bit trickier if (b1 == SmileConstants.TOKEN_LITERAL_START_ARRAY) { if (!acc.hasMoreBytes()) { return MatchStrength.INCONCLUSIVE; } /* For arrays, we will actually accept much wider range of values (including * things that could otherwise collide) */ if (likelySmileValue(b2) || possibleSmileValue(b2, true)) { return MatchStrength.SOLID_MATCH; } return MatchStrength.NO_MATCH; } // Scalar values are pretty weak, albeit possible; require more certain match, consider it weak: if (likelySmileValue(b1) || possibleSmileValue(b2, false)) { return MatchStrength.SOLID_MATCH; } return MatchStrength.NO_MATCH; }
/** * Sub-classes need to override this method (as of 1.8) */ @Override public MatchStrength hasFormat(InputAccessor acc) throws IOException { return SmileParserBootstrapper.hasSmileFormat(acc); }
/** * Helper method that can be called to determine if content accessed * using given accessor seems to be JSON content. */ protected MatchStrength hasJSONFormat(InputAccessor acc) throws IOException { return ByteSourceJsonBootstrapper.hasJSONFormat(acc); }