Java Value.getValueType方法代码示例

import org.msgpack.value.Value; //导入方法依赖的package包/类
private Attribute unpackAttribute(String attributeName, MessageUnpacker unpacker) throws Exception {
    if ( ! unpacker.hasNext() ) {
        throw new IllegalArgumentException("Premature end of message pack stream");
    }
    Value value = unpacker.unpackValue();
    if ( value.isBinaryValue() ) {
        return new Attribute().withName(attributeName).withValue(value.asBinaryValue().asByteArray());
    } else if ( value.isFloatValue() ) {
        return new Attribute().withName(attributeName).withValue(value.asFloatValue().toDouble());
    } else if ( value.isIntegerValue() ) {
        IntegerValue intVal = value.asIntegerValue();
        if ( intVal.isInLongRange() ) {
            return new Attribute().withName(attributeName).withValue(intVal.asLong());
        } else {
            return new Attribute().withName(attributeName).withValue(intVal.asBigInteger());
        }
    } else if ( value.isStringValue() ) {
        return new Attribute().withName(attributeName).withValue(value.asStringValue().asString());
    } else {
        throw new UnsupportedOperationException("Message pack stream contained '"+value.getValueType()+"' type, but that type is not supported");
    }
}
 

import org.msgpack.value.Value; //导入方法依赖的package包/类
@Override
public GenericArray<Object> jsonColumn(Value value) {
    if (!value.isArrayValue())
        throw new RuntimeException("Support only array type json record");

    List<Value> list = value.asArrayValue().list();

    GenericArray<Object> array = new GenericData.Array<>(list.size(), avroSchema);
    for (Value val : list) {
        switch (val.getValueType()) {
            case STRING:
                array.add(elementConverter.stringColumn(val.asStringValue().toString()));
                break;
            case INTEGER:
                array.add(elementConverter.longColumn(val.asIntegerValue().toLong()));
                break;
            case FLOAT:
                array.add(elementConverter.doubleColumn(val.asFloatValue().toDouble()));
                break;
            case BOOLEAN:
                array.add(elementConverter.booleanColumn(val.asBooleanValue().getBoolean()));
                break;
            case ARRAY:
                array.add(elementConverter.jsonColumn(val.asArrayValue()));
                break;
            case MAP:
                array.add(elementConverter.jsonColumn(val.asMapValue()));
                break;
            default:
                throw new RuntimeException("Irregular Messagepack type");
        }
    }
    return array;
}
 

import org.msgpack.value.Value; //导入方法依赖的package包/类
@Override
public GenericRecord jsonColumn(Value value) {
    if (!value.isMapValue())
        throw new RuntimeException("Support only map type json record");

    Map<Value, Value> map = value.asMapValue().map();

    GenericRecord record = new GenericData.Record(avroSchema);
    for (Map.Entry<String, AbstractAvroValueConverter> entry : converterTable.entrySet()) {
        Value key = ValueFactory.newString(entry.getKey());
        if (!map.containsKey(key)) {
            record.put(entry.getKey(), null);
        } else {
            Value child = map.get(ValueFactory.newString(entry.getKey()));
            switch (child.getValueType()) {
                case STRING:
                    record.put(entry.getKey(), entry.getValue().stringColumn(child.asStringValue().toString()));
                    break;
                case INTEGER:
                    record.put(entry.getKey(), entry.getValue().longColumn(child.asIntegerValue().toLong()));
                    break;
                case FLOAT:
                    record.put(entry.getKey(), entry.getValue().doubleColumn(child.asFloatValue().toDouble()));
                    break;
                case BOOLEAN:
                    record.put(entry.getKey(), entry.getValue().booleanColumn(child.asBooleanValue().getBoolean()));
                    break;
                case ARRAY:
                    record.put(entry.getKey(), entry.getValue().jsonColumn(child.asArrayValue()));
                    break;
                case MAP:
                    record.put(entry.getKey(), entry.getValue().jsonColumn(child.asMapValue()));
                    break;
                default:
                    throw new RuntimeException("Irregular Messagepack type");
            }
        }
    }
    return record;
}
 

import org.msgpack.value.Value; //导入方法依赖的package包/类
private Object doGuessDeserialize( ModuleDescriptor module, ValueType valueType, Value value )
    throws IOException, ClassNotFoundException
{
    switch( value.getValueType() )
    {
        case MAP:
            MapValue mapValue = value.asMapValue();
            Optional<String> typeInfo = mapValue
                .entrySet().stream()
                .filter( entry -> entry.getKey().isStringValue() )
                .map( entry ->
                      {
                          String key = doDeserialize( module, ValueType.STRING, entry.getKey() );
                          return new AbstractMap.SimpleImmutableEntry<>( key, entry.getValue() );
                      } )
                .filter( entry -> "_type".equals( entry.getKey() ) )
                .findFirst()
                .map( entry -> doDeserialize( module, ValueType.STRING, entry.getValue() ) );
            if( typeInfo.isPresent() )
            {
                StatefulAssociationCompositeDescriptor descriptor = statefulCompositeDescriptorFor(
                    module, typeInfo.get() );
                if( descriptor != null )
                {
                    return deserializeStatefulAssociationValue( ( (CompositeDescriptor) descriptor ).module(),
                                                                descriptor.valueType(),
                                                                mapValue );
                }
            }
        default:
            throw new SerializationException( "Don't know how to deserialize " + valueType + " from " + value
                                              + " (" + value.getValueType() + ")" );
    }
}
 

import org.msgpack.value.Value; //导入方法依赖的package包/类
private boolean fetchJobResult(int rows, TDJobOperator job)
{
    Optional<ArrayValue> firstRow = pollingRetryExecutor(state, RESULT)
            .retryUnless(TDOperator::isDeterministicClientException)
            .withErrorMessage("Failed to download result of job '%s'", job.getJobId())
            .withRetryInterval(retryInterval)
            .run(s -> job.getResult(
                    ite -> ite.hasNext()
                            ? Optional.of(ite.next())
                            : Optional.absent()));

    if (!firstRow.isPresent()) {
        throw new TaskExecutionException("Got unexpected empty result for count job: " + job.getJobId());
    }
    ArrayValue row = firstRow.get();
    if (row.size() != 1) {
        throw new TaskExecutionException("Got unexpected result row size for count job: " + row.size());
    }
    Value count = row.get(0);
    IntegerValue actualRows;
    try {
        actualRows = count.asIntegerValue();
    }
    catch (MessageTypeCastException e) {
        throw new TaskExecutionException("Got unexpected value type count job: " + count.getValueType());
    }

    return BigInteger.valueOf(rows).compareTo(actualRows.asBigInteger()) <= 0;
}
 

import org.msgpack.value.Value; //导入方法依赖的package包/类
private boolean isTruthy(Value firstCol)
{
    // Anything that is not NULL and not FALSE or 0 is considered truthy.
    switch (firstCol.getValueType()) {
        case NIL:
            return false;
        case BOOLEAN:
            return firstCol.asBooleanValue().getBoolean();
        case INTEGER:
            return firstCol.asIntegerValue().asLong() != 0;
        default:
            return true;
    }
}