Examples with Meta io.confluent.protobuf.MetaProto.Meta used on opensource projects

Example 1 with Meta

use of io.confluent.protobuf.MetaProto.Meta in project schema-registry by confluentinc.

the class ProtobufData method toConnectSchema.

private Schema toConnectSchema(ToConnectContext ctx, FieldDescriptor descriptor) {
    SchemaBuilder builder;
    switch(descriptor.getType()) {
        case INT32:
        case SINT32:
        case SFIXED32:
            {
                if (descriptor.getOptions().hasExtension(MetaProto.fieldMeta)) {
                    Meta fieldMeta = descriptor.getOptions().getExtension(MetaProto.fieldMeta);
                    Map<String, String> params = fieldMeta.getParamsMap();
                    if (params != null) {
                        String connectType = params.get(CONNECT_TYPE_PROP);
                        if (CONNECT_TYPE_INT8.equals(connectType)) {
                            builder = SchemaBuilder.int8();
                            break;
                        } else if (CONNECT_TYPE_INT16.equals(connectType)) {
                            builder = SchemaBuilder.int16();
                            break;
                        }
                    }
                }
                builder = SchemaBuilder.int32();
                if (descriptor.getType() != FieldDescriptor.Type.INT32) {
                    builder.parameter(PROTOBUF_TYPE_PROP, descriptor.getType().toString().toLowerCase());
                }
                break;
            }
        case UINT32:
        case FIXED32:
        case INT64:
        case UINT64:
        case SINT64:
        case FIXED64:
        case SFIXED64:
            {
                builder = SchemaBuilder.int64();
                if (descriptor.getType() != FieldDescriptor.Type.INT64) {
                    builder.parameter(PROTOBUF_TYPE_PROP, descriptor.getType().toString().toLowerCase());
                }
                break;
            }
        case FLOAT:
            {
                builder = SchemaBuilder.float32();
                break;
            }
        case DOUBLE:
            {
                builder = SchemaBuilder.float64();
                break;
            }
        case BOOL:
            {
                builder = SchemaBuilder.bool();
                break;
            }
        case STRING:
            builder = SchemaBuilder.string();
            break;
        case BYTES:
            builder = SchemaBuilder.bytes();
            break;
        case ENUM:
            builder = useIntForEnums ? SchemaBuilder.int32() : SchemaBuilder.string();
            EnumDescriptor enumDescriptor = descriptor.getEnumType();
            String name = enhancedSchemaSupport ? enumDescriptor.getFullName() : enumDescriptor.getName();
            builder.name(name);
            String paramName = generalizedSumTypeSupport ? GENERALIZED_TYPE_ENUM : PROTOBUF_TYPE_ENUM;
            builder.parameter(paramName, enumDescriptor.getName());
            for (EnumValueDescriptor enumValueDesc : enumDescriptor.getValues()) {
                String enumSymbol = enumValueDesc.getName();
                String enumTag = String.valueOf(enumValueDesc.getNumber());
                builder.parameter(paramName + "." + enumSymbol, enumTag);
            }
            builder.optional();
            break;
        case MESSAGE:
            {
                String fullName = descriptor.getMessageType().getFullName();
                switch(fullName) {
                    case PROTOBUF_DECIMAL_TYPE:
                        Integer precision = null;
                        int scale = 0;
                        if (descriptor.getOptions().hasExtension(MetaProto.fieldMeta)) {
                            Meta fieldMeta = descriptor.getOptions().getExtension(MetaProto.fieldMeta);
                            Map<String, String> params = fieldMeta.getParamsMap();
                            String precisionStr = params.get(PROTOBUF_PRECISION_PROP);
                            if (precisionStr != null) {
                                try {
                                    precision = Integer.parseInt(precisionStr);
                                } catch (NumberFormatException e) {
                                // ignore
                                }
                            }
                            String scaleStr = params.get(PROTOBUF_SCALE_PROP);
                            if (scaleStr != null) {
                                try {
                                    scale = Integer.parseInt(scaleStr);
                                } catch (NumberFormatException e) {
                                // ignore
                                }
                            }
                        }
                        builder = Decimal.builder(scale);
                        if (precision != null) {
                            builder.parameter(CONNECT_PRECISION_PROP, precision.toString());
                        }
                        break;
                    case PROTOBUF_DATE_TYPE:
                        builder = Date.builder();
                        break;
                    case PROTOBUF_TIME_TYPE:
                        builder = Time.builder();
                        break;
                    case PROTOBUF_TIMESTAMP_TYPE:
                        builder = Timestamp.builder();
                        break;
                    default:
                        builder = toUnwrappedOrStructSchema(ctx, descriptor);
                        break;
                }
                builder.optional();
                break;
            }
        default:
            throw new DataException("Unknown Connect schema type: " + descriptor.getType());
    }
    if (descriptor.isRepeated() && builder.type() != Schema.Type.MAP) {
        Schema schema = builder.optional().build();
        builder = SchemaBuilder.array(schema);
        builder.optional();
    }
    if (useOptionalForNullables) {
        if (descriptor.hasOptionalKeyword()) {
            builder.optional();
        }
    } else if (!useWrapperForNullables) {
        builder.optional();
    }
    builder.parameter(PROTOBUF_TYPE_TAG, String.valueOf(descriptor.getNumber()));
    return builder.build();
}

