Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.thrift.protocol; import org.apache.thrift.TException; /** * Utility class with static methods for interacting with protocol data * streams. * */ public class TProtocolUtil { /** * The maximum recursive depth the skip() function will traverse before * throwing a TException. */ private static int maxSkipDepth = Integer.MAX_VALUE; /** * Specifies the maximum recursive depth that the skip function will * traverse before throwing a TException. This is a global setting, so * any call to skip in this JVM will enforce this value. * * @param depth the maximum recursive depth. A value of 2 would allow * the skip function to skip a structure or collection with basic children, * but it would not permit skipping a struct that had a field containing * a child struct. A value of 1 would only allow skipping of simple * types and empty structs/collections. */ public static void setMaxSkipDepth(int depth) { maxSkipDepth = depth; } /** * Skips over the next data element from the provided input TProtocol object. * * @param prot the protocol object to read from * @param type the next value will be interpreted as this TType value. */ public static void skip(TProtocol prot, byte type) throws TException { skip(prot, type, maxSkipDepth); } /** * Skips over the next data element from the provided input TProtocol object. * * @param prot the protocol object to read from * @param type the next value will be interpreted as this TType value. * @param maxDepth this function will only skip complex objects to this * recursive depth, to prevent Java stack overflow. */ public static void skip(TProtocol prot, byte type, int maxDepth) throws TException { if (maxDepth <= 0) { throw new TException("Maximum skip depth exceeded"); } switch (type) { case TType.BOOL: prot.readBool(); break; case TType.BYTE: prot.readByte(); break; case TType.I16: prot.readI16(); break; case TType.I32: prot.readI32(); break; case TType.I64: prot.readI64(); break; case TType.DOUBLE: prot.readDouble(); break; case TType.STRING: prot.readBinary(); break; case TType.STRUCT: prot.readStructBegin(); while (true) { TField field = prot.readFieldBegin(); if (field.type == TType.STOP) { break; } skip(prot, field.type, maxDepth - 1); prot.readFieldEnd(); } prot.readStructEnd(); break; case TType.MAP: TMap map = prot.readMapBegin(); for (int i = 0; i < map.size; i++) { skip(prot, map.keyType, maxDepth - 1); skip(prot, map.valueType, maxDepth - 1); } prot.readMapEnd(); break; case TType.SET: TSet set = prot.readSetBegin(); for (int i = 0; i < set.size; i++) { skip(prot, set.elemType, maxDepth - 1); } prot.readSetEnd(); break; case TType.LIST: TList list = prot.readListBegin(); for (int i = 0; i < list.size; i++) { skip(prot, list.elemType, maxDepth - 1); } prot.readListEnd(); break; default: throw new TProtocolException(TProtocolException.INVALID_DATA, "Unrecognized type " + type); } } /** * Attempt to determine the protocol used to serialize some data. * * The guess is based on known specificities of supported protocols. * In some cases, no guess can be done, in that case we return the * fallback TProtocolFactory. * To be certain to correctly detect the protocol, the first encoded * field should have a field id < 256 * * @param data The serialized data to guess the protocol for. * @param fallback The TProtocol to return if no guess can be made. * @return a Class implementing TProtocolFactory which can be used to create a deserializer. */ public static TProtocolFactory guessProtocolFactory(byte[] data, TProtocolFactory fallback) { // // If the first and last bytes are opening/closing curly braces we guess the protocol as // being TJSONProtocol. // It could not be a TCompactBinary encoding for a field of type 0xb (Map) // with delta id 7 as the last byte for TCompactBinary is always 0. // if ('{' == data[0] && '}' == data[data.length - 1]) { return new TJSONProtocol.Factory(); } // // If the last byte is not 0, then it cannot be TCompactProtocol, it must be // TBinaryProtocol. // if (data[data.length - 1] != 0) { return new TBinaryProtocol.Factory(); } // // A first byte of value > 16 indicates TCompactProtocol was used, and the first byte // encodes a delta field id (id <= 15) and a field type. // if (data[0] > 0x10) { return new TCompactProtocol.Factory(); } // // If the second byte is 0 then it is a field id < 256 encoded by TBinaryProtocol. // It cannot possibly be TCompactProtocol since a value of 0 would imply a field id // of 0 as the zig zag varint encoding would end. // if (data.length > 1 && 0 == data[1]) { return new TBinaryProtocol.Factory(); } // // If bit 7 of the first byte of the field id is set then we have two choices: // 1. A field id > 63 was encoded with TCompactProtocol. // 2. A field id > 0x7fff (32767) was encoded with TBinaryProtocol and the last byte of the // serialized data is 0. // Option 2 is impossible since field ids are short and thus limited to 32767. // if (data.length > 1 && (data[1] & 0x80) != 0) { return new TCompactProtocol.Factory(); } // // The remaining case is either a field id <= 63 encoded as TCompactProtocol, // one >= 256 encoded with TBinaryProtocol with a last byte at 0, or an empty structure. // As we cannot really decide, we return the fallback protocol. // return fallback; } }