/*
* Protocol Buffers - Google's data interchange format
* Copyright 2014 Google Inc. All rights reserved.
* https://developers.google.com/protocol-buffers/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.google.protobuf.jruby;
import com.google.protobuf.ByteString;
import com.google.protobuf.DescriptorProtos;
import com.google.protobuf.Descriptors;
import org.jcodings.Encoding;
import org.jcodings.specific.ASCIIEncoding;
import org.jcodings.specific.USASCIIEncoding;
import org.jcodings.specific.UTF8Encoding;
import org.jruby.*;
import org.jruby.runtime.Block;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.builtin.IRubyObject;
import java.math.BigInteger;
public class Utils {
public static Descriptors.FieldDescriptor.Type rubyToFieldType(IRubyObject typeClass) {
return Descriptors.FieldDescriptor.Type.valueOf(typeClass.asJavaString().toUpperCase());
}
public static IRubyObject fieldTypeToRuby(ThreadContext context, Descriptors.FieldDescriptor.Type type) {
return fieldTypeToRuby(context, type.name());
}
public static IRubyObject fieldTypeToRuby(ThreadContext context, DescriptorProtos.FieldDescriptorProto.Type type) {
return fieldTypeToRuby(context, type.name());
}
private static IRubyObject fieldTypeToRuby(ThreadContext context, String typeName) {
return context.runtime.newSymbol(typeName.replace("TYPE_", "").toLowerCase());
}
public static IRubyObject checkType(ThreadContext context, Descriptors.FieldDescriptor.Type fieldType,
IRubyObject value, RubyModule typeClass) {
Ruby runtime = context.runtime;
Object val;
switch(fieldType) {
case INT32:
case INT64:
case UINT32:
case UINT64:
if (!isRubyNum(value)) {
throw runtime.newTypeError("Expected number type for integral field.");
}
switch(fieldType) {
case INT32:
RubyNumeric.num2int(value);
break;
case INT64:
RubyNumeric.num2long(value);
break;
case UINT32:
num2uint(value);
break;
default:
num2ulong(context.runtime, value);
break;
}
checkIntTypePrecision(context, fieldType, value);
break;
case FLOAT:
if (!isRubyNum(value))
throw runtime.newTypeError("Expected number type for float field.");
break;
case DOUBLE:
if (!isRubyNum(value))
throw runtime.newTypeError("Expected number type for double field.");
break;
case BOOL:
if (!(value instanceof RubyBoolean))
throw runtime.newTypeError("Invalid argument for boolean field.");
break;
case BYTES:
case STRING:
value = validateStringEncoding(context, fieldType, value);
break;
case MESSAGE:
if (value.getMetaClass() != typeClass) {
throw runtime.newTypeError(value, typeClass);
}
break;
case ENUM:
if (value instanceof RubySymbol) {
Descriptors.EnumDescriptor enumDescriptor =
((RubyEnumDescriptor) typeClass.getInstanceVariable(DESCRIPTOR_INSTANCE_VAR)).getDescriptor();
val = enumDescriptor.findValueByName(value.asJavaString());
if (val == null)
throw runtime.newRangeError("Enum value " + value + " is not found.");
} else if(!isRubyNum(value)) {
throw runtime.newTypeError("Expected number or symbol type for enum field.");
}
break;
default:
break;
}
return value;
}
public static IRubyObject wrapPrimaryValue(ThreadContext context, Descriptors.FieldDescriptor.Type fieldType, Object value) {
Ruby runtime = context.runtime;
switch (fieldType) {
case INT32:
return runtime.newFixnum((Integer) value);
case INT64:
return runtime.newFixnum((Long) value);
case UINT32:
return runtime.newFixnum(((Integer) value) & (-1l >>> 32));
case UINT64:
long ret = (Long) value;
return ret >= 0 ? runtime.newFixnum(ret) :
RubyBignum.newBignum(runtime, UINT64_COMPLEMENTARY.add(new BigInteger(ret + "")));
case FLOAT:
return runtime.newFloat((Float) value);
case DOUBLE:
return runtime.newFloat((Double) value);
case BOOL:
return (Boolean) value ? runtime.getTrue() : runtime.getFalse();
case BYTES: {
IRubyObject wrapped = runtime.newString(((ByteString) value).toStringUtf8());
wrapped.setFrozen(true);
return wrapped;
}
case STRING: {
IRubyObject wrapped = runtime.newString(value.toString());
wrapped.setFrozen(true);
return wrapped;
}
default:
return runtime.getNil();
}
}
public static int num2uint(IRubyObject value) {
long longVal = RubyNumeric.num2long(value);
if (longVal > UINT_MAX)
throw value.getRuntime().newRangeError("Integer " + longVal + " too big to convert to 'unsigned int'");
long num = longVal;
if (num > Integer.MAX_VALUE || num < Integer.MIN_VALUE)
// encode to UINT32
num = (-longVal ^ (-1l >>> 32) ) + 1;
RubyNumeric.checkInt(value, num);
return (int) num;
}
public static long num2ulong(Ruby runtime, IRubyObject value) {
if (value instanceof RubyFloat) {
RubyBignum bignum = RubyBignum.newBignum(runtime, ((RubyFloat) value).getDoubleValue());
return RubyBignum.big2ulong(bignum);
} else if (value instanceof RubyBignum) {
return RubyBignum.big2ulong((RubyBignum) value);
} else {
return RubyNumeric.num2long(value);
}
}
public static IRubyObject validateStringEncoding(ThreadContext context, Descriptors.FieldDescriptor.Type type, IRubyObject value) {
if (!(value instanceof RubyString))
throw context.runtime.newTypeError("Invalid argument for string field.");
switch(type) {
case BYTES:
value = ((RubyString)value).encode(context, context.runtime.evalScriptlet("Encoding::ASCII_8BIT"));
break;
case STRING:
value = ((RubyString)value).encode(context, context.runtime.evalScriptlet("Encoding::UTF_8"));
break;
default:
break;
}
value.setFrozen(true);
return value;
}
public static void checkNameAvailability(ThreadContext context, String name) {
if (context.runtime.getObject().getConstantAt(name) != null)
throw context.runtime.newNameError(name + " is already defined", name);
}
/**
* Replace invalid "." in descriptor with __DOT__
* @param name
* @return
*/
public static String escapeIdentifier(String name) {
return name.replace(".", BADNAME_REPLACEMENT);
}
/**
* Replace __DOT__ in descriptor name with "."
* @param name
* @return
*/
public static String unescapeIdentifier(String name) {
return name.replace(BADNAME_REPLACEMENT, ".");
}
public static boolean isMapEntry(Descriptors.FieldDescriptor fieldDescriptor) {
return fieldDescriptor.getType() == Descriptors.FieldDescriptor.Type.MESSAGE &&
fieldDescriptor.isRepeated() &&
fieldDescriptor.getMessageType().getOptions().getMapEntry();
}
public static RubyFieldDescriptor msgdefCreateField(ThreadContext context, String label, IRubyObject name,
IRubyObject type, IRubyObject number, IRubyObject typeClass, RubyClass cFieldDescriptor) {
Ruby runtime = context.runtime;
RubyFieldDescriptor fieldDef = (RubyFieldDescriptor) cFieldDescriptor.newInstance(context, Block.NULL_BLOCK);
fieldDef.setLabel(context, runtime.newString(label));
fieldDef.setName(context, name);
fieldDef.setType(context, type);
fieldDef.setNumber(context, number);
if (!typeClass.isNil()) {
if (!(typeClass instanceof RubyString)) {
throw runtime.newArgumentError("expected string for type class");
}
fieldDef.setSubmsgName(context, typeClass);
}
return fieldDef;
}
protected static void checkIntTypePrecision(ThreadContext context, Descriptors.FieldDescriptor.Type type, IRubyObject value) {
if (value instanceof RubyFloat) {
double doubleVal = RubyNumeric.num2dbl(value);
if (Math.floor(doubleVal) != doubleVal) {
throw context.runtime.newRangeError("Non-integral floating point value assigned to integer field.");
}
}
if (type == Descriptors.FieldDescriptor.Type.UINT32 || type == Descriptors.FieldDescriptor.Type.UINT64) {
if (RubyNumeric.num2dbl(value) < 0) {
throw context.runtime.newRangeError("Assigning negative value to unsigned integer field.");
}
}
}
protected static boolean isRubyNum(Object value) {
return value instanceof RubyFixnum || value instanceof RubyFloat || value instanceof RubyBignum;
}
protected static void validateTypeClass(ThreadContext context, Descriptors.FieldDescriptor.Type type, IRubyObject value) {
Ruby runtime = context.runtime;
if (!(value instanceof RubyModule)) {
throw runtime.newArgumentError("TypeClass has incorrect type");
}
RubyModule klass = (RubyModule) value;
IRubyObject descriptor = klass.getInstanceVariable(DESCRIPTOR_INSTANCE_VAR);
if (descriptor.isNil()) {
throw runtime.newArgumentError("Type class has no descriptor. Please pass a " +
"class or enum as returned by the DescriptorPool.");
}
if (type == Descriptors.FieldDescriptor.Type.MESSAGE) {
if (! (descriptor instanceof RubyDescriptor)) {
throw runtime.newArgumentError("Descriptor has an incorrect type");
}
} else if (type == Descriptors.FieldDescriptor.Type.ENUM) {
if (! (descriptor instanceof RubyEnumDescriptor)) {
throw runtime.newArgumentError("Descriptor has an incorrect type");
}
}
}
public static String BADNAME_REPLACEMENT = "__DOT__";
public static String DESCRIPTOR_INSTANCE_VAR = "@descriptor";
public static String EQUAL_SIGN = "=";
private static BigInteger UINT64_COMPLEMENTARY = new BigInteger("18446744073709551616"); //Math.pow(2, 64)
private static long UINT_MAX = 0xffffffffl;
}