Example 2 with Meta

use of io.confluent.protobuf.MetaProto.Meta in project schema-registry by confluentinc.

the class ProtobufSchema method toEnum.

private static EnumElement toEnum(EnumDescriptorProto ed) {
    String name = ed.getName();
    log.trace("*** enum name: {}", name);
    ImmutableList.Builder<EnumConstantElement> constants = ImmutableList.builder();
    for (EnumValueDescriptorProto ev : ed.getValueList()) {
        ImmutableList.Builder<OptionElement> options = ImmutableList.builder();
        if (ev.getOptions().hasDeprecated()) {
            OptionElement option = new OptionElement(DEPRECATED, Kind.BOOLEAN, ev.getOptions().getDeprecated(), false);
            options.add(option);
        }
        if (ev.getOptions().hasExtension(MetaProto.enumValueMeta)) {
            Meta meta = ev.getOptions().getExtension(MetaProto.enumValueMeta);
            OptionElement option = toOption(CONFLUENT_ENUM_VALUE_META, meta);
            if (option != null) {
                options.add(option);
            }
        }
        constants.add(new EnumConstantElement(DEFAULT_LOCATION, ev.getName(), ev.getNumber(), "", options.build()));
    }
    ImmutableList.Builder<ReservedElement> reserved = ImmutableList.builder();
    for (EnumReservedRange range : ed.getReservedRangeList()) {
        ReservedElement reservedElem = toReserved(range);
        reserved.add(reservedElem);
    }
    for (String reservedName : ed.getReservedNameList()) {
        ReservedElement reservedElem = new ReservedElement(DEFAULT_LOCATION, "", Collections.singletonList(reservedName));
        reserved.add(reservedElem);
    }
    ImmutableList.Builder<OptionElement> options = ImmutableList.builder();
    if (ed.getOptions().hasAllowAlias()) {
        OptionElement option = new OptionElement(ALLOW_ALIAS, Kind.BOOLEAN, ed.getOptions().getAllowAlias(), false);
        options.add(option);
    }
    if (ed.getOptions().hasDeprecated()) {
        OptionElement option = new OptionElement(DEPRECATED, Kind.BOOLEAN, ed.getOptions().getDeprecated(), false);
        options.add(option);
    }
    if (ed.getOptions().hasExtension(MetaProto.enumMeta)) {
        Meta meta = ed.getOptions().getExtension(MetaProto.enumMeta);
        OptionElement option = toOption(CONFLUENT_ENUM_META, meta);
        if (option != null) {
            options.add(option);
        }
    }
    return new EnumElement(DEFAULT_LOCATION, name, "", options.build(), constants.build(), reserved.build());
}

Example 3 with Meta

use of io.confluent.protobuf.MetaProto.Meta in project schema-registry by confluentinc.

the class ProtobufSchema method toDynamicEnum.

