Java 类com.google.protobuf.TextFormat.ParseException 实例源码

@Override
public void asyncGetCursorInfo(String ledgerName, String consumerName,
        final MetaStoreCallback<ManagedCursorInfo> callback) {
    String path = prefix + ledgerName + "/" + consumerName;
    if (log.isDebugEnabled()) {
        log.debug("Reading from {}", path);
    }

    zk.getData(path, false, (rc, path1, ctx, data, stat) -> executor.submit(safeRun(() -> {
        if (rc != Code.OK.intValue()) {
            callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc))));
        } else {
            try {
                ManagedCursorInfo info = parseManagedCursorInfo(data);
                callback.operationComplete(info, new ZKStat(stat));
            } catch (ParseException | InvalidProtocolBufferException e) {
                callback.operationFailed(new MetaStoreException(e));
            }
        }
    })), null);

    if (log.isDebugEnabled()) {
        log.debug("Reading from {} ok", path);
    }
}

/** Applies the given function to the first toolchain that applies to the given cpu. */
public static String applyToToolchain(
    String original,
    String targetCpu,
    Function<CToolchain.Builder, CToolchain.Builder> transformation)
    throws ParseException {
  CrosstoolConfig.CrosstoolRelease.Builder crosstoolBuilder =
      CrosstoolConfig.CrosstoolRelease.newBuilder();
  TextFormat.merge(original, crosstoolBuilder);
  for (int i = 0; i < crosstoolBuilder.getToolchainCount(); i++) {
    if (crosstoolBuilder.getToolchain(i).getTargetCpu().equals(targetCpu)) {
      CToolchain.Builder toolchainBuilder =
          CToolchain.newBuilder(crosstoolBuilder.getToolchain(i));
      transformation.apply(toolchainBuilder);
      crosstoolBuilder.removeToolchain(i);
      crosstoolBuilder.addToolchain(toolchainBuilder.build());
      break;
    }
  }

  return TextFormat.printToString(crosstoolBuilder.build());
}

public void testUnknownEnumValuesInTextFormat() {
  TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  builder.setOptionalNestedEnumValue(4321);
  builder.addRepeatedNestedEnumValue(5432);
  builder.addPackedNestedEnumValue(6543);
  TestAllTypes message = builder.build();

  // We can print a message with unknown enum values.
  String textData = TextFormat.printToString(message);
  assertEquals(
      "optional_nested_enum: UNKNOWN_ENUM_VALUE_NestedEnum_4321\n"
      + "repeated_nested_enum: UNKNOWN_ENUM_VALUE_NestedEnum_5432\n"
      + "packed_nested_enum: UNKNOWN_ENUM_VALUE_NestedEnum_6543\n", textData);

  // Parsing unknown enum values will fail just like parsing other kinds of
  // unknown fields.
  try {
    TextFormat.merge(textData, builder);
    fail();
  } catch (ParseException e) {
    // expected.
  }
}

private ManagedLedgerInfo parseManagedLedgerInfo(byte[] data)
        throws ParseException, InvalidProtocolBufferException {
    // First try binary format, then fallback to text
    try {
        return ManagedLedgerInfo.parseFrom(data);
    } catch (InvalidProtocolBufferException e) {
        // Fallback to parsing protobuf text format
        ManagedLedgerInfo.Builder builder = ManagedLedgerInfo.newBuilder();
        TextFormat.merge(new String(data, Encoding), builder);
        return builder.build();
    }
}

private ManagedCursorInfo parseManagedCursorInfo(byte[] data)
        throws ParseException, InvalidProtocolBufferException {
    // First try binary format, then fallback to text
    try {
        return ManagedCursorInfo.parseFrom(data);
    } catch (InvalidProtocolBufferException e) {
        // Fallback to parsing protobuf text format
        ManagedCursorInfo.Builder builder = ManagedCursorInfo.newBuilder();
        TextFormat.merge(new String(data, Encoding), builder);
        return builder.build();
    }

}

/** Parses the config file, in proto text format, and returns it. */
public Service getApiProtoConfig(String configFileName) throws ParseException {
  String content = readTestData(configFileName);
  Service.Builder builder = Service.newBuilder();
  TextFormat.merge(content, builder);
  return builder.build();
}

public boolean primitive(Object value) throws ParseException, IOException
{
  if (getMatchKeyList().contains(key)) {
    found = true;
    this.value = value;
    keyValMap.put(key, value);
    key = null;
    keyCount++;
    return false;
  }
  return true;
}

/**
 * Handle a request, customized by an user's protocol
 * 
 * @param uid
 * @param ip
 * @param app
 * @param apv
 * @param os
 * @param osv
 * @param ch
 * @param op
 * @param nation
 * @param province
 * @param city
 * @throws ParseException
 * @throws InvalidProtocolBufferException
 * @throws Exception
 */
public void handle(String uid, String ip, String app, String apv, String os, String osv,
        String ch, String op, String nation, String province, String city)
        throws ParseException, InvalidProtocolBufferException, Exception
{
    InfoReqPack.Builder builder = InfoReqPack.newBuilder();
    if (null != uid && !"".equals(uid))
        builder.setUid(uid);
    if (null != ip && !"".equals(ip))
        builder.setIp(ip);
    if (null != app && !"".equals(app))
        builder.setApp(app);
    if (null != apv && !"".equals(apv))
        builder.setAppVer(apv);
    if (null != os && !"".equals(os))
        builder.setOs(os);
    if (null != osv && !"".equals(osv))
        builder.setOsVer(osv);
    if (null != ch && !"".equals(ch))
        builder.setChannel(ch);
    if (null != op && !"".equals(op))
        builder.setIsp(op);
    if (null != nation && !"".equals(nation))
        builder.setNation(nation);
    if (null != province && !"".equals(province))
        builder.setProvince(province);
    if (null != city && !"".equals(city))
        builder.setCity(city);
    builder.setLocSwitch(true);
    InfoReqPack pack = builder.build();
    // if (ClientMgr.getInstance().send("ADAPTER", pack, this)) {
    if (ClientMgr.getInstance().send("INFO", pack, this)) {
         log.info("REQ succ:" + this.m_checkSum);
    } else {
        log.info("REQ failed:" + this.m_checkSum);
        throw new Exception("send fail");
    }
}

public void writeMultipleEvents() throws Exception, ParseException {
    final int TOTAL_WRITES = 100000;
    final long startTime = System.currentTimeMillis();
    successes = 0;
    fails = 0;

    for (int z = 0; z < TOTAL_WRITES; z++) {
        es.appendToStream(STREAM_NAME, new ResponseReceiver() {

            @Override
            public void onResponseReturn(Message msg) {
                // log.debug("Response returned="+i);
                successes++;
                if ((successes + fails) == (TOTAL_WRITES)) {
                    processing.release();
                }
            }

            @Override
            public void onErrorReturn(Exception ex) {
                fails++;
                if ((successes + fails) == TOTAL_WRITES) {
                    processing.release();
                }
            }
        }, generateEvents());
    }

    processing.acquire();
    long endTime = System.currentTimeMillis();
    long duration = endTime - startTime;
    log.debug("Writing finished. Number of writes={} ({} successful, {} failed), duration={}",
                    TOTAL_WRITES, successes, fails, duration);
}

@Test
public void writeMultipleEvents() throws Exception, ParseException {
    final int TOTAL_WRITES = 100000;
    final long startTime = System.currentTimeMillis();
    successes = 0;
    fails = 0;

    for (int z = 0; z < TOTAL_WRITES; z++) {
        es.appendToStream(STREAM_NAME, new ResponseReceiver() {

            @Override
            public void onResponseReturn(Message msg) {
                // log.debug("Response returned="+i);
                successes++;
                if ((successes + fails) == (TOTAL_WRITES)) {
                    processing.release();
                }
            }

            @Override
            public void onErrorReturn(Exception ex) {
                fails++;
                if ((successes + fails) == TOTAL_WRITES) {
                    processing.release();
                }
            }
        }, generateEvents());
    }

    processing.acquire();
    long endTime = System.currentTimeMillis();
    long duration = endTime - startTime;
    log.debug("Writing finished. Number of writes={} ({} successful, {} failed), duration={}",
                    TOTAL_WRITES, successes, fails, duration);
}

@Override
protected CompilerPass getProcessor(final Compiler compiler) {
  ConformanceConfig.Builder builder = ConformanceConfig.newBuilder();
  try {
    TextFormat.merge(configuration, builder);
  } catch (ParseException e) {
    throw new RuntimeException(e);
  }
  return new CheckConformance(compiler, ImmutableList.of(builder.build()));
}

private ValidatedConformanceConfig parseConfigProto(String textProto) {
  ConformanceConfig.Builder builder = ConformanceConfig.newBuilder();
  try {
    TextFormat.merge(textProto, builder);
  } catch (ParseException pe) {
    throw new RuntimeException(pe);
  }
  return ValidatedConformanceConfig.create(builder.build());
}

static Platform parsePlatform(Label platformLabel, @Nullable String platformDescription) {
  Platform.Builder platformBuilder = Platform.newBuilder();
  try {
    if (platformDescription != null) {
      TextFormat.getParser().merge(platformDescription, platformBuilder);
    }
  } catch (ParseException e) {
    throw new IllegalArgumentException(
        String.format(
            "Failed to parse remote_execution_properties from platform %s", platformLabel),
        e);
  }
  return platformBuilder.build();
}

public static String mergeCrosstoolConfig(String original, CToolchain toolchain)
    throws TextFormat.ParseException {
  CrosstoolConfig.CrosstoolRelease.Builder builder =
      CrosstoolConfig.CrosstoolRelease.newBuilder();
  TextFormat.merge(original, builder);
  for (CToolchain.Builder toolchainBuilder : builder.getToolchainBuilderList()) {
    toolchainBuilder.mergeFrom(toolchain);
  }
  return TextFormat.printToString(builder.build());
}

public static String addLibcLabelToCrosstool(String original, String label)
    throws TextFormat.ParseException {
  CrosstoolConfig.CrosstoolRelease.Builder builder =
      CrosstoolConfig.CrosstoolRelease.newBuilder();
  TextFormat.merge(original, builder);
  for (CrosstoolConfig.CToolchain.Builder toolchain : builder.getToolchainBuilderList()) {
    toolchain.setDefaultGrteTop(label);
  }
  return TextFormat.printToString(builder.build());
}

public void startJSON() throws ParseException, IOException
{
  found = false;
  end = false;
}

public void endJSON() throws ParseException, IOException
{
  end = true;
}

public boolean startArray() throws ParseException, IOException
{
  return true;
}

public boolean startObject() throws ParseException, IOException
{
  return true;
}

public boolean startObjectEntry(String key) throws ParseException, IOException
{
  this.key = key;
  return true;
}

public boolean endArray() throws ParseException, IOException
{
  return false;
}

public boolean endObject() throws ParseException, IOException
{
  return true;
}

public boolean endObjectEntry() throws ParseException, IOException
{
  return true;
}

@Test
public void canWriteAndReadString() throws ParseException, InvalidProtocolBufferException
{
    PSFProtos.PSF.Builder psfBuilder = PSFProtos.PSF.newBuilder();
    PSFParameter.Builder psfParamBuilder = PSFProtos.PSFParameter.newBuilder();
    psfBuilder.setPsfType(PSFType.TWO_AXIS_AND_THETA_GAUSSIAN_2D);
    psfParamBuilder.setName("X\"SD");
    psfParamBuilder.setUnit(PSFParameterUnit.DISTANCE);
    psfParamBuilder.setValue(1.1);
    psfBuilder.addParameters(psfParamBuilder);
    psfParamBuilder.setName("Y SD");
    psfParamBuilder.setUnit(PSFParameterUnit.DISTANCE);
    psfParamBuilder.setValue(1.2);
    psfBuilder.addParameters(psfParamBuilder);
    psfParamBuilder.setName("'Angle");
    psfParamBuilder.setUnit(PSFParameterUnit.ANGLE);
    psfParamBuilder.clearValue();
    psfBuilder.addParameters(psfParamBuilder);

    // Standard string
    String e = psfBuilder.toString();
    PSFProtos.PSF psf = psfBuilder.build();
    String o = psf.toString();
    System.out.printf(o);
    Assert.assertEquals(e, o);

    psfBuilder.clear();
    TextFormat.merge(o, psfBuilder);
    Assert.assertTrue("Merge string", psf.equals(psfBuilder.build()));

    // Short string
    String o2 = TextFormat.shortDebugString(psf);
    System.out.println(o2);

    psfBuilder.clear();
    TextFormat.merge(o2, psfBuilder);
    Assert.assertTrue("Merge short string", psf.equals(psfBuilder.build()));

    // JSON
    Printer printer = JsonFormat.printer().omittingInsignificantWhitespace();
    String json = printer.print(psf);
    System.out.println(json);
    json = JSONUtils.simplify(json);
    System.out.println(json);

    psfBuilder.clear();
    JsonFormat.parser().merge(json, psfBuilder);
    Assert.assertTrue("Merge JSON", psf.equals(psfBuilder.build()));
}

@Test
public void testMergeCharSequenceExtensionRegistryBuilder() throws ParseException,
    URISyntaxException {
  final Map<String, FileDescriptor> info1 =
      ProtoFiles
          .newBuilder()
          .addFiles(new File(getClass().getResource("protoc-misc/").toURI()),
              "DeepAggregateOptionValue1.proto").build();

  final String protoSource =
      new StringBuilder().append("message Message1 {").append(NL)
          .append("  optional string f1 = 1;").append(NL).append("  optional Message2 f2 = 2;")
          .append(NL).append("}").append(NL).append("").append(NL).append("message Message2 {")
          .append(NL).append(" optional string f21 = 1;").append(NL)
          .append(" optional string f22 = 2;").append(NL).append("}").append(NL).toString();

  final Map<String, FileDescriptor> info =
      ProtoFiles.newBuilder().addSource("DeepAggregateOptionValue1.proto", protoSource).build();
  final Descriptor type =
      info.get("DeepAggregateOptionValue1.proto").findMessageTypeByName("Message1");

  final FieldDescriptor f1FD = type.findFieldByName("f1");
  final FieldDescriptor f2FD = type.findFieldByName("f2");
  final Descriptor type2 = f2FD.getMessageType();

  final DynamicMessage expected =
      DynamicMessage
          .newBuilder(type)
          .setField(f1FD, "hello")
          .setField(
              f2FD,
              DynamicMessage.newBuilder(type2).setField(type2.findFieldByName("f21"), "deep1")
                  .setField(type2.findFieldByName("f22"), "deep2").build()).build();

  final DynamicMessage.Builder builder = DynamicMessage.newBuilder(type);
  final String input = "f1:'hello' f2 {f21:'deep1' f22:'deep2'}";
  final ExtensionRegistry extensionRegistry = ExtensionRegistry.getEmptyRegistry();

  TextFormat.merge(input, extensionRegistry, builder);
  final DynamicMessage actual = builder.build();

  assertThat(actual, equalTo(expected));
}