ridv/gorealis-v2
1
0
Fork 0
Code Issues Pull requests Projects Releases 13 Packages Wiki Activity Actions

Moving from govendor to dep, updated dependencies (#48)

Browse source 
* Moving from govendor to dep.

* Making the pull request template more friendly.

* Fixing akward space in PR template.

* goimports run on whole project using ` goimports -w $(find . -type f -name '*.go' -not -path "./vendor/*" -not -path "./gen-go/*")`

source of command: https://gist.github.com/bgentry/fd1ffef7dbde01857f66
This commit is contained in:
Renan DelValle 2018-01-07 13:13:47 -08:00 • committed by GitHub
parent 9631aa3aab
commit 8d445c1c77
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2186 changed files with 400410 additions and 352 deletions
Download patch file Download diff file Expand all files Collapse all files

1
vendor/git.apache.org/thrift.git/lib/javame/coding_standards.md generated vendored Normal file
View file

@ -0,0 +1 @@
Please follow [General Coding Standards](/doc/coding_standards.md)

132
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TApplicationException.java generated vendored Normal file
View file

@ -0,0 +1,132 @@
/*
* 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;
import org.apache.thrift.protocol.TField;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.protocol.TProtocolUtil;
import org.apache.thrift.protocol.TStruct;
import org.apache.thrift.protocol.TType;
/**
* Application level exception
*
*/
public class TApplicationException extends TException {
private static final long serialVersionUID = 1L;
public static final int UNKNOWN = 0;
public static final int UNKNOWN_METHOD = 1;
public static final int INVALID_MESSAGE_TYPE = 2;
public static final int WRONG_METHOD_NAME = 3;
public static final int BAD_SEQUENCE_ID = 4;
public static final int MISSING_RESULT = 5;
public static final int INTERNAL_ERROR = 6;
public static final int PROTOCOL_ERROR = 7;
public static final int INVALID_TRANSFORM = 8;
public static final int INVALID_PROTOCOL = 9;
public static final int UNSUPPORTED_CLIENT_TYPE = 10;
protected int type_ = UNKNOWN;
public TApplicationException() {
super();
}
public TApplicationException(int type) {
super();
type_ = type;
}
public TApplicationException(int type, String message) {
super(message);
type_ = type;
}
public TApplicationException(String message) {
super(message);
}
public int getType() {
return type_;
}
public static TApplicationException read(TProtocol iprot) throws TException {
TField field;
iprot.readStructBegin();
String message = null;
int type = UNKNOWN;
while (true) {
field = iprot.readFieldBegin();
if (field.type == TType.STOP) {
break;
}
switch (field.id) {
case 1:
if (field.type == TType.STRING) {
message = iprot.readString();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
case 2:
if (field.type == TType.I32) {
type = iprot.readI32();
} else {
TProtocolUtil.skip(iprot, field.type);
}
break;
default:
TProtocolUtil.skip(iprot, field.type);
break;
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
return new TApplicationException(type, message);
}
public void write(TProtocol oprot) throws TException {
TStruct struct = new TStruct("TApplicationException");
TField field = new TField();
oprot.writeStructBegin(struct);
if (getMessage() != null) {
field.name = "message";
field.type = TType.STRING;
field.id = 1;
oprot.writeFieldBegin(field);
oprot.writeString(getMessage());
oprot.writeFieldEnd();
}
field.name = "type";
field.type = TType.I32;
field.id = 2;
oprot.writeFieldBegin(field);
oprot.writeI32(type_);
oprot.writeFieldEnd();
oprot.writeFieldStop();
oprot.writeStructEnd();
}
}

46
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TBase.java generated vendored Normal file
View file

@ -0,0 +1,46 @@
/*
* 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;
import org.apache.thrift.protocol.TProtocol;
/**
* Generic base interface for generated Thrift objects.
*
*/
public interface TBase {
/**
* Reads the TObject from the given input protocol.
*
* @param iprot Input protocol
*/
public void read(TProtocol iprot) throws TException;
/**
* Writes the objects out to the protocol
*
* @param oprot Output protocol
*/
public void write(TProtocol oprot) throws TException;
public int compareTo(Object other);
}

209
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TBaseHelper.java generated vendored Normal file
View file

@ -0,0 +1,209 @@
/*
* 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;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
public class TBaseHelper {
public static int compareTo(boolean a, boolean b) {
return (a == b) ? 0 : (a ? 1 : -1);
}
public static int compareTo(Boolean a, Boolean b) {
return (a.booleanValue() == b.booleanValue()) ? 0 : (a.booleanValue() ? 1 : -1);
}
public static int compareTo(Boolean a, boolean b) {
return (a.booleanValue() == b) ? 0 : (a.booleanValue() ? 1 : -1);
}
public static Boolean booleanValueOf(boolean b) {
return (b ? Boolean.TRUE : Boolean.FALSE);
}
public static int compareTo(byte a, byte b) {
if (a < b) {
return -1;
} else if (b < a) {
return 1;
} else {
return 0;
}
}
public static int compareTo(short a, short b) {
if (a < b) {
return -1;
} else if (b < a) {
return 1;
} else {
return 0;
}
}
public static int compareTo(int a, int b) {
if (a < b) {
return -1;
} else if (b < a) {
return 1;
} else {
return 0;
}
}
public static int compareTo(long a, long b) {
if (a < b) {
return -1;
} else if (b < a) {
return 1;
} else {
return 0;
}
}
public static int compareTo(double a, double b) {
if (a < b) {
return -1;
} else if (b < a) {
return 1;
} else {
return 0;
}
}
public static int compareTo(String a, String b) {
return a.compareTo(b);
}
public static int compareTo(byte[] a, byte[] b) {
int sizeCompare = compareTo(a.length, b.length);
if (sizeCompare != 0) {
return sizeCompare;
}
for (int i = 0; i < a.length; i++) {
int byteCompare = compareTo(a, b);
if (byteCompare != 0) {
return byteCompare;
}
}
return 0;
}
public static int compareTo(Object a, Object b) {
if (a instanceof Vector) {
return compareTo((Vector)a, (Vector)b);
} if (a instanceof Hashtable) {
return compareTo((Hashtable)a, (Hashtable)b);
} else {
return ((TBase)a).compareTo(b);
}
}
public static int compareTo(Vector a, Vector b) {
int lastComparison = compareTo(a.size(), b.size());
if (lastComparison != 0) {
return lastComparison;
}
for (int i = 0; i < a.size(); i++) {
Object oA = a.elementAt(i);
Object oB = b.elementAt(i);
lastComparison = compareTo(oA, oB);
if (lastComparison != 0) {
return lastComparison;
}
}
return 0;
}
public static int compareTo(Hashtable a, Hashtable b) {
int lastComparison = compareTo(a.size(), b.size());
if (lastComparison != 0) {
return lastComparison;
}
Enumeration enumA = a.keys();
Enumeration enumB = b.keys();
while (lastComparison == 0 && enumA.hasMoreElements()) {
Object keyA = enumA.nextElement();
Object keyB = enumB.nextElement();
lastComparison = compareTo(keyA, keyB);
if (lastComparison == 0) {
lastComparison = compareTo(a.get(keyA), b.get(keyB));
}
}
return lastComparison;
}
public static int compareTo(TEnum a, TEnum b) {
return compareTo(a.getValue(), b.getValue());
}
/*
public static int compareTo(List a, List b) {
int lastComparison = compareTo(a.size(), b.size());
if (lastComparison != 0) {
return lastComparison;
}
for (int i = 0; i < a.size(); i++) {
Object oA = a.get(i);
Object oB = b.get(i);
if (oA instanceof List) {
lastComparison = compareTo((List) oA, (List) oB);
} else {
lastComparison = compareTo((Comparable) oA, (Comparable) oB);
}
if (lastComparison != 0) {
return lastComparison;
}
}
return 0;
}
*/
public static void toString(byte[] bytes, StringBuffer sb) {
toString(bytes, 0, bytes.length, sb);
}
public static void toString(byte[] buf, int arrayOffset, int origLimit, StringBuffer sb) {
int limit = (origLimit - arrayOffset > 128) ? arrayOffset + 128 : origLimit;
for (int i = arrayOffset; i < limit; i++) {
if (i > arrayOffset) {
sb.append(" ");
}
sb.append(paddedByteString(buf[i]));
}
if (origLimit != limit) {
sb.append("...");
}
}
public static String paddedByteString(byte b) {
int extended = (b | 0x100) & 0x1ff;
return Integer.toHexString(extended).toUpperCase().substring(1);
}
}

41
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TByteArrayOutputStream.java generated vendored Normal file
View file

@ -0,0 +1,41 @@
/*
* 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;
import java.io.ByteArrayOutputStream;
/**
* Class that allows access to the underlying buf without doing deep
* copies on it.
*
*/
public class TByteArrayOutputStream extends ByteArrayOutputStream {
public TByteArrayOutputStream(int size) {
super(size);
}
public byte[] get() {
return buf;
}
public int len() {
return count;
}
}

95
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TDeserializer.java generated vendored Normal file
View file

@ -0,0 +1,95 @@
/*
* 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;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TIOStreamTransport;
/**
* Generic utility for easily deserializing objects from a byte array or Java
* String.
*
*/
public class TDeserializer {
private final TProtocolFactory protocolFactory_;
/**
* Create a new TDeserializer that uses the TBinaryProtocol by default.
*/
public TDeserializer() {
this(new TBinaryProtocol.Factory());
}
/**
* Create a new TDeserializer. It will use the TProtocol specified by the
* factory that is passed in.
*
* @param protocolFactory Factory to create a protocol
*/
public TDeserializer(TProtocolFactory protocolFactory) {
protocolFactory_ = protocolFactory;
}
/**
* Deserialize the Thrift object from a byte array.
*
* @param base The object to read into
* @param bytes The array to read from
*/
public void deserialize(TBase base, byte[] bytes) throws TException {
base.read(
protocolFactory_.getProtocol(
new TIOStreamTransport(
new ByteArrayInputStream(bytes))));
}
/**
* Deserialize the Thrift object from a Java string, using a specified
* character set for decoding.
*
* @param base The object to read into
* @param data The string to read from
* @param charset Valid JVM charset
*/
public void deserialize(TBase base, String data, String charset) throws TException {
try {
deserialize(base, data.getBytes(charset));
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT ENCODING: " + charset);
}
}
/**
* Deerialize the Thrift object from a Java string, using the default JVM
* charset encoding.
*
* @param base The object to read into
* @param data The string to read from
* @return Serialized object as a String
*/
public void toString(TBase base, String data) throws TException {
deserialize(base, data.getBytes());
}
}

24
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TEnum.java generated vendored Normal file
View file

@ -0,0 +1,24 @@
/*
* 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;
public interface TEnum {
public int getValue();
}

45
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TException.java generated vendored Normal file
View file

@ -0,0 +1,45 @@
/*
* 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;
/**
* Generic exception class for Thrift.
*
*/
public class TException extends Exception {
private static final long serialVersionUID = 1L;
public TException() {
super();
}
public TException(String message) {
super(message);
}
public TException(Throwable cause) {
super(cause.getMessage());
}
public TException(String message, Throwable cause) {
super(message);
}
}

48
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TFieldRequirementType.java generated vendored Normal file
View file

@ -0,0 +1,48 @@
/*
* 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.
*/
/*
* 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;
/**
* Requirement type constants.
*
*/
public final class TFieldRequirementType {
public static final byte REQUIRED = 1;
public static final byte OPTIONAL = 2;
public static final byte DEFAULT = 3;
}

32
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TProcessor.java generated vendored Normal file
View file

@ -0,0 +1,32 @@
/*
* 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;
import org.apache.thrift.protocol.TProtocol;
/**
* A processor is a generic object which operates upon an input stream and
* writes to some output stream.
*
*/
public interface TProcessor {
public boolean process(TProtocol in, TProtocol out)
throws TException;
}

39
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TProcessorFactory.java generated vendored Normal file
View file

@ -0,0 +1,39 @@
/*
* 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;
import org.apache.thrift.transport.TTransport;
/**
* The default processor factory just returns a singleton
* instance.
*/
public class TProcessorFactory {
private final TProcessor processor_;
public TProcessorFactory(TProcessor processor) {
processor_ = processor;
}
public TProcessor getProcessor(TTransport trans) {
return processor_;
}
}

110
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TSerializer.java generated vendored Normal file
View file

@ -0,0 +1,110 @@
/*
* 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;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TIOStreamTransport;
/**
* Generic utility for easily serializing objects into a byte array or Java
* String.
*
*/
public class TSerializer {
/**
* This is the byte array that data is actually serialized into
*/
private final ByteArrayOutputStream baos_ = new ByteArrayOutputStream();
/**
* This transport wraps that byte array
*/
private final TIOStreamTransport transport_ = new TIOStreamTransport(baos_);
/**
* Internal protocol used for serializing objects.
*/
private TProtocol protocol_;
/**
* Create a new TSerializer that uses the TBinaryProtocol by default.
*/
public TSerializer() {
this(new TBinaryProtocol.Factory());
}
/**
* Create a new TSerializer. It will use the TProtocol specified by the
* factory that is passed in.
*
* @param protocolFactory Factory to create a protocol
*/
public TSerializer(TProtocolFactory protocolFactory) {
protocol_ = protocolFactory.getProtocol(transport_);
}
/**
* Serialize the Thrift object into a byte array. The process is simple,
* just clear the byte array output, write the object into it, and grab the
* raw bytes.
*
* @param base The object to serialize
* @return Serialized object in byte[] format
*/
public byte[] serialize(TBase base) throws TException {
baos_.reset();
base.write(protocol_);
return baos_.toByteArray();
}
/**
* Serialize the Thrift object into a Java string, using a specified
* character set for encoding.
*
* @param base The object to serialize
* @param charset Valid JVM charset
* @return Serialized object as a String
*/
public String toString(TBase base, String charset) throws TException {
try {
return new String(serialize(base), charset);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT ENCODING: " + charset);
}
}
/**
* Serialize the Thrift object into a Java string, using the default JVM
* charset encoding.
*
* @param base The object to serialize
* @return Serialized object as a String
*/
public String toString(TBase base) throws TException {
return new String(serialize(base));
}
}

39
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/TServiceClient.java generated vendored Normal file
View file

@ -0,0 +1,39 @@
/*
* 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;
import org.apache.thrift.protocol.TProtocol;
/**
* A TServiceClient is used to communicate with a TService implementation
* across protocols and transports.
*/
public interface TServiceClient {
/**
* Get the TProtocol being used as the input (read) protocol.
* @return
*/
public TProtocol getInputProtocol();
/**
* Get the TProtocol being used as the output (write) protocol.
* @return
*/
public TProtocol getOutputProtocol();
}

88
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/FieldMetaData.java generated vendored Normal file
View file

@ -0,0 +1,88 @@
/*
* 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.
*/
/*
* 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.meta_data;
import org.apache.thrift.TBase;
import java.util.Hashtable;
/**
* This class is used to store meta data about thrift fields. Every field in a
* a struct should have a corresponding instance of this class describing it.
*
*/
public class FieldMetaData {
public final String fieldName;
public final byte requirementType;
public final FieldValueMetaData valueMetaData;
private static Hashtable structMap;
static {
structMap = new Hashtable();
}
public FieldMetaData(String name, byte req, FieldValueMetaData vMetaData){
this.fieldName = name;
this.requirementType = req;
this.valueMetaData = vMetaData;
}
public static synchronized void addStructMetaDataMap(Class sClass, Hashtable map){
structMap.put(sClass, map);
}
/**
* Returns a map with metadata (i.e. instances of FieldMetaData) that
* describe the fields of the given class.
*
* @param sClass The TBase class for which the metadata map is requested
*/
public static synchronized Hashtable getStructMetaDataMap(Class sClass){
if (!structMap.containsKey(sClass)){ // Load class if it hasn't been loaded
try{
sClass.newInstance();
} catch (InstantiationException e){
throw new RuntimeException("InstantiationException for TBase class: " + sClass.getName() + ", message: " + e.getMessage());
} catch (IllegalAccessException e){
throw new RuntimeException("IllegalAccessException for TBase class: " + sClass.getName() + ", message: " + e.getMessage());
}
}
return (Hashtable) structMap.get(sClass);
}
}

61
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/FieldValueMetaData.java generated vendored Normal file
View file

@ -0,0 +1,61 @@
/*
* 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.
*/
/*
* 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.meta_data;
import org.apache.thrift.protocol.TType;
/**
* FieldValueMetaData and collection of subclasses to store metadata about
* the value(s) of a field
*/
public class FieldValueMetaData {
public final byte type;
public FieldValueMetaData(byte type){
this.type = type;
}
public boolean isStruct() {
return type == TType.STRUCT;
}
public boolean isContainer() {
return type == TType.LIST || type == TType.MAP || type == TType.SET;
}
}

49
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/ListMetaData.java generated vendored Normal file
View file

@ -0,0 +1,49 @@
/*
* 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.
*/
/*
* 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.meta_data;
import org.apache.thrift.meta_data.FieldValueMetaData;
public class ListMetaData extends FieldValueMetaData {
public final FieldValueMetaData elemMetaData;
public ListMetaData(byte type, FieldValueMetaData eMetaData){
super(type);
this.elemMetaData = eMetaData;
}
}

51
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/MapMetaData.java generated vendored Normal file
View file

@ -0,0 +1,51 @@
/*
* 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.
*/
/*
* 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.meta_data;
import org.apache.thrift.meta_data.FieldValueMetaData;
public class MapMetaData extends FieldValueMetaData {
public final FieldValueMetaData keyMetaData;
public final FieldValueMetaData valueMetaData;
public MapMetaData(byte type, FieldValueMetaData kMetaData, FieldValueMetaData vMetaData){
super(type);
this.keyMetaData = kMetaData;
this.valueMetaData = vMetaData;
}
}

47
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/SetMetaData.java generated vendored Normal file
View file

@ -0,0 +1,47 @@
/*
* 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.
*/
/*
* 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.meta_data;
public class SetMetaData extends FieldValueMetaData {
public final FieldValueMetaData elemMetaData;
public SetMetaData(byte type, FieldValueMetaData eMetaData){
super(type);
this.elemMetaData = eMetaData;
}
}

51
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/meta_data/StructMetaData.java generated vendored Normal file
View file

@ -0,0 +1,51 @@
/*
* 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.
*/
/*
* 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.meta_data;
import org.apache.thrift.TBase;
import org.apache.thrift.meta_data.FieldValueMetaData;
public class StructMetaData extends FieldValueMetaData {
public final Class structClass;
public StructMetaData(byte type, Class sClass){
super(type);
this.structClass = sClass;
}
}

127
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TBase64Utils.java generated vendored Normal file
View file

@ -0,0 +1,127 @@
/*
* 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;
/**
* Class for encoding and decoding Base64 data.
*
* This class is kept at package level because the interface does no input
* validation and is therefore too low-level for generalized reuse.
*
* Note also that the encoding does not pad with equal signs , as discussed in
* section 2.2 of the RFC (http://www.faqs.org/rfcs/rfc3548.html). Furthermore,
* bad data encountered when decoding is neither rejected or ignored but simply
* results in bad decoded data -- this is not in compliance with the RFC but is
* done in the interest of performance.
*
*/
class TBase64Utils {
private static final String ENCODE_TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* Encode len bytes of data in src at offset srcOff, storing the result into
* dst at offset dstOff. len must be 1, 2, or 3. dst must have at least len+1
* bytes of space at dstOff. src and dst should not be the same object. This
* method does no validation of the input values in the interest of
* performance.
*
* @param src the source of bytes to encode
* @param srcOff the offset into the source to read the unencoded bytes
* @param len the number of bytes to encode (must be 1, 2, or 3).
* @param dst the destination for the encoding
* @param dstOff the offset into the destination to place the encoded bytes
*/
static final void encode(byte[] src, int srcOff, int len, byte[] dst,
int dstOff) {
dst[dstOff] = (byte)ENCODE_TABLE.charAt((src[srcOff] >> 2) & 0x3F);
if (len == 3) {
dst[dstOff + 1] =
(byte)ENCODE_TABLE.charAt(
((src[srcOff] << 4) & 0x30) | ((src[srcOff+1] >> 4) & 0x0F));
dst[dstOff + 2] =
(byte)ENCODE_TABLE.charAt(
((src[srcOff+1] << 2) & 0x3C) | ((src[srcOff+2] >> 6) & 0x03));
dst[dstOff + 3] =
(byte)ENCODE_TABLE.charAt(src[srcOff+2] & 0x3F);
}
else if (len == 2) {
dst[dstOff+1] =
(byte)ENCODE_TABLE.charAt(
((src[srcOff] << 4) & 0x30) | ((src[srcOff+1] >> 4) & 0x0F));
dst[dstOff + 2] =
(byte)ENCODE_TABLE.charAt((src[srcOff+1] << 2) & 0x3C);
}
else { // len == 1) {
dst[dstOff + 1] =
(byte)ENCODE_TABLE.charAt((src[srcOff] << 4) & 0x30);
}
}
private static final byte[] DECODE_TABLE = {
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
};
/**
* Decode len bytes of data in src at offset srcOff, storing the result into
* dst at offset dstOff. len must be 2, 3, or 4. dst must have at least len-1
* bytes of space at dstOff. src and dst may be the same object as long as
* dstoff <= srcOff. This method does no validation of the input values in
* the interest of performance.
*
* @param src the source of bytes to decode
* @param srcOff the offset into the source to read the encoded bytes
* @param len the number of bytes to decode (must be 2, 3, or 4)
* @param dst the destination for the decoding
* @param dstOff the offset into the destination to place the decoded bytes
*/
static final void decode(byte[] src, int srcOff, int len, byte[] dst,
int dstOff) {
dst[dstOff] = (byte)
((DECODE_TABLE[src[srcOff] & 0x0FF] << 2) |
(DECODE_TABLE[src[srcOff+1] & 0x0FF] >> 4));
if (len > 2) {
dst[dstOff+1] = (byte)
(((DECODE_TABLE[src[srcOff+1] & 0x0FF] << 4) & 0xF0) |
(DECODE_TABLE[src[srcOff+2] & 0x0FF] >> 2));
if (len > 3) {
dst[dstOff+2] = (byte)
(((DECODE_TABLE[src[srcOff+2] & 0x0FF] << 6) & 0xC0) |
DECODE_TABLE[src[srcOff+3] & 0x0FF]);
}
}
}
}

329
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TBinaryProtocol.java generated vendored Normal file
View file

@ -0,0 +1,329 @@
/*
* 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 java.io.UnsupportedEncodingException;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransport;
/**
* Binary protocol implementation for thrift.
*
*/
public class TBinaryProtocol extends TProtocol {
protected static final int VERSION_MASK = 0xffff0000;
protected static final int VERSION_1 = 0x80010000;
protected boolean strictRead_ = false;
protected boolean strictWrite_ = true;
/**
* Factory
*/
public static class Factory implements TProtocolFactory {
protected boolean strictRead_ = false;
protected boolean strictWrite_ = true;
public Factory() {
this(false, true);
}
public Factory(boolean strictRead, boolean strictWrite) {
strictRead_ = strictRead;
strictWrite_ = strictWrite;
}
public TProtocol getProtocol(TTransport trans) {
return new TBinaryProtocol(trans, strictRead_, strictWrite_);
}
}
/**
* Constructor
*/
public TBinaryProtocol(TTransport trans) {
this(trans, false, true);
}
public TBinaryProtocol(TTransport trans, boolean strictRead, boolean strictWrite) {
super(trans);
strictRead_ = strictRead;
strictWrite_ = strictWrite;
}
public void writeMessageBegin(TMessage message) throws TException {
if (strictWrite_) {
int version = VERSION_1 | message.type;
writeI32(version);
writeString(message.name);
writeI32(message.seqid);
} else {
writeString(message.name);
writeByte(message.type);
writeI32(message.seqid);
}
}
public void writeMessageEnd() {}
public void writeStructBegin(TStruct struct) {}
public void writeStructEnd() {}
public void writeFieldBegin(TField field) throws TException {
writeByte(field.type);
writeI16(field.id);
}
public void writeFieldEnd() {}
public void writeFieldStop() throws TException {
writeByte(TType.STOP);
}
public void writeMapBegin(TMap map) throws TException {
writeByte(map.keyType);
writeByte(map.valueType);
writeI32(map.size);
}
public void writeMapEnd() {}
public void writeListBegin(TList list) throws TException {
writeByte(list.elemType);
writeI32(list.size);
}
public void writeListEnd() {}
public void writeSetBegin(TSet set) throws TException {
writeByte(set.elemType);
writeI32(set.size);
}
public void writeSetEnd() {}
public void writeBool(boolean b) throws TException {
writeByte(b ? (byte)1 : (byte)0);
}
private byte [] bout = new byte[1];
public void writeByte(byte b) throws TException {
bout[0] = b;
trans_.write(bout, 0, 1);
}
private byte[] i16out = new byte[2];
public void writeI16(short i16) throws TException {
i16out[0] = (byte)(0xff & (i16 >> 8));
i16out[1] = (byte)(0xff & (i16));
trans_.write(i16out, 0, 2);
}
private byte[] i32out = new byte[4];
public void writeI32(int i32) throws TException {
i32out[0] = (byte)(0xff & (i32 >> 24));
i32out[1] = (byte)(0xff & (i32 >> 16));
i32out[2] = (byte)(0xff & (i32 >> 8));
i32out[3] = (byte)(0xff & (i32));
trans_.write(i32out, 0, 4);
}
private byte[] i64out = new byte[8];
public void writeI64(long i64) throws TException {
i64out[0] = (byte)(0xff & (i64 >> 56));
i64out[1] = (byte)(0xff & (i64 >> 48));
i64out[2] = (byte)(0xff & (i64 >> 40));
i64out[3] = (byte)(0xff & (i64 >> 32));
i64out[4] = (byte)(0xff & (i64 >> 24));
i64out[5] = (byte)(0xff & (i64 >> 16));
i64out[6] = (byte)(0xff & (i64 >> 8));
i64out[7] = (byte)(0xff & (i64));
trans_.write(i64out, 0, 8);
}
public void writeDouble(double dub) throws TException {
writeI64(Double.doubleToLongBits(dub));
}
public void writeString(String str) throws TException {
try {
byte[] dat = str.getBytes("UTF-8");
writeI32(dat.length);
trans_.write(dat, 0, dat.length);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
}
public void writeBinary(byte[] bin) throws TException {
writeI32(bin.length);
trans_.write(bin, 0, bin.length);
}
/**
* Reading methods.
*/
public TMessage readMessageBegin() throws TException {
TMessage message = new TMessage();
int size = readI32();
if (size < 0) {
int version = size & VERSION_MASK;
if (version != VERSION_1) {
throw new TProtocolException(TProtocolException.BAD_VERSION, "Bad version in readMessageBegin");
}
message.type = (byte)(size & 0x000000ff);
message.name = readString();
message.seqid = readI32();
} else {
if (strictRead_) {
throw new TProtocolException(TProtocolException.BAD_VERSION, "Missing version in readMessageBegin, old client?");
}
message.name = readStringBody(size);
message.type = readByte();
message.seqid = readI32();
}
return message;
}
public void readMessageEnd() {}
public TStruct readStructBegin() {
return new TStruct();
}
public void readStructEnd() {}
public TField readFieldBegin() throws TException {
TField field = new TField();
field.type = readByte();
if (field.type != TType.STOP) {
field.id = readI16();
}
return field;
}
public void readFieldEnd() {}
public TMap readMapBegin() throws TException {
TMap map = new TMap();
map.keyType = readByte();
map.valueType = readByte();
map.size = readI32();
return map;
}
public void readMapEnd() {}
public TList readListBegin() throws TException {
TList list = new TList();
list.elemType = readByte();
list.size = readI32();
return list;
}
public void readListEnd() {}
public TSet readSetBegin() throws TException {
TSet set = new TSet();
set.elemType = readByte();
set.size = readI32();
return set;
}
public void readSetEnd() {}
public boolean readBool() throws TException {
return (readByte() == 1);
}
private byte[] bin = new byte[1];
public byte readByte() throws TException {
readAll(bin, 0, 1);
return bin[0];
}
private byte[] i16rd = new byte[2];
public short readI16() throws TException {
readAll(i16rd, 0, 2);
return
(short)
(((i16rd[0] & 0xff) << 8) |
((i16rd[1] & 0xff)));
}
private byte[] i32rd = new byte[4];
public int readI32() throws TException {
readAll(i32rd, 0, 4);
return
((i32rd[0] & 0xff) << 24) |
((i32rd[1] & 0xff) << 16) |
((i32rd[2] & 0xff) << 8) |
((i32rd[3] & 0xff));
}
private byte[] i64rd = new byte[8];
public long readI64() throws TException {
readAll(i64rd, 0, 8);
return
((long)(i64rd[0] & 0xff) << 56) |
((long)(i64rd[1] & 0xff) << 48) |
((long)(i64rd[2] & 0xff) << 40) |
((long)(i64rd[3] & 0xff) << 32) |
((long)(i64rd[4] & 0xff) << 24) |
((long)(i64rd[5] & 0xff) << 16) |
((long)(i64rd[6] & 0xff) << 8) |
((long)(i64rd[7] & 0xff));
}
public double readDouble() throws TException {
return Double.longBitsToDouble(readI64());
}
public String readString() throws TException {
int size = readI32();
return readStringBody(size);
}
public String readStringBody(int size) throws TException {
try {
byte[] buf = new byte[size];
trans_.readAll(buf, 0, size);
return new String(buf, "UTF-8");
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
}
public byte[] readBinary() throws TException {
int size = readI32();
byte[] buf = new byte[size];
trans_.readAll(buf, 0, size);
return buf;
}
private int readAll(byte[] buf, int off, int len) throws TException {
return trans_.readAll(buf, off, len);
}
}

38
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TField.java generated vendored Normal file
View file

@ -0,0 +1,38 @@
/*
* 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;
/**
* Helper class that encapsulates field metadata.
*
*/
public class TField {
public TField() {}
public TField(String n, byte t, short i) {
name = n;
type = t;
id = i;
}
public String name = "";
public byte type = TType.STOP;
public short id = 0;
}

973
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TJSONProtocol.java generated vendored Normal file
View file

@ -0,0 +1,973 @@
/*
* 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 java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Stack;
import org.apache.thrift.TByteArrayOutputStream;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransport;
/**
* JSON protocol implementation for thrift.
* This is a full-featured protocol supporting write and read.
* Please see the C++ class header for a detailed description of the
* protocol's wire format.
*/
public class TJSONProtocol extends TProtocol {
/**
* Factory for JSON protocol objects
*/
public static class Factory implements TProtocolFactory {
public TProtocol getProtocol(TTransport trans) {
return new TJSONProtocol(trans);
}
}
private static final byte[] COMMA = new byte[] { ',' };
private static final byte[] COLON = new byte[] { ':' };
private static final byte[] LBRACE = new byte[] { '{' };
private static final byte[] RBRACE = new byte[] { '}' };
private static final byte[] LBRACKET = new byte[] { '[' };
private static final byte[] RBRACKET = new byte[] { ']' };
private static final byte[] QUOTE = new byte[] { '"' };
private static final byte[] BACKSLASH = new byte[] { '\\' };
private static final byte[] ZERO = new byte[] { '0' };
private static final byte[] ESCSEQ = new byte[] { '\\', 'u', '0', '0' };
private static final long VERSION = 1;
private static final byte[] JSON_CHAR_TABLE = {
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, // 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
1, 1, '"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
};
private static final String ESCAPE_CHARS = "\"\\/bfnrt";
private static final byte[] ESCAPE_CHAR_VALS = {
'"', '\\', '/', '\b', '\f', '\n', '\r', '\t',
};
private static final int DEF_STRING_SIZE = 16;
private static final byte[] NAME_BOOL = new byte[] { 't', 'f' };
private static final byte[] NAME_BYTE = new byte[] { 'i', '8' };
private static final byte[] NAME_I16 = new byte[] { 'i', '1', '6' };
private static final byte[] NAME_I32 = new byte[] { 'i', '3', '2' };
private static final byte[] NAME_I64 = new byte[] { 'i', '6', '4' };
private static final byte[] NAME_DOUBLE = new byte[] { 'd', 'b', 'l' };
private static final byte[] NAME_STRUCT = new byte[] { 'r', 'e', 'c' };
private static final byte[] NAME_STRING = new byte[] { 's', 't', 'r' };
private static final byte[] NAME_MAP = new byte[] { 'm', 'a', 'p' };
private static final byte[] NAME_LIST = new byte[] { 'l', 's', 't' };
private static final byte[] NAME_SET = new byte[] { 's', 'e', 't' };
private static final TStruct ANONYMOUS_STRUCT = new TStruct();
private static final byte[] getTypeNameForTypeID(byte typeID)
throws TException {
switch (typeID) {
case TType.BOOL:
return NAME_BOOL;
case TType.BYTE:
return NAME_BYTE;
case TType.I16:
return NAME_I16;
case TType.I32:
return NAME_I32;
case TType.I64:
return NAME_I64;
case TType.DOUBLE:
return NAME_DOUBLE;
case TType.STRING:
return NAME_STRING;
case TType.STRUCT:
return NAME_STRUCT;
case TType.MAP:
return NAME_MAP;
case TType.SET:
return NAME_SET;
case TType.LIST:
return NAME_LIST;
default:
throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED,
"Unrecognized type");
}
}
private static final byte getTypeIDForTypeName(byte[] name)
throws TException {
byte result = TType.STOP;
if (name.length > 1) {
switch (name[0]) {
case 'd':
result = TType.DOUBLE;
break;
case 'i':
switch (name[1]) {
case '8':
result = TType.BYTE;
break;
case '1':
result = TType.I16;
break;
case '3':
result = TType.I32;
break;
case '6':
result = TType.I64;
break;
}
break;
case 'l':
result = TType.LIST;
break;
case 'm':
result = TType.MAP;
break;
case 'r':
result = TType.STRUCT;
break;
case 's':
if (name[1] == 't') {
result = TType.STRING;
}
else if (name[1] == 'e') {
result = TType.SET;
}
break;
case 't':
result = TType.BOOL;
break;
}
}
if (result == TType.STOP) {
throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED,
"Unrecognized type");
}
return result;
}
// Base class for tracking JSON contexts that may require inserting/reading
// additional JSON syntax characters
// This base context does nothing.
protected class JSONBaseContext {
/**
* @throws TException
*/
protected void write() throws TException {}
/**
* @throws TException
*/
protected void read() throws TException {}
protected boolean escapeNum() {
return false;
}
}
// Context for JSON lists. Will insert/read commas before each item except
// for the first one
protected class JSONListContext extends JSONBaseContext {
private boolean first_ = true;
protected void write() throws TException {
if (first_) {
first_ = false;
} else {
trans_.write(COMMA);
}
}
protected void read() throws TException {
if (first_) {
first_ = false;
} else {
readJSONSyntaxChar(COMMA);
}
}
}
// Context for JSON records. Will insert/read colons before the value portion
// of each record pair, and commas before each key except the first. In
// addition, will indicate that numbers in the key position need to be
// escaped in quotes (since JSON keys must be strings).
protected class JSONPairContext extends JSONBaseContext {
private boolean first_ = true;
private boolean colon_ = true;
protected void write() throws TException {
if (first_) {
first_ = false;
colon_ = true;
} else {
trans_.write(colon_ ? COLON : COMMA);
colon_ = !colon_;
}
}
protected void read() throws TException {
if (first_) {
first_ = false;
colon_ = true;
} else {
readJSONSyntaxChar(colon_ ? COLON : COMMA);
colon_ = !colon_;
}
}
protected boolean escapeNum() {
return colon_;
}
}
// Holds up to one byte from the transport
protected class LookaheadReader {
private boolean hasData_;
private byte[] data_ = new byte[1];
// Return and consume the next byte to be read, either taking it from the
// data buffer if present or getting it from the transport otherwise.
protected byte read() throws TException {
if (hasData_) {
hasData_ = false;
}
else {
trans_.readAll(data_, 0, 1);
}
return data_[0];
}
// Return the next byte to be read without consuming, filling the data
// buffer if it has not been filled already.
protected byte peek() throws TException {
if (!hasData_) {
trans_.readAll(data_, 0, 1);
}
hasData_ = true;
return data_[0];
}
}
// Stack of nested contexts of type JSONBaseContext that we may be in
private Stack contextStack_ = new Stack();
// Current context that we are in
private JSONBaseContext context_ = new JSONBaseContext();
// Reader that manages a 1-byte buffer
private LookaheadReader reader_ = new LookaheadReader();
// Push a new JSON context onto the stack.
private void pushContext(JSONBaseContext c) {
contextStack_.push(context_);
context_ = c;
}
// Pop the last JSON context off the stack
private void popContext() {
context_ = (JSONBaseContext)contextStack_.pop();
}
/**
* Constructor
*/
public TJSONProtocol(TTransport trans) {
super(trans);
}
public void reset() {
contextStack_.clear();
context_ = new JSONBaseContext();
reader_ = new LookaheadReader();
}
// Temporary buffer used by several methods
private byte[] tmpbuf_ = new byte[4];
// Read a byte that must match b[0]; otherwise an exception is thrown.
// Marked protected to avoid synthetic accessor in JSONListContext.read
// and JSONPairContext.read
protected void readJSONSyntaxChar(byte[] b) throws TException {
byte ch = reader_.read();
if (ch != b[0]) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Unexpected character:" + (char)ch);
}
}
// Convert a byte containing a hex char ('0'-'9' or 'a'-'f') into its
// corresponding hex value
private static final byte hexVal(byte ch) throws TException {
if ((ch >= '0') && (ch <= '9')) {
return (byte)((char)ch - '0');
}
else if ((ch >= 'a') && (ch <= 'f')) {
return (byte)((char)ch - 'a' + 10);
}
else {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Expected hex character");
}
}
// Convert a byte containing a hex value to its corresponding hex character
private static final byte hexChar(byte val) {
val &= 0x0F;
if (val < 10) {
return (byte)((char)val + '0');
}
else {
return (byte)((char)(val - 10) + 'a');
}
}
private static boolean isHighSurrogate(char c) {
return c >= '\uD800' && c <= '\uDBFF';
}
private static boolean isLowSurrogate(char c) {
return c >= '\uDC00' && c <= '\uDFFF';
}
private static byte[] toUTF8(int codepoint) {
final int[] FIRST_BYTE_MASK = { 0, 0xc0, 0xe0, 0xf0 };
int length = 0;
if (codepoint <= 0x7f) length = 1;
else if (codepoint <= 0x7ff) length = 2;
else if (codepoint <= 0xffff) length = 3;
else if (codepoint <= 0x1fffff) length = 4;
else throw new RuntimeException("Code point over U+1FFFFF is not supported");
byte[] bytes = new byte[length];
switch (length) {
case 4:
bytes[3] = (byte)((codepoint & 0x3f) | 0x80);
codepoint >>= 6;
case 3:
bytes[2] = (byte)((codepoint & 0x3f) | 0x80);
codepoint >>= 6;
case 2:
bytes[1] = (byte)((codepoint & 0x3f) | 0x80);
codepoint >>= 6;
case 1:
bytes[0] = (byte)(codepoint | FIRST_BYTE_MASK[length - 1]);
}
return bytes;
}
private static byte[] toUTF8(int high, int low) {
int codepoint = (1 << 16) + ((high & 0x3ff) << 10);
codepoint += low & 0x3ff;
return toUTF8(codepoint);
}
// Write the bytes in array buf as a JSON characters, escaping as needed
private void writeJSONString(byte[] b) throws TException {
context_.write();
trans_.write(QUOTE);
int len = b.length;
for (int i = 0; i < len; i++) {
if ((b[i] & 0x00FF) >= 0x30) {
if (b[i] == BACKSLASH[0]) {
trans_.write(BACKSLASH);
trans_.write(BACKSLASH);
}
else {
trans_.write(b, i, 1);
}
}
else {
tmpbuf_[0] = JSON_CHAR_TABLE[b[i]];
if (tmpbuf_[0] == 1) {
trans_.write(b, i, 1);
}
else if (tmpbuf_[0] > 1) {
trans_.write(BACKSLASH);
trans_.write(tmpbuf_, 0, 1);
}
else {
trans_.write(ESCSEQ);
tmpbuf_[0] = hexChar((byte)(b[i] >> 4));
tmpbuf_[1] = hexChar(b[i]);
trans_.write(tmpbuf_, 0, 2);
}
}
}
trans_.write(QUOTE);
}
// Write out number as a JSON value. If the context dictates so, it will be
// wrapped in quotes to output as a JSON string.
private void writeJSONInteger(long num) throws TException {
context_.write();
String str = Long.toString(num);
boolean escapeNum = context_.escapeNum();
if (escapeNum) {
trans_.write(QUOTE);
}
try {
byte[] buf = str.getBytes("UTF-8");
trans_.write(buf);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
if (escapeNum) {
trans_.write(QUOTE);
}
}
// Write out a double as a JSON value. If it is NaN or infinity or if the
// context dictates escaping, write out as JSON string.
private void writeJSONDouble(double num) throws TException {
context_.write();
String str = Double.toString(num);
boolean special = false;
switch (str.charAt(0)) {
case 'N': // NaN
case 'I': // Infinity
special = true;
break;
case '-':
if (str.charAt(1) == 'I') { // -Infinity
special = true;
}
break;
}
boolean escapeNum = special || context_.escapeNum();
if (escapeNum) {
trans_.write(QUOTE);
}
try {
byte[] b = str.getBytes("UTF-8");
trans_.write(b, 0, b.length);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
if (escapeNum) {
trans_.write(QUOTE);
}
}
// Write out contents of byte array b as a JSON string with base-64 encoded
// data
private void writeJSONBase64(byte[] b, int offset, int length) throws TException {
context_.write();
trans_.write(QUOTE);
int len = length;
int off = offset;
while (len >= 3) {
// Encode 3 bytes at a time
TBase64Utils.encode(b, off, 3, tmpbuf_, 0);
trans_.write(tmpbuf_, 0, 4);
off += 3;
len -= 3;
}
if (len > 0) {
// Encode remainder
TBase64Utils.encode(b, off, len, tmpbuf_, 0);
trans_.write(tmpbuf_, 0, len + 1);
}
trans_.write(QUOTE);
}
private void writeJSONObjectStart() throws TException {
context_.write();
trans_.write(LBRACE);
pushContext(new JSONPairContext());
}
private void writeJSONObjectEnd() throws TException {
popContext();
trans_.write(RBRACE);
}
private void writeJSONArrayStart() throws TException {
context_.write();
trans_.write(LBRACKET);
pushContext(new JSONListContext());
}
private void writeJSONArrayEnd() throws TException {
popContext();
trans_.write(RBRACKET);
}
public void writeMessageBegin(TMessage message) throws TException {
writeJSONArrayStart();
writeJSONInteger(VERSION);
try {
byte[] b = message.name.getBytes("UTF-8");
writeJSONString(b);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
writeJSONInteger(message.type);
writeJSONInteger(message.seqid);
}
public void writeMessageEnd() throws TException {
writeJSONArrayEnd();
}
public void writeStructBegin(TStruct struct) throws TException {
writeJSONObjectStart();
}
public void writeStructEnd() throws TException {
writeJSONObjectEnd();
}
public void writeFieldBegin(TField field) throws TException {
writeJSONInteger(field.id);
writeJSONObjectStart();
writeJSONString(getTypeNameForTypeID(field.type));
}
public void writeFieldEnd() throws TException {
writeJSONObjectEnd();
}
public void writeFieldStop() {}
public void writeMapBegin(TMap map) throws TException {
writeJSONArrayStart();
writeJSONString(getTypeNameForTypeID(map.keyType));
writeJSONString(getTypeNameForTypeID(map.valueType));
writeJSONInteger(map.size);
writeJSONObjectStart();
}
public void writeMapEnd() throws TException {
writeJSONObjectEnd();
writeJSONArrayEnd();
}
public void writeListBegin(TList list) throws TException {
writeJSONArrayStart();
writeJSONString(getTypeNameForTypeID(list.elemType));
writeJSONInteger(list.size);
}
public void writeListEnd() throws TException {
writeJSONArrayEnd();
}
public void writeSetBegin(TSet set) throws TException {
writeJSONArrayStart();
writeJSONString(getTypeNameForTypeID(set.elemType));
writeJSONInteger(set.size);
}
public void writeSetEnd() throws TException {
writeJSONArrayEnd();
}
public void writeBool(boolean b) throws TException {
writeJSONInteger(b ? (long)1 : (long)0);
}
public void writeByte(byte b) throws TException {
writeJSONInteger(b);
}
public void writeI16(short i16) throws TException {
writeJSONInteger(i16);
}
public void writeI32(int i32) throws TException {
writeJSONInteger(i32);
}
public void writeI64(long i64) throws TException {
writeJSONInteger(i64);
}
public void writeDouble(double dub) throws TException {
writeJSONDouble(dub);
}
public void writeString(String str) throws TException {
try {
byte[] b = str.getBytes("UTF-8");
writeJSONString(b);
} catch (UnsupportedEncodingException uex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
}
public void writeBinary(byte[] bin) throws TException {
writeJSONBase64(bin, 0, bin.length);
}
/**
* Reading methods.
*/
// Read in a JSON string, unescaping as appropriate.. Skip reading from the
// context if skipContext is true.
private TByteArrayOutputStream readJSONString(boolean skipContext)
throws TException {
TByteArrayOutputStream arr = new TByteArrayOutputStream(DEF_STRING_SIZE);
int highSurrogate = 0;
if (!skipContext) {
context_.read();
}
readJSONSyntaxChar(QUOTE);
while (true) {
byte ch = reader_.read();
if (ch == QUOTE[0]) {
break;
}
if (ch == ESCSEQ[0]) {
ch = reader_.read();
if (ch == ESCSEQ[1]) {
trans_.readAll(tmpbuf_, 0, 4);
short cu = (short)(
((short)hexVal(tmpbuf_[0]) << 12) +
((short)hexVal(tmpbuf_[1]) << 8) +
((short)hexVal(tmpbuf_[2]) << 4) +
(short)hexVal(tmpbuf_[3]));
try {
if (isHighSurrogate((char)cu)) {
if (highSurrogate != 0) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Expected low surrogate char");
}
highSurrogate = cu;
}
else if (isLowSurrogate((char)cu)) {
if (highSurrogate == 0) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Expected high surrogate char");
}
arr.write(toUTF8(highSurrogate, cu));
highSurrogate = 0;
}
else {
arr.write(toUTF8(cu));
}
continue;
}
catch (UnsupportedEncodingException ex) {
throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED,
"JVM does not support UTF-8");
}
catch (IOException ex) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Invalid unicode sequence");
}
}
else {
int off = ESCAPE_CHARS.indexOf(ch);
if (off == -1) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Expected control char");
}
ch = ESCAPE_CHAR_VALS[off];
}
}
arr.write(ch);
}
if (highSurrogate != 0) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Expected low surrogate char");
}
return arr;
}
// Return true if the given byte could be a valid part of a JSON number.
private boolean isJSONNumeric(byte b) {
switch (b) {
case '+':
case '-':
case '.':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'E':
case 'e':
return true;
}
return false;
}
// Read in a sequence of characters that are all valid in JSON numbers. Does
// not do a complete regex check to validate that this is actually a number.
private String readJSONNumericChars() throws TException {
StringBuffer strbuf = new StringBuffer();
while (true) {
byte ch = reader_.peek();
if (!isJSONNumeric(ch)) {
break;
}
strbuf.append((char)reader_.read());
}
return strbuf.toString();
}
// Read in a JSON number. If the context dictates, read in enclosing quotes.
private long readJSONInteger() throws TException {
context_.read();
if (context_.escapeNum()) {
readJSONSyntaxChar(QUOTE);
}
String str = readJSONNumericChars();
if (context_.escapeNum()) {
readJSONSyntaxChar(QUOTE);
}
try {
return Long.valueOf(str).longValue();
} catch (NumberFormatException ex) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Bad data encounted in numeric data");
}
}
// Read in a JSON double value. Throw if the value is not wrapped in quotes
// when expected or if wrapped in quotes when not expected.
private double readJSONDouble() throws TException {
context_.read();
if (reader_.peek() == QUOTE[0]) {
TByteArrayOutputStream arr = readJSONString(true);
try {
double dub = Double.valueOf(arr.toString("UTF-8")).doubleValue();
if (!context_.escapeNum() && !Double.isNaN(dub) &&
!Double.isInfinite(dub)) {
// Throw exception -- we should not be in a string in this case
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Numeric data unexpectedly quoted");
}
return dub;
} catch (UnsupportedEncodingException ex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
}
else {
if (context_.escapeNum()) {
// This will throw - we should have had a quote if escapeNum == true
readJSONSyntaxChar(QUOTE);
}
try {
return Double.valueOf(readJSONNumericChars()).doubleValue();
} catch (NumberFormatException ex) {
throw new TProtocolException(TProtocolException.INVALID_DATA,
"Bad data encounted in numeric data");
}
}
}
// Read in a JSON string containing base-64 encoded data and decode it.
private byte[] readJSONBase64() throws TException {
TByteArrayOutputStream arr = readJSONString(false);
byte[] b = arr.get();
int len = arr.len();
int off = 0;
int size = 0;
// Ignore padding
int bound = len >= 2 ? len - 2 : 0;
for (int i = len - 1; i >= bound && b[i] == '='; --i) {
--len;
}
while (len >= 4) {
// Decode 4 bytes at a time
TBase64Utils.decode(b, off, 4, b, size); // NB: decoded in place
off += 4;
len -= 4;
size += 3;
}
// Don't decode if we hit the end or got a single leftover byte (invalid
// base64 but legal for skip of regular string type)
if (len > 1) {
// Decode remainder
TBase64Utils.decode(b, off, len, b, size); // NB: decoded in place
size += len - 1;
}
// Sadly we must copy the byte[] (any way around this?)
byte[] result = new byte[size];
System.arraycopy(b, 0, result, 0, size);
return result;
}
private void readJSONObjectStart() throws TException {
context_.read();
readJSONSyntaxChar(LBRACE);
pushContext(new JSONPairContext());
}
private void readJSONObjectEnd() throws TException {
readJSONSyntaxChar(RBRACE);
popContext();
}
private void readJSONArrayStart() throws TException {
context_.read();
readJSONSyntaxChar(LBRACKET);
pushContext(new JSONListContext());
}
private void readJSONArrayEnd() throws TException {
readJSONSyntaxChar(RBRACKET);
popContext();
}
public TMessage readMessageBegin() throws TException {
readJSONArrayStart();
if (readJSONInteger() != VERSION) {
throw new TProtocolException(TProtocolException.BAD_VERSION,
"Message contained bad version.");
}
String name;
try {
name = readJSONString(false).toString("UTF-8");
} catch (UnsupportedEncodingException ex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
byte type = (byte)readJSONInteger();
int seqid = (int)readJSONInteger();
return new TMessage(name, type, seqid);
}
public void readMessageEnd() throws TException {
readJSONArrayEnd();
}
public TStruct readStructBegin() throws TException {
readJSONObjectStart();
return ANONYMOUS_STRUCT;
}
public void readStructEnd() throws TException {
readJSONObjectEnd();
}
public TField readFieldBegin() throws TException {
byte ch = reader_.peek();
byte type;
short id = 0;
if (ch == RBRACE[0]) {
type = TType.STOP;
}
else {
id = (short)readJSONInteger();
readJSONObjectStart();
type = getTypeIDForTypeName(readJSONString(false).get());
}
return new TField("", type, id);
}
public void readFieldEnd() throws TException {
readJSONObjectEnd();
}
public TMap readMapBegin() throws TException {
readJSONArrayStart();
byte keyType = getTypeIDForTypeName(readJSONString(false).get());
byte valueType = getTypeIDForTypeName(readJSONString(false).get());
int size = (int)readJSONInteger();
readJSONObjectStart();
return new TMap(keyType, valueType, size);
}
public void readMapEnd() throws TException {
readJSONObjectEnd();
readJSONArrayEnd();
}
public TList readListBegin() throws TException {
readJSONArrayStart();
byte elemType = getTypeIDForTypeName(readJSONString(false).get());
int size = (int)readJSONInteger();
return new TList(elemType, size);
}
public void readListEnd() throws TException {
readJSONArrayEnd();
}
public TSet readSetBegin() throws TException {
readJSONArrayStart();
byte elemType = getTypeIDForTypeName(readJSONString(false).get());
int size = (int)readJSONInteger();
return new TSet(elemType, size);
}
public void readSetEnd() throws TException {
readJSONArrayEnd();
}
public boolean readBool() throws TException {
return (readJSONInteger() == 0 ? false : true);
}
public byte readByte() throws TException {
return (byte)readJSONInteger();
}
public short readI16() throws TException {
return (short)readJSONInteger();
}
public int readI32() throws TException {
return (int)readJSONInteger();
}
public long readI64() throws TException {
return readJSONInteger();
}
public double readDouble() throws TException {
return readJSONDouble();
}
public String readString() throws TException {
try {
return readJSONString(false).toString("UTF-8");
} catch (UnsupportedEncodingException ex) {
throw new TException("JVM DOES NOT SUPPORT UTF-8");
}
}
public byte[] readBinary() throws TException {
return readJSONBase64();
}
}

36
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TList.java generated vendored Normal file
View file

@ -0,0 +1,36 @@
/*
* 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;
/**
* Helper class that encapsulates list metadata.
*
*/
public class TList {
public TList() {}
public TList(byte t, int s) {
elemType = t;
size = s;
}
public byte elemType = TType.STOP;
public int size = 0;
}

38
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TMap.java generated vendored Normal file
View file

@ -0,0 +1,38 @@
/*
* 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;
/**
* Helper class that encapsulates map metadata.
*
*/
public class TMap {
public TMap() {}
public TMap(byte k, byte v, int s) {
keyType = k;
valueType = v;
size = s;
}
public byte keyType = TType.STOP;
public byte valueType = TType.STOP;
public int size = 0;
}

38
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TMessage.java generated vendored Normal file
View file

@ -0,0 +1,38 @@
/*
* 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;
/**
* Helper class that encapsulates struct metadata.
*
*/
public class TMessage {
public TMessage() {}
public TMessage(String n, byte t, int s) {
name = n;
type = t;
seqid = s;
}
public String name = "";
public byte type;
public int seqid;
}

30
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TMessageType.java generated vendored Normal file
View file

@ -0,0 +1,30 @@
/*
* 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;
/**
* Message type constants in the Thrift protocol.
*
*/
public final class TMessageType {
public static final byte CALL = 1;
public static final byte REPLY = 2;
public static final byte EXCEPTION = 3;
}

169
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TProtocol.java generated vendored Normal file
View file

@ -0,0 +1,169 @@
/*
* 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;
import org.apache.thrift.transport.TTransport;
/**
* Protocol interface definition.
*
*/
public abstract class TProtocol {
/**
* Prevent direct instantiation
*/
private TProtocol() {}
/**
* Transport
*/
protected TTransport trans_;
/**
* Constructor
*/
protected TProtocol(TTransport trans) {
trans_ = trans;
}
/**
* Transport accessor
*/
public TTransport getTransport() {
return trans_;
}
/**
* Writing methods.
*/
public abstract void writeMessageBegin(TMessage message) throws TException;
public abstract void writeMessageEnd() throws TException;
public abstract void writeStructBegin(TStruct struct) throws TException;
public abstract void writeStructEnd() throws TException;
public abstract void writeFieldBegin(TField field) throws TException;
public abstract void writeFieldEnd() throws TException;
public abstract void writeFieldStop() throws TException;
public abstract void writeMapBegin(TMap map) throws TException;
public abstract void writeMapEnd() throws TException;
public abstract void writeListBegin(TList list) throws TException;
public abstract void writeListEnd() throws TException;
public abstract void writeSetBegin(TSet set) throws TException;
public abstract void writeSetEnd() throws TException;
public abstract void writeBool(boolean b) throws TException;
public void writeBool(Boolean b) throws TException {
writeBool(b.booleanValue());
}
public abstract void writeByte(byte b) throws TException;
public void writeByte(Byte b) throws TException {
writeByte(b.byteValue());
}
public abstract void writeI16(short i16) throws TException;
public void writeI16(Short i16) throws TException {
writeI16(i16.shortValue());
}
public abstract void writeI32(int i32) throws TException;
public void writeI32(Integer i32) throws TException {
writeI32(i32.intValue());
}
public abstract void writeI64(long i64) throws TException;
public void writeI64(Long i64) throws TException {
writeI64(i64.longValue());
}
public abstract void writeDouble(double dub) throws TException;
public void writeDouble(Double d) throws TException {
writeDouble(d.doubleValue());
}
public abstract void writeString(String str) throws TException;
public abstract void writeBinary(byte[] bin) throws TException;
/**
* Reading methods.
*/
public abstract TMessage readMessageBegin() throws TException;
public abstract void readMessageEnd() throws TException;
public abstract TStruct readStructBegin() throws TException;
public abstract void readStructEnd() throws TException;
public abstract TField readFieldBegin() throws TException;
public abstract void readFieldEnd() throws TException;
public abstract TMap readMapBegin() throws TException;
public abstract void readMapEnd() throws TException;
public abstract TList readListBegin() throws TException;
public abstract void readListEnd() throws TException;
public abstract TSet readSetBegin() throws TException;
public abstract void readSetEnd() throws TException;
public abstract boolean readBool() throws TException;
public abstract byte readByte() throws TException;
public abstract short readI16() throws TException;
public abstract int readI32() throws TException;
public abstract long readI64() throws TException;
public abstract double readDouble() throws TException;
public abstract String readString() throws TException;
public abstract byte[] readBinary() throws TException;
}

81
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TProtocolException.java generated vendored Normal file
View file

@ -0,0 +1,81 @@
/*
* 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;
/**
* Protocol exceptions.
*
*/
public class TProtocolException extends TException {
private static final long serialVersionUID = 1L;
public static final int UNKNOWN = 0;
public static final int INVALID_DATA = 1;
public static final int NEGATIVE_SIZE = 2;
public static final int SIZE_LIMIT = 3;
public static final int BAD_VERSION = 4;
public static final int NOT_IMPLEMENTED = 5;
protected int type_ = UNKNOWN;
public TProtocolException() {
super();
}
public TProtocolException(int type) {
super();
type_ = type;
}
public TProtocolException(int type, String message) {
super(message);
type_ = type;
}
public TProtocolException(String message) {
super(message);
}
public TProtocolException(int type, Throwable cause) {
super(cause);
type_ = type;
}
public TProtocolException(Throwable cause) {
super(cause);
}
public TProtocolException(String message, Throwable cause) {
super(message, cause);
}
public TProtocolException(int type, String message, Throwable cause) {
super(message, cause);
type_ = type;
}
public int getType() {
return type_;
}
}

30
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TProtocolFactory.java generated vendored Normal file
View file

@ -0,0 +1,30 @@
/*
* 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.transport.TTransport;
/**
* Factory interface for constructing protocol instances.
*
*/
public interface TProtocolFactory {
public TProtocol getProtocol(TTransport trans);
}

158
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TProtocolUtil.java generated vendored Normal file
View file

@ -0,0 +1,158 @@
/*
* 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 intepreted 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 intepreted 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:
break;
}
}
}

36
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TSet.java generated vendored Normal file
View file

@ -0,0 +1,36 @@
/*
* 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;
/**
* Helper class that encapsulates set metadata.
*
*/
public class TSet {
public TSet() {}
public TSet(byte t, int s) {
elemType = t;
size = s;
}
public byte elemType = TType.STOP;
public int size = 0;
}

34
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TStruct.java generated vendored Normal file
View file

@ -0,0 +1,34 @@
/*
* 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;
/**
* Helper class that encapsulates struct metadata.
*
*/
public class TStruct {
public TStruct() {}
public TStruct(String n) {
name = n;
}
public String name = "";
}

40
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/protocol/TType.java generated vendored Normal file
View file

@ -0,0 +1,40 @@
/*
* 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;
/**
* Type constants in the Thrift protocol.
*
*/
public final class TType {
public static final byte STOP = 0;
public static final byte VOID = 1;
public static final byte BOOL = 2;
public static final byte BYTE = 3;
public static final byte DOUBLE = 4;
public static final byte I16 = 6;
public static final byte I32 = 8;
public static final byte I64 = 10;
public static final byte STRING = 11;
public static final byte STRUCT = 12;
public static final byte MAP = 13;
public static final byte SET = 14;
public static final byte LIST = 15;
}

122
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TFramedTransport.java generated vendored Normal file
View file

@ -0,0 +1,122 @@
/*
* 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.transport;
import java.io.ByteArrayInputStream;
import org.apache.thrift.TByteArrayOutputStream;
/**
* Socket implementation of the TTransport interface. To be commented soon!
*
*/
public class TFramedTransport extends TTransport {
/**
* Underlying transport
*/
private TTransport transport_ = null;
/**
* Buffer for output
*/
private final TByteArrayOutputStream writeBuffer_ =
new TByteArrayOutputStream(1024);
/**
* Buffer for input
*/
private ByteArrayInputStream readBuffer_ = null;
public static class Factory extends TTransportFactory {
public Factory() {
}
public TTransport getTransport(TTransport base) {
return new TFramedTransport(base);
}
}
/**
* Constructor wraps around another tranpsort
*/
public TFramedTransport(TTransport transport) {
transport_ = transport;
}
public void open() throws TTransportException {
transport_.open();
}
public boolean isOpen() {
return transport_.isOpen();
}
public void close() {
transport_.close();
}
public int read(byte[] buf, int off, int len) throws TTransportException {
if (readBuffer_ != null) {
int got = readBuffer_.read(buf, off, len);
if (got > 0) {
return got;
}
}
// Read another frame of data
readFrame();
return readBuffer_.read(buf, off, len);
}
private void readFrame() throws TTransportException {
byte[] i32rd = new byte[4];
transport_.readAll(i32rd, 0, 4);
int size =
((i32rd[0] & 0xff) << 24) |
((i32rd[1] & 0xff) << 16) |
((i32rd[2] & 0xff) << 8) |
((i32rd[3] & 0xff));
byte[] buff = new byte[size];
transport_.readAll(buff, 0, size);
readBuffer_ = new ByteArrayInputStream(buff);
}
public void write(byte[] buf, int off, int len) throws TTransportException {
writeBuffer_.write(buf, off, len);
}
public void flush() throws TTransportException {
byte[] buf = writeBuffer_.get();
int len = writeBuffer_.len();
writeBuffer_.reset();
byte[] i32out = new byte[4];
i32out[0] = (byte)(0xff & (len >> 24));
i32out[1] = (byte)(0xff & (len >> 16));
i32out[2] = (byte)(0xff & (len >> 8));
i32out[3] = (byte)(0xff & (len));
transport_.write(i32out, 0, 4);
transport_.write(buf, 0, len);
transport_.flush();
}
}

163
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/THttpClient.java generated vendored Normal file
View file

@ -0,0 +1,163 @@
/*
* 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.transport;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
/**
* HTTP implementation of the TTransport interface. Used for working with a
* Thrift web services implementation.
*
*/
public class THttpClient extends TTransport {
private String url_ = null;
private final ByteArrayOutputStream requestBuffer_ = new ByteArrayOutputStream();
private InputStream inputStream_ = null;
private HttpConnection connection = null;
private int connectTimeout_ = 0;
private int readTimeout_ = 0;
private Hashtable customHeaders_ = null;
public THttpClient(String url) throws TTransportException {
url_ = url;
}
public void setConnectTimeout(int timeout) {
connectTimeout_ = timeout;
}
public void setReadTimeout(int timeout) {
readTimeout_ = timeout;
}
public void setCustomHeaders(Hashtable headers) {
customHeaders_ = headers;
}
public void setCustomHeader(String key, String value) {
if (customHeaders_ == null) {
customHeaders_ = new Hashtable();
}
customHeaders_.put(key, value);
}
public void open() {}
public void close() {
if (null != inputStream_) {
try {
inputStream_.close();
} catch (IOException ioe) {
}
inputStream_ = null;
}
if (connection != null) {
try {
connection.close();
} catch (IOException ioe) {
}
connection = null;
}
}
public boolean isOpen() {
return true;
}
public int read(byte[] buf, int off, int len) throws TTransportException {
if (inputStream_ == null) {
throw new TTransportException("Response buffer is empty, no request.");
}
try {
int ret = inputStream_.read(buf, off, len);
if (ret == -1) {
throw new TTransportException("No more data available.");
}
return ret;
} catch (IOException iox) {
throw new TTransportException(iox);
}
}
public void write(byte[] buf, int off, int len) {
requestBuffer_.write(buf, off, len);
}
public void flush() throws TTransportException {
// Extract request and reset buffer
byte[] data = requestBuffer_.toByteArray();
requestBuffer_.reset();
try {
// Create connection object
connection = (HttpConnection)Connector.open(url_);
// Make the request
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-thrift");
connection.setRequestProperty("Accept", "application/x-thrift");
connection.setRequestProperty("User-Agent", "JavaME/THttpClient");
connection.setRequestProperty("Connection", "Keep-Alive");
connection.setRequestProperty("Keep-Alive", "5000");
connection.setRequestProperty("Http-version", "HTTP/1.1");
connection.setRequestProperty("Cache-Control", "no-transform");
if (customHeaders_ != null) {
for (Enumeration e = customHeaders_.keys() ; e.hasMoreElements() ;) {
String key = (String)e.nextElement();
String value = (String)customHeaders_.get(key);
connection.setRequestProperty(key, value);
}
}
OutputStream os = connection.openOutputStream();
os.write(data);
os.close();
int responseCode = connection.getResponseCode();
if (responseCode != HttpConnection.HTTP_OK) {
throw new TTransportException("HTTP Response code: " + responseCode);
}
// Read the responses
inputStream_ = connection.openInputStream();
} catch (IOException iox) {
System.out.println(iox.toString());
throw new TTransportException(iox);
}
}
}

153
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TIOStreamTransport.java generated vendored Normal file
View file

@ -0,0 +1,153 @@
/*
* 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.transport;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* This is the most commonly used base transport. It takes an InputStream
* and an OutputStream and uses those to perform all transport operations.
* This allows for compatibility with all the nice constructs Java already
* has to provide a variety of types of streams.
*
*/
public class TIOStreamTransport extends TTransport {
/** Underlying inputStream */
protected InputStream inputStream_ = null;
/** Underlying outputStream */
protected OutputStream outputStream_ = null;
/**
* Subclasses can invoke the default constructor and then assign the input
* streams in the open method.
*/
protected TIOStreamTransport() {}
/**
* Input stream constructor.
*
* @param is Input stream to read from
*/
public TIOStreamTransport(InputStream is) {
inputStream_ = is;
}
/**
* Output stream constructor.
*
* @param os Output stream to read from
*/
public TIOStreamTransport(OutputStream os) {
outputStream_ = os;
}
/**
* Two-way stream constructor.
*
* @param is Input stream to read from
* @param os Output stream to read from
*/
public TIOStreamTransport(InputStream is, OutputStream os) {
inputStream_ = is;
outputStream_ = os;
}
/**
* The streams must already be open at construction time, so this should
* always return true.
*
* @return true
*/
public boolean isOpen() {
return true;
}
/**
* The streams must already be open. This method does nothing.
*/
public void open() throws TTransportException {}
/**
* Closes both the input and output streams.
*/
public void close() {
if (inputStream_ != null) {
try {
inputStream_.close();
} catch (IOException iox) {
}
inputStream_ = null;
}
if (outputStream_ != null) {
try {
outputStream_.close();
} catch (IOException iox) {
}
outputStream_ = null;
}
}
/**
* Reads from the underlying input stream if not null.
*/
public int read(byte[] buf, int off, int len) throws TTransportException {
if (inputStream_ == null) {
throw new TTransportException(TTransportException.NOT_OPEN, "Cannot read from null inputStream");
}
try {
return inputStream_.read(buf, off, len);
} catch (IOException iox) {
throw new TTransportException(TTransportException.UNKNOWN, iox);
}
}
/**
* Writes to the underlying output stream if not null.
*/
public void write(byte[] buf, int off, int len) throws TTransportException {
if (outputStream_ == null) {
throw new TTransportException(TTransportException.NOT_OPEN, "Cannot write to null outputStream");
}
try {
outputStream_.write(buf, off, len);
} catch (IOException iox) {
throw new TTransportException(TTransportException.UNKNOWN, iox);
}
}
/**
* Flushes the underlying output stream if not null.
*/
public void flush() throws TTransportException {
if (outputStream_ == null) {
throw new TTransportException(TTransportException.NOT_OPEN, "Cannot flush null outputStream");
}
try {
outputStream_.flush();
} catch (IOException iox) {
throw new TTransportException(TTransportException.UNKNOWN, iox);
}
}
}

97
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TMemoryBuffer.java generated vendored Normal file
View file

@ -0,0 +1,97 @@
/*
* 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.transport;
import org.apache.thrift.TByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
/**
* Memory buffer-based implementation of the TTransport interface.
*/
public class TMemoryBuffer extends TTransport {
/**
* Create a TMemoryBuffer with an initial buffer size of <i>size</i>. The
* internal buffer will grow as necessary to accommodate the size of the data
* being written to it.
*/
public TMemoryBuffer(int size) {
arr_ = new TByteArrayOutputStream(size);
}
public boolean isOpen() {
return true;
}
public void open() {
/* Do nothing */
}
public void close() {
/* Do nothing */
}
public int read(byte[] buf, int off, int len) {
byte[] src = arr_.get();
int amtToRead = (len > arr_.len() - pos_ ? arr_.len() - pos_ : len);
if (amtToRead > 0) {
System.arraycopy(src, pos_, buf, off, amtToRead);
pos_ += amtToRead;
}
return amtToRead;
}
public void write(byte[] buf, int off, int len) {
arr_.write(buf, off, len);
}
/**
* Output the contents of the memory buffer as a String, using the supplied
* encoding
*
* @param enc the encoding to use
* @return the contents of the memory buffer as a String
*/
public String toString(String enc) throws UnsupportedEncodingException {
return arr_.toString(enc);
}
public String inspect() {
String buf = "";
byte[] bytes = arr_.toByteArray();
for (int i = 0; i < bytes.length; i++) {
buf += (pos_ == i ? "==>" : "") + Integer.toHexString(bytes[i] & 0xff) + " ";
}
return buf;
}
// The contents of the buffer
private TByteArrayOutputStream arr_;
// Position to read next byte from
private int pos_;
public int length() {
return arr_.size();
}
public byte[] getArray() {
return arr_.get();
}
}

121
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TTransport.java generated vendored Normal file
View file

@ -0,0 +1,121 @@
/*
* 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.transport;
/**
* Generic class that encapsulates the I/O layer. This is basically a thin
* wrapper around the combined functionality of Java input/output streams.
*
*/
public abstract class TTransport {
/**
* Queries whether the transport is open.
*
* @return True if the transport is open.
*/
public abstract boolean isOpen();
/**
* Is there more data to be read?
*
* @return True if the remote side is still alive and feeding us
*/
public boolean peek() {
return isOpen();
}
/**
* Opens the transport for reading/writing.
*
* @throws TTransportException if the transport could not be opened
*/
public abstract void open()
throws TTransportException;
/**
* Closes the transport.
*/
public abstract void close();
/**
* Reads up to len bytes into buffer buf, starting att offset off.
*
* @param buf Array to read into
* @param off Index to start reading at
* @param len Maximum number of bytes to read
* @return The number of bytes actually read
* @throws TTransportException if there was an error reading data
*/
public abstract int read(byte[] buf, int off, int len)
throws TTransportException;
/**
* Guarantees that all of len bytes are actually read off the transport.
*
* @param buf Array to read into
* @param off Index to start reading at
* @param len Maximum number of bytes to read
* @return The number of bytes actually read, which must be equal to len
* @throws TTransportException if there was an error reading data
*/
public int readAll(byte[] buf, int off, int len)
throws TTransportException {
int got = 0;
int ret = 0;
while (got < len) {
ret = read(buf, off+got, len-got);
if (ret <= 0) {
throw new TTransportException("Cannot read. Remote side has closed. Tried to read " + len + " bytes, but only got " + got + " bytes.");
}
got += ret;
}
return got;
}
/**
* Writes the buffer to the output
*
* @param buf The output data buffer
* @throws TTransportException if an error occurs writing data
*/
public void write(byte[] buf) throws TTransportException {
write(buf, 0, buf.length);
}
/**
* Writes up to len bytes from the buffer.
*
* @param buf The output data buffer
* @param off The offset to start writing from
* @param len The number of bytes to write
* @throws TTransportException if there was an error writing data
*/
public abstract void write(byte[] buf, int off, int len)
throws TTransportException;
/**
* Flush any pending data out of a transport buffer.
*
* @throws TTransportException if there was an error writing out data.
*/
public void flush()
throws TTransportException {}
}

80
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TTransportException.java generated vendored Normal file
View file

@ -0,0 +1,80 @@
/*
* 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.transport;
import org.apache.thrift.TException;
/**
* Transport exceptions.
*
*/
public class TTransportException extends TException {
private static final long serialVersionUID = 1L;
public static final int UNKNOWN = 0;
public static final int NOT_OPEN = 1;
public static final int ALREADY_OPEN = 2;
public static final int TIMED_OUT = 3;
public static final int END_OF_FILE = 4;
protected int type_ = UNKNOWN;
public TTransportException() {
super();
}
public TTransportException(int type) {
super();
type_ = type;
}
public TTransportException(int type, String message) {
super(message);
type_ = type;
}
public TTransportException(String message) {
super(message);
}
public TTransportException(int type, Throwable cause) {
super(cause);
type_ = type;
}
public TTransportException(Throwable cause) {
super(cause);
}
public TTransportException(String message, Throwable cause) {
super(message, cause);
}
public TTransportException(int type, String message, Throwable cause) {
super(message, cause);
type_ = type;
}
public int getType() {
return type_;
}
}

41
vendor/git.apache.org/thrift.git/lib/javame/src/org/apache/thrift/transport/TTransportFactory.java generated vendored Normal file
View file

@ -0,0 +1,41 @@
/*
* 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.transport;
/**
* Factory class used to create wrapped instance of Transports.
* This is used primarily in servers, which get Transports from
* a ServerTransport and then may want to mutate them (i.e. create
* a BufferedTransport from the underlying base transport)
*
*/
public class TTransportFactory {
/**
* Return a wrapped instance of the base Transport.
*
* @param in The base transport
* @returns Wrapped Transport
*/
public TTransport getTransport(TTransport trans) {
return trans;
}
}