private static EnumDefinition toDynamicEnum(EnumElement enumElem) {
    Map<String, OptionElement> enumOptions = mergeOptions(enumElem.getOptions());
    Boolean allowAlias = findOption(ALLOW_ALIAS, enumOptions).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
    Boolean isDeprecated = findOption(DEPRECATED, enumOptions).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
    EnumDefinition.Builder enumer = EnumDefinition.newBuilder(enumElem.getName(), allowAlias, isDeprecated);
    for (ReservedElement reserved : enumElem.getReserveds()) {
        for (Object elem : reserved.getValues()) {
            if (elem instanceof String) {
                enumer.addReservedName((String) elem);
            } else if (elem instanceof Integer) {
                int tag = (Integer) elem;
                enumer.addReservedRange(tag, tag + 1);
            } else if (elem instanceof IntRange) {
                IntRange range = (IntRange) elem;
                enumer.addReservedRange(range.getStart(), range.getEndInclusive() + 1);
            } else {
                throw new IllegalStateException("Unsupported reserved type: " + elem.getClass().getName());
            }
        }
    }
    for (EnumConstantElement constant : enumElem.getConstants()) {
        Map<String, OptionElement> constantOptions = mergeOptions(constant.getOptions());
        Boolean isConstDeprecated = findOption(DEPRECATED, constantOptions).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
        Optional<OptionElement> meta = findOption(CONFLUENT_ENUM_VALUE_META, constantOptions);
        String doc = findDoc(meta);
        Map<String, String> params = findParams(meta);
        enumer.addValue(constant.getName(), constant.getTag(), doc, params, isConstDeprecated);
    }
    Optional<OptionElement> meta = findOption(CONFLUENT_ENUM_META, enumOptions);
    String doc = findDoc(meta);
    Map<String, String> params = findParams(meta);
    enumer.setMeta(doc, params);
    return enumer.build();
}

Example 4 with Meta

use of io.confluent.protobuf.MetaProto.Meta in project schema-registry by confluentinc.

the class ProtobufSchema method toProtoFile.

private static ProtoFileElement toProtoFile(FileDescriptorProto file) {
    String packageName = file.getPackage();
    // Don't set empty package name
    if ("".equals(packageName)) {
        packageName = null;
    }
    Syntax syntax = null;
    switch(file.getSyntax()) {
        case PROTO2:
            syntax = Syntax.PROTO_2;
            break;
        case PROTO3:
            syntax = Syntax.PROTO_3;
            break;
        default:
            break;
    }
    ImmutableList.Builder<TypeElement> types = ImmutableList.builder();
    for (DescriptorProto md : file.getMessageTypeList()) {
        MessageElement message = toMessage(file, md);
        types.add(message);
    }
    for (EnumDescriptorProto ed : file.getEnumTypeList()) {
        EnumElement enumer = toEnum(ed);
        types.add(enumer);
    }
    ImmutableList.Builder<ServiceElement> services = ImmutableList.builder();
    for (ServiceDescriptorProto sd : file.getServiceList()) {
        ServiceElement service = toService(sd);
        services.add(service);
    }
    ImmutableList.Builder<String> imports = ImmutableList.builder();
    ImmutableList.Builder<String> publicImports = ImmutableList.builder();
    List<String> dependencyList = file.getDependencyList();
    Set<Integer> publicDependencyList = new HashSet<>(file.getPublicDependencyList());
    for (int i = 0; i < dependencyList.size(); i++) {
        String depName = dependencyList.get(i);
        if (publicDependencyList.contains(i)) {
            publicImports.add(depName);
        } else {
            imports.add(depName);
        }
    }
    ImmutableList.Builder<OptionElement> options = ImmutableList.builder();
    if (file.getOptions().hasJavaPackage()) {
        options.add(new OptionElement(JAVA_PACKAGE, Kind.STRING, file.getOptions().getJavaPackage(), false));
    }
    if (file.getOptions().hasJavaOuterClassname()) {
        options.add(new OptionElement(JAVA_OUTER_CLASSNAME, Kind.STRING, file.getOptions().getJavaOuterClassname(), false));
    }
    if (file.getOptions().hasJavaMultipleFiles()) {
        options.add(new OptionElement(JAVA_MULTIPLE_FILES, Kind.BOOLEAN, file.getOptions().getJavaMultipleFiles(), false));
    }
    if (file.getOptions().hasJavaStringCheckUtf8()) {
        options.add(new OptionElement(JAVA_STRING_CHECK_UTF8, Kind.BOOLEAN, file.getOptions().getJavaStringCheckUtf8(), false));
    }
    if (file.getOptions().hasOptimizeFor()) {
        options.add(new OptionElement(OPTIMIZE_FOR, Kind.ENUM, file.getOptions().getOptimizeFor(), false));
    }
    if (file.getOptions().hasGoPackage()) {
        options.add(new OptionElement(GO_PACKAGE, Kind.STRING, file.getOptions().getGoPackage(), false));
    }
    if (file.getOptions().hasCcGenericServices()) {
        options.add(new OptionElement(CC_GENERIC_SERVICES, Kind.BOOLEAN, file.getOptions().getCcGenericServices(), false));
    }
    if (file.getOptions().hasJavaGenericServices()) {
        options.add(new OptionElement(JAVA_GENERIC_SERVICES, Kind.BOOLEAN, file.getOptions().getJavaGenericServices(), false));
    }
    if (file.getOptions().hasPyGenericServices()) {
        options.add(new OptionElement(PY_GENERIC_SERVICES, Kind.BOOLEAN, file.getOptions().getPyGenericServices(), false));
    }
    if (file.getOptions().hasPhpGenericServices()) {
        options.add(new OptionElement(PHP_GENERIC_SERVICES, Kind.BOOLEAN, file.getOptions().getPhpGenericServices(), false));
    }
    if (file.getOptions().hasDeprecated()) {
        options.add(new OptionElement(DEPRECATED, Kind.BOOLEAN, file.getOptions().getDeprecated(), false));
    }
    if (file.getOptions().hasCcEnableArenas()) {
        options.add(new OptionElement(CC_ENABLE_ARENAS, Kind.BOOLEAN, file.getOptions().getCcEnableArenas(), false));
    }
    if (file.getOptions().hasObjcClassPrefix()) {
        options.add(new OptionElement(OBJC_CLASS_PREFIX, Kind.STRING, file.getOptions().getObjcClassPrefix(), false));
    }
    if (file.getOptions().hasCsharpNamespace()) {
        options.add(new OptionElement(CSHARP_NAMESPACE, Kind.STRING, file.getOptions().getCsharpNamespace(), false));
    }
    if (file.getOptions().hasSwiftPrefix()) {
        options.add(new OptionElement(SWIFT_PREFIX, Kind.STRING, file.getOptions().getSwiftPrefix(), false));
    }
    if (file.getOptions().hasPhpClassPrefix()) {
        options.add(new OptionElement(PHP_CLASS_PREFIX, Kind.STRING, file.getOptions().getPhpClassPrefix(), false));
    }
    if (file.getOptions().hasPhpNamespace()) {
        options.add(new OptionElement(PHP_NAMESPACE, Kind.STRING, file.getOptions().getPhpNamespace(), false));
    }
    if (file.getOptions().hasPhpMetadataNamespace()) {
        options.add(new OptionElement(PHP_METADATA_NAMESPACE, Kind.STRING, file.getOptions().getPhpMetadataNamespace(), false));
    }
    if (file.getOptions().hasRubyPackage()) {
        options.add(new OptionElement(RUBY_PACKAGE, Kind.STRING, file.getOptions().getRubyPackage(), false));
    }
    if (file.getOptions().hasExtension(MetaProto.fileMeta)) {
        Meta meta = file.getOptions().getExtension(MetaProto.fileMeta);
        OptionElement option = toOption(CONFLUENT_FILE_META, meta);
        if (option != null) {
            options.add(option);
        }
    }
    // NOTE: skip extensions
    return new ProtoFileElement(DEFAULT_LOCATION, packageName, syntax, imports.build(), publicImports.build(), types.build(), services.build(), Collections.emptyList(), options.build());
}

Example 5 with Meta

use of io.confluent.protobuf.MetaProto.Meta in project schema-registry by confluentinc.

the class ProtobufSchema method toDynamicMessage.

private static MessageDefinition toDynamicMessage(Syntax syntax, MessageElement messageElem) {
    log.trace("*** message: {}", messageElem.getName());
    MessageDefinition.Builder message = MessageDefinition.newBuilder(messageElem.getName());
    for (TypeElement type : messageElem.getNestedTypes()) {
        if (type instanceof MessageElement) {
            message.addMessageDefinition(toDynamicMessage(syntax, (MessageElement) type));
        } else if (type instanceof EnumElement) {
            message.addEnumDefinition(toDynamicEnum((EnumElement) type));
        }
    }
    Set<String> added = new HashSet<>();
    for (OneOfElement oneof : messageElem.getOneOfs()) {
        MessageDefinition.OneofBuilder oneofBuilder = message.addOneof(oneof.getName());
        for (FieldElement field : oneof.getFields()) {
            String defaultVal = field.getDefaultValue();
            String jsonName = field.getJsonName();
            Map<String, OptionElement> options = mergeOptions(field.getOptions());
            CType ctype = findOption(CTYPE, options).map(o -> CType.valueOf(o.getValue().toString())).orElse(null);
            JSType jstype = findOption(JSTYPE, options).map(o -> JSType.valueOf(o.getValue().toString())).orElse(null);
            Boolean isDeprecated = findOption(DEPRECATED, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
            Optional<OptionElement> meta = findOption(CONFLUENT_FIELD_META, options);
            String doc = findDoc(meta);
            Map<String, String> params = findParams(meta);
            oneofBuilder.addField(false, field.getType(), field.getName(), field.getTag(), defaultVal, jsonName, doc, params, ctype, jstype, isDeprecated);
            added.add(field.getName());
        }
    }
    // Process fields after messages so that any newly created map entry messages are at the end
    for (FieldElement field : messageElem.getFields()) {
        if (added.contains(field.getName())) {
            continue;
        }
        Field.Label fieldLabel = field.getLabel();
        String label = fieldLabel != null ? fieldLabel.toString().toLowerCase() : null;
        boolean isProto3Optional = "optional".equals(label) && syntax == Syntax.PROTO_3;
        String fieldType = field.getType();
        String defaultVal = field.getDefaultValue();
        String jsonName = field.getJsonName();
        Map<String, OptionElement> options = mergeOptions(field.getOptions());
        CType ctype = findOption(CTYPE, options).map(o -> CType.valueOf(o.getValue().toString())).orElse(null);
        Boolean isPacked = findOption(PACKED, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
        JSType jstype = findOption(JSTYPE, options).map(o -> JSType.valueOf(o.getValue().toString())).orElse(null);
        Boolean isDeprecated = findOption(DEPRECATED, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
        Optional<OptionElement> meta = findOption(CONFLUENT_FIELD_META, options);
        String doc = findDoc(meta);
        Map<String, String> params = findParams(meta);
        ProtoType protoType = ProtoType.get(fieldType);
        ProtoType keyType = protoType.getKeyType();
        ProtoType valueType = protoType.getValueType();
        // Map fields are only permitted in messages
        if (protoType.isMap() && keyType != null && valueType != null) {
            label = "repeated";
            fieldType = toMapEntry(field.getName());
            MessageDefinition.Builder mapMessage = MessageDefinition.newBuilder(fieldType);
            mapMessage.setMapEntry(true);
            mapMessage.addField(null, keyType.toString(), KEY_FIELD, 1, null, null, null);
            mapMessage.addField(null, valueType.toString(), VALUE_FIELD, 2, null, null, null);
            message.addMessageDefinition(mapMessage.build());
        }
        if (isProto3Optional) {
            // Add synthetic oneof after real oneofs
            MessageDefinition.OneofBuilder oneofBuilder = message.addOneof("_" + field.getName());
            oneofBuilder.addField(true, fieldType, field.getName(), field.getTag(), defaultVal, jsonName, doc, params, ctype, jstype, isDeprecated);
        } else {
            message.addField(label, fieldType, field.getName(), field.getTag(), defaultVal, jsonName, doc, params, ctype, isPacked, jstype, isDeprecated);
        }
    }
    for (ReservedElement reserved : messageElem.getReserveds()) {
        for (Object elem : reserved.getValues()) {
            if (elem instanceof String) {
                message.addReservedName((String) elem);
            } else if (elem instanceof Integer) {
                int tag = (Integer) elem;
                message.addReservedRange(tag, tag + 1);
            } else if (elem instanceof IntRange) {
                IntRange range = (IntRange) elem;
                message.addReservedRange(range.getStart(), range.getEndInclusive() + 1);
            } else {
                throw new IllegalStateException("Unsupported reserved type: " + elem.getClass().getName());
            }
        }
    }
    Map<String, OptionElement> options = mergeOptions(messageElem.getOptions());
    Boolean noStandardDescriptorAccessor = findOption(NO_STANDARD_DESCRIPTOR_ACCESSOR, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
    if (noStandardDescriptorAccessor != null) {
        message.setNoStandardDescriptorAccessor(noStandardDescriptorAccessor);
    }
    Boolean isDeprecated = findOption(DEPRECATED, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
    if (isDeprecated != null) {
        message.setDeprecated(isDeprecated);
    }
    Boolean isMapEntry = findOption(MAP_ENTRY, options).map(o -> Boolean.valueOf(o.getValue().toString())).orElse(null);
    if (isMapEntry != null) {
        message.setMapEntry(isMapEntry);
    }
    Optional<OptionElement> meta = findOption(CONFLUENT_MESSAGE_META, options);
    String doc = findDoc(meta);
    Map<String, String> params = findParams(meta);
    message.setMeta(doc, params);
    return message.build();
}