Java 类com.fasterxml.jackson.core.format.MatchStrength 实例源码

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;
}

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 (!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);
}

/**
 * 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);
}