diff --git a/client.diff/p b/client.diff/p new file mode 100755 index 000000000..94270c917 --- /dev/null +++ b/client.diff/p @@ -0,0 +1,10 @@ +#!/bin/bash +p=$(pwd -P) +function compile() { + gradle build -x checkstyleMain +} +compile +cp build/libs/client.diff-2.1.0-SNAPSHOT.jar ../gumtree-20170805-2.1.0-SNAPSHOT/lib/ +cd .. +gumtree-20170805-2.1.0-SNAPSHOT/bin/gumtree webdiff Hello1.pb Hello2.pb +cd - diff --git a/client.diff/src/main/java/com/github/gumtreediff/client/diff/web/DiffView.java b/client.diff/src/main/java/com/github/gumtreediff/client/diff/web/DiffView.java index 2e6541378..9555f2ec7 100644 --- a/client.diff/src/main/java/com/github/gumtreediff/client/diff/web/DiffView.java +++ b/client.diff/src/main/java/com/github/gumtreediff/client/diff/web/DiffView.java @@ -49,7 +49,16 @@ public DiffView(File fSrc, File fDst) throws IOException { TreeContext dst = Generators.getInstance().getTree(fDst.getAbsolutePath()); Matcher matcher = Matchers.getInstance().getMatcher(src.getRoot(), dst.getRoot()); matcher.match(); - diffs = new HtmlDiffs(fSrc, fDst, src, dst, matcher); + if (fSrc.getAbsolutePath().endsWith(".pb")) { + String pathSrc = fSrc.getAbsolutePath(); + pathSrc = pathSrc.substring(0, pathSrc.lastIndexOf(".pb")) + ".java"; + String pathDst = fDst.getAbsolutePath(); + pathDst = pathDst.substring(0, pathDst.lastIndexOf(".pb")) + ".java"; + // System.out.println("ends with .pb " + pathSrc + " dst = " + pathDst); + diffs = new HtmlDiffs(new File(pathSrc), new File(pathDst), src, dst, matcher); + } else { + diffs = new HtmlDiffs(fSrc, fDst, src, dst, matcher); + } diffs.produce(); } diff --git a/client/src/main/java/com/github/gumtreediff/client/Run.java b/client/src/main/java/com/github/gumtreediff/client/Run.java index 6f04f6694..4e7b192fe 100644 --- a/client/src/main/java/com/github/gumtreediff/client/Run.java +++ b/client/src/main/java/com/github/gumtreediff/client/Run.java @@ -54,7 +54,6 @@ protected void process(String name, String[] args) { public static void initGenerators() { Reflections reflections = new Reflections("com.github.gumtreediff.gen"); - reflections.getSubTypesOf(TreeGenerator.class).forEach( gen -> { com.github.gumtreediff.gen.Register a = diff --git a/core/build.gradle b/core/build.gradle index a66aff299..7208146a7 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -4,6 +4,8 @@ dependencies { compile 'com.github.mpkorstanje:simmetrics-core:3.2.3' compile 'net.sf.trove4j:trove4j:3.0.3' compile 'com.google.code.gson:gson:2.4' + compile files('lib/protobuf-java-3.3.1.jar') + runtime files('lib/protobuf-java-3.3.1.jar') } allprojects { gradle.projectsEvaluated { @@ -11,4 +13,4 @@ allprojects { options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation" } } -} \ No newline at end of file +} diff --git a/core/p b/core/p new file mode 100755 index 000000000..cc940e112 --- /dev/null +++ b/core/p @@ -0,0 +1,18 @@ +#!/bin/bash +function compile() { + gradle build -x checkstyleMain -x test +} +compile +cd .. > /dev/null +gumtree=gumtree-$(date '+%Y%m%d')-2.1.0-SNAPSHOT +gumtree=gumtree-20170806-2.1.0-SNAPSHOT +if [ ! -d $gumtree/lib/ ]; then + gradle build -x checkstyleMain -x test + unzip dist/build/distributions/$gumtree.zip +fi +cp core/build/libs/core-2.1.0-SNAPSHOT.jar $gumtree/lib/ +fast Hello1.java Hello1.pb +fast Hello2.java Hello2.pb +$gumtree/bin/gumtree diff Hello1.pb Hello2.pb +#$gumtree/bin/gumtree webdiff Hello1.pb Hello2.pb +cd - > /dev/null diff --git a/core/src/main/java/com/github/gumtreediff/gen/Registry.java b/core/src/main/java/com/github/gumtreediff/gen/Registry.java index b10a9e4ec..97dacdd19 100644 --- a/core/src/main/java/com/github/gumtreediff/gen/Registry.java +++ b/core/src/main/java/com/github/gumtreediff/gen/Registry.java @@ -44,15 +44,26 @@ public class Priority { public C get(K key, Object... args) { Factory factory = getFactory(key); - if (factory != null) - return factory.instantiate(args); + if (factory != null) { + C c = factory.instantiate(args); + if (c == null) { + System.err.println("can't instantiate for key = " + key); + System.err.println("can't instantiate for factory = " + factory.getClass().getName()); + System.err.println("can't instantiate for n args = " + args.length); + for (int i = 0; i < args.length; i++) { + System.err.println("can't instantiate for arg " + i + " = " + args[i].getClass().getName()); + } + } + return c; + } return null; } public Factory getFactory(K key) { Entry entry = find(key); - if (entry != null) + if (entry != null) { return entry.factory; + } return null; } diff --git a/core/src/main/java/com/github/gumtreediff/gen/TreeGenerator.java b/core/src/main/java/com/github/gumtreediff/gen/TreeGenerator.java index 3e7870d3a..d30b1123b 100644 --- a/core/src/main/java/com/github/gumtreediff/gen/TreeGenerator.java +++ b/core/src/main/java/com/github/gumtreediff/gen/TreeGenerator.java @@ -30,7 +30,7 @@ public abstract class TreeGenerator { public TreeContext generateFromReader(Reader r) throws IOException { TreeContext ctx = generate(r); - ctx.validate(); + ctx.validate(); return ctx; } diff --git a/core/src/main/java/com/github/gumtreediff/io/ActionsIoUtils.java b/core/src/main/java/com/github/gumtreediff/io/ActionsIoUtils.java index 30b00866f..ce3596f22 100644 --- a/core/src/main/java/com/github/gumtreediff/io/ActionsIoUtils.java +++ b/core/src/main/java/com/github/gumtreediff/io/ActionsIoUtils.java @@ -34,13 +34,18 @@ import javax.xml.stream.XMLStreamWriter; import java.io.IOException; import java.io.Writer; +import java.io.FileOutputStream; import java.util.List; +import java.util.Map; +import java.util.HashMap; +import fast.Fast; public final class ActionsIoUtils { private ActionsIoUtils() { } + public static Map pb_mappings = new HashMap(); public static ActionSerializer toText(TreeContext sctx, List actions, MappingStore mappings) throws IOException { return new ActionSerializer(sctx, mappings, actions) { @@ -87,15 +92,82 @@ public abstract static class ActionSerializer extends AbstractSerializer { protected abstract ActionFormatter newFormatter(TreeContext ctx, Writer writer) throws Exception; + static int id = 1; + static Map src_map = new HashMap(); + static Map dst_map = new HashMap(); + + void pbToMapOne(Map map, fast.Fast.Element.Builder element) { + if (element.getChildCount() > 0) { + for (int i=0; i map, fast.Fast.Element element) { + id = 1; + map.clear(); + pbToMapOne(map, element.toBuilder()); + } + @Override public void writeTo(Writer writer) throws Exception { + boolean update_pb = false; + if (context != null && context.root!=null && pb_mappings.size() > 0) { + update_pb = true; + } + String filename = null; + String dst_filename = null; + String delta_filename = null; + fast.Fast.Element unit = null; + fast.Fast.Element dst_unit = null; + if (update_pb) { + unit = pb_mappings.get(context.root); + if (unit.getUnit()!=null) { + filename = unit.getUnit().getFilename() + ".pb"; + delta_filename = unit.getUnit().getFilename() + "-diff.pb"; + fast.Fast.Data.Builder data_element = fast.Fast.Data.newBuilder(); + if (unit!=null) data_element.setElement(unit); + if (filename!=null) { + FileOutputStream output = new FileOutputStream(filename); + data_element.build().writeTo(output); + output.close(); + } + } + pbToMap(src_map, unit); + ITree dst = mappings.getDst(context.root); + if (dst!=null) { + dst_unit = pb_mappings.get(dst); + if (dst_unit.getUnit()!=null) { + dst_filename = dst_unit.getUnit().getFilename() + ".pb"; + fast.Fast.Data.Builder data_element = fast.Fast.Data.newBuilder(); + if (dst_unit!=null) data_element.setElement(dst_unit); + if (dst_filename!=null) { + FileOutputStream output = new FileOutputStream(dst_filename); + data_element.build().writeTo(output); + output.close(); + } + } + pbToMap(dst_map, dst_unit); + } + } ActionFormatter fmt = newFormatter(context, writer); // Start the output fmt.startOutput(); + fast.Fast.Delta.Builder delta = fast.Fast.Delta.newBuilder(); + delta.setSrc(filename); + delta.setDst(dst_filename); + // Write the matches fmt.startMatches(); for (Mapping m: mappings) { + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.MATCH); + fast.Fast.Delta.Diff.Match.Builder mbuilder = dbuilder.getMatchBuilder(); + mbuilder.setSrc(m.getFirst().getId()); + mbuilder.setDst(m.getSecond().getId()); fmt.match(m.getFirst(), m.getSecond()); } fmt.endMatches(); @@ -106,24 +178,186 @@ public void writeTo(Writer writer) throws Exception { ITree src = a.getNode(); if (a instanceof Move) { ITree dst = mappings.getDst(src); + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.MOVE); + fast.Fast.Delta.Diff.Move.Builder mbuilder = dbuilder.getMoveBuilder(); + mbuilder.setSrc(src.getId()); + mbuilder.setDst(dst.getParent().getId()); + mbuilder.setPosition(((Move) a).getPosition()); + fmt.moveAction(src, dst.getParent(), ((Move) a).getPosition()); + } else if (a instanceof Update) { + ITree dst = mappings.getDst(src); + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.UPDATE); + fast.Fast.Delta.Diff.Update.Builder mbuilder = dbuilder.getUpdateBuilder(); + mbuilder.setSrc(src.getId()); + mbuilder.setDst(dst.getId()); + fmt.updateAction(src, dst); + } else if (a instanceof Insert) { + ITree dst = a.getNode(); + if (dst.isRoot()) { + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.ADD); + fast.Fast.Delta.Diff.Add.Builder mbuilder = dbuilder.getAddBuilder(); + mbuilder.setSrc(src.getId()); + fmt.insertRoot(src); + } else { + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.ADD); + fast.Fast.Delta.Diff.Add.Builder mbuilder = dbuilder.getAddBuilder(); + mbuilder.setSrc(src.getId()); + mbuilder.setDst(dst.getParent().getId()); + mbuilder.setPosition(dst.getParent().getChildPosition(dst)); + fmt.insertAction(src, dst.getParent(), dst.getParent().getChildPosition(dst)); + } + } else if (a instanceof Delete) { + fast.Fast.Delta.Diff.Builder dbuilder = delta.addDiffBuilder(); + dbuilder.setType(fast.Fast.Delta.Diff.DeltaType.DEL); + fast.Fast.Delta.Diff.Del.Builder mbuilder = dbuilder.getDelBuilder(); + mbuilder.setSrc(src.getId()); + fmt.deleteAction(src); + } + } + fmt.endActions(); + + // Finish up + fmt.endOutput(); + if (update_pb) { + fast.Fast.Data.Builder data_element = fast.Fast.Data.newBuilder(); + if (delta!=null) data_element.setDelta(delta); + FileOutputStream output = new FileOutputStream(delta_filename); + data_element.build().writeTo(output); + output.close(); + } + } + + public void writeTo0(Writer writer) throws Exception { + boolean update_pb = false; + if (context != null && context.root!=null && pb_mappings.size() > 0) { + update_pb = true; + } + String filename = null; + fast.Fast.Element unit = null; + fast.Fast.Element dst_unit = null; + if (update_pb) { + unit = pb_mappings.get(context.root); + if (unit.getUnit()!=null) + filename = unit.getUnit().getFilename() + "-diff.pb"; + pbToMap(src_map, unit); + ITree dst = mappings.getDst(context.root); + if (dst!=null) { + dst_unit = pb_mappings.get(dst); + pbToMap(dst_map, dst_unit); + } + } + + ActionFormatter fmt = newFormatter(context, writer); + // Start the output + fmt.startOutput(); + + Map dst_to_src_mappings = new HashMap(); + // Write the matches + // fmt.startMatches(); + for (Mapping m: mappings) { + if (update_pb) + dst_to_src_mappings.put(m.getSecond(), m.getFirst()); + // fmt.match(m.getFirst(), m.getSecond()); + } + // fmt.endMatches(); + + // Write the actions + fmt.startActions(); + for (Action a : actions) { + ITree src = a.getNode(); + if (a instanceof Move) { + fast.Fast.Element e_src = pb_mappings.get(src); + fast.Fast.Element.Builder eb_src = e_src.toBuilder(); + eb_src.setChange(fast.Fast.Element.DiffType.CHANGED_FROM); + ITree dst = mappings.getDst(src); + fast.Fast.Element e_dst = pb_mappings.get(dst); + fast.Fast.Element.Builder eb_dst = e_dst.toBuilder(); + eb_dst.setChange(fast.Fast.Element.DiffType.CHANGED_TO); + ITree dParent = dst.getParent(); + if (dParent != null) { + ITree sParent = dst_to_src_mappings.get(dParent); + if (sParent != null) { + fast.Fast.Element.Builder eb_sparent = pb_mappings.get(sParent).toBuilder(); + if (((Move) a).getPosition() <= eb_sparent.getChildCount()) + eb_sparent.addChild(((Move) a).getPosition(), eb_dst); + } + } fmt.moveAction(src, dst.getParent(), ((Move) a).getPosition()); } else if (a instanceof Update) { + fast.Fast.Element.Builder eb_src = src_map.get(src.getId()); + eb_src.setChange(fast.Fast.Element.DiffType.CHANGED_FROM); + src_map.put(src.getId(), eb_src); + ITree node = src; + while (node.getParent()!=null) { + fast.Fast.Element.Builder eb_node = src_map.get(node.getId()); + eb_node.build(); + src_map.put(node.getId(), eb_node); + node = node.getParent(); + } + unit = src_map.get(src_map.size()).build(); + System.out.println(unit); ITree dst = mappings.getDst(src); + fast.Fast.Element e_dst = pb_mappings.get(dst); + fast.Fast.Element.Builder eb_dst = e_dst.toBuilder(); + eb_dst.setChange(fast.Fast.Element.DiffType.CHANGED_TO); + pb_mappings.put(dst, eb_dst.build()); + // System.out.println(eb_dst); + ITree sParent = src.getParent(); + if (sParent != null) { + fast.Fast.Element.Builder eb_sparent = pb_mappings.get(sParent).toBuilder(); + // System.out.println(eb_sparent); + int i; + for (i=0; i clazz) { @Override protected Entry newEntry(Class clazz, Register annotation) { + // System.out.println("annotation id = " + annotation.id()); return new Entry(annotation.id(), clazz, defaultFactory(clazz, ITree.class, ITree.class, MappingStore.class), annotation.priority()) { diff --git a/core/src/main/java/com/github/gumtreediff/tree/TreeContext.java b/core/src/main/java/com/github/gumtreediff/tree/TreeContext.java index 411367846..78e03a5b3 100644 --- a/core/src/main/java/com/github/gumtreediff/tree/TreeContext.java +++ b/core/src/main/java/com/github/gumtreediff/tree/TreeContext.java @@ -37,7 +37,7 @@ public class TreeContext { private final MetadataSerializers serializers = new MetadataSerializers(); - private ITree root; + public ITree root; @Override public String toString() { diff --git a/dist/build.gradle b/dist/build.gradle index 19968b7d7..88560fc4b 100644 --- a/dist/build.gradle +++ b/dist/build.gradle @@ -27,6 +27,7 @@ dependencies { compile project(':gen.js') compile project(':gen.ruby') compile project(':gen.srcml') + compile project(':gen.pb') } run { diff --git a/gen.antlr3-smali b/gen.antlr3-smali new file mode 160000 index 000000000..93a437302 --- /dev/null +++ b/gen.antlr3-smali @@ -0,0 +1 @@ +Subproject commit 93a4373023aae5b9a559069c682f67420f56ffd4 diff --git a/gen.antlr3/build.gradle b/gen.antlr3/build.gradle index 41d1e3a3a..2e55c122f 100644 --- a/gen.antlr3/build.gradle +++ b/gen.antlr3/build.gradle @@ -1 +1,5 @@ description = 'GumTree abstract AntLR module.' +dependencies { + compile files('lib/protobuf-java-3.3.1.jar') + runtime files('lib/protobuf-java-3.3.1.jar') +} diff --git a/gen.antlr3/p b/gen.antlr3/p new file mode 100755 index 000000000..a9b9ebaf1 --- /dev/null +++ b/gen.antlr3/p @@ -0,0 +1,13 @@ +#!/bin/bash +p=$(pwd -P) +function compile() { + cp ../../fast/src/fast/Fast.java src/main/java/fast + cp ../../fast/src/fast/antlr/FastAntlr.java src/main/java/fast/antlr + gradle build -x test -x checkstyleMain + cd ../gen.antlr3-smali/smali + ./p + cd $p +} +compile >& t.t +cat ../../fast/fast-antlr.proto | sed -e 's/int32 type = 1;/fast.antlr.Kind type = 1;/' | sed -e 's/package fast.antlr;/package fast.antlr; import "tokens.proto";/' > /tmp/fast-antlr.proto +cat /tmp/output.pb | protoc -I/tmp --decode=fast.antlr.Element /tmp/tokens.proto /tmp/fast-antlr.proto diff --git a/gen.antlr3/src/main/java/com/github/gumtreediff/gen/antlr3/AbstractAntlr3TreeGenerator.java b/gen.antlr3/src/main/java/com/github/gumtreediff/gen/antlr3/AbstractAntlr3TreeGenerator.java index 46213b6b0..81dae4cf1 100644 --- a/gen.antlr3/src/main/java/com/github/gumtreediff/gen/antlr3/AbstractAntlr3TreeGenerator.java +++ b/gen.antlr3/src/main/java/com/github/gumtreediff/gen/antlr3/AbstractAntlr3TreeGenerator.java @@ -20,8 +20,14 @@ package com.github.gumtreediff.gen.antlr3; +import java.io.FileNotFoundException; import java.io.IOException; import java.io.Reader; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.PrintStream; +import java.lang.Exception; + import java.util.ArrayDeque; import java.util.Deque; import java.util.List; @@ -34,7 +40,7 @@ import com.github.gumtreediff.tree.ITree; import com.github.gumtreediff.tree.TreeContext; -public abstract class AbstractAntlr3TreeGenerator extends TreeGenerator { +public abstract class AbstractAntlr3TreeGenerator extends TreeGenerator { private Deque trees = new ArrayDeque<>(); @@ -94,14 +100,30 @@ protected String getTokenName(int tokenType) { return names[tokenType]; } + @SuppressWarnings("unchecked") - protected void buildTree(TreeContext context, CommonTree ct) { + protected void buildTree(TreeContext context, CommonTree ct) throws FileNotFoundException { int type = ct.getType(); String tokenName = getTokenName(type); String label = ct.getText(); if (tokenName.equals(label)) label = ITree.NO_LABEL; + PrintStream protocol = new PrintStream("/tmp/tokens.proto"); + String[] names = getTokenNames(); + protocol.println("syntax=\"proto3\";"); + protocol.println("package fast;"); + protocol.println("enum Kind {"); + protocol.println("\tINVALID=0;"); + protocol.println("\tEOR=1;"); + protocol.println("\tDOWN=2;"); + protocol.println("\tUP=3;"); + for (int i=4; i < names.length; i++) { + protocol.println("\t" + names[i] + "=" + i + ";"); + } + protocol.println("}"); + protocol.close(); + ITree t = context.createTree(type, label, tokenName); int start = startPos(ct.getTokenStartIndex()); diff --git a/gen.jdt/p b/gen.jdt/p new file mode 100755 index 000000000..3f5b13942 --- /dev/null +++ b/gen.jdt/p @@ -0,0 +1,10 @@ +#!/bin/bash +p=$(pwd -P) +function compile() { + gradle build -x checkstyleMain +} +compile +cp build/libs/gen.jdt-2.1.0-SNAPSHOT.jar ../gumtree-20170805-2.1.0-SNAPSHOT/lib/ +cd .. +gumtree-20170805-2.1.0-SNAPSHOT/bin/gumtree diff Hello1.pb Hello2.pb +cd - diff --git a/gen.jdt/src/main/java/com/github/gumtreediff/gen/jdt/JdtTreeGenerator.java b/gen.jdt/src/main/java/com/github/gumtreediff/gen/jdt/JdtTreeGenerator.java index 4e3c48d0d..20806bed5 100644 --- a/gen.jdt/src/main/java/com/github/gumtreediff/gen/jdt/JdtTreeGenerator.java +++ b/gen.jdt/src/main/java/com/github/gumtreediff/gen/jdt/JdtTreeGenerator.java @@ -24,7 +24,8 @@ import com.github.gumtreediff.gen.Register; import com.github.gumtreediff.gen.Registry; -@Register(id = "java-jdt", accept = "\\.java$", priority = Registry.Priority.MAXIMUM) +// @Register(id = "java-jdt", accept = "\\.java$", priority = Registry.Priority.MAXIMUM) +@Register(id = "java-jdt", accept = "\\.java$", priority = Registry.Priority.MINIMUM) public class JdtTreeGenerator extends AbstractJdtTreeGenerator { @Override diff --git a/gen.pb/build.gradle b/gen.pb/build.gradle new file mode 100644 index 000000000..ddf594003 --- /dev/null +++ b/gen.pb/build.gradle @@ -0,0 +1,6 @@ +description = 'GumTree Protobuf module.' +apply plugin:'java' +dependencies { + compile files('lib/protobuf-java-3.3.1.jar') + runtime files('lib/protobuf-java-3.3.1.jar') +} diff --git a/gen.pb/lib/protobuf-java-3.3.1.jar b/gen.pb/lib/protobuf-java-3.3.1.jar new file mode 100644 index 000000000..94ac9d763 Binary files /dev/null and b/gen.pb/lib/protobuf-java-3.3.1.jar differ diff --git a/gen.pb/p b/gen.pb/p new file mode 100755 index 000000000..02f21f667 --- /dev/null +++ b/gen.pb/p @@ -0,0 +1,16 @@ +#!/bin/bash +function compile() { + gradle build -x checkstyleMain +} +compile +cd .. > /dev/null +gumtree=gumtree-$(date '+%Y%m%d')-2.1.0-SNAPSHOT +if [ ! -d $gumtree/lib/ ]; then + gradle build -x checkstyleMain + unzip dist/build/distributions/$gumtree.zip +fi +cp gen.pb/build/libs/gen.pb-2.1.0-SNAPSHOT.jar $gumtree/lib/ +fast Hello1.java Hello1.pb +fast Hello2.java Hello2.pb +$gumtree/bin/gumtree webdiff Hello1.pb Hello2.pb +cd - > /dev/null diff --git a/gen.pb/src/main/java/com/github/gumtreediff/gen/pb/AbstractPBTreeGenerator.java b/gen.pb/src/main/java/com/github/gumtreediff/gen/pb/AbstractPBTreeGenerator.java new file mode 100644 index 000000000..10b79debf --- /dev/null +++ b/gen.pb/src/main/java/com/github/gumtreediff/gen/pb/AbstractPBTreeGenerator.java @@ -0,0 +1,93 @@ +package com.github.gumtreediff.gen.pb; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.Reader; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.PrintStream; +import java.lang.Exception; +import java.io.InputStream; + +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.List; +import java.util.Map; + +import com.github.gumtreediff.gen.TreeGenerator; +import com.github.gumtreediff.tree.ITree; +import com.github.gumtreediff.tree.TreeContext; + +import com.github.gumtreediff.gen.Register; +import com.github.gumtreediff.io.ActionsIoUtils; + +import fast.Fast; +import fast.Fast.Data; +import fast.Fast.Element; + +@Register(id = "protobuf", accept = "\\.pb") +public class AbstractPBTreeGenerator extends TreeGenerator { + + private Deque trees = new ArrayDeque<>(); + + protected static Map chars; + + public AbstractPBTreeGenerator() { + } + + @Override + public TreeContext generate(Reader r) throws IOException { + TreeContext context = new TreeContext(); + return context; + } + + static int pos = 0; + static int id = 1; + @Override + public TreeContext generateFromFile(String input) throws IOException { + // System.out.println("generating from file " + input); + fast.Fast.Data data = fast.Fast.Data.parseFrom(new FileInputStream(input)); + fast.Fast.Element element = data.getElement(); + TreeContext context = new TreeContext(); + try { + id = 1; + pos = 0; + buildTree(context, element); + } catch (Exception e) { + e.printStackTrace(); + } + trees.clear(); + return context; + } + + @SuppressWarnings("unchecked") + protected void buildTree(TreeContext context, fast.Fast.Element element) throws Exception { + int type = element.getKindValue(); + String tokenName = element.getKind().toString(); + String text = element.getText().toStringUtf8(); + String tail = element.getTail().toStringUtf8(); + int length = text.length(); + int start = pos; + // System.out.println(tokenName); + ITree t = context.createTree(type, text, tokenName); + pos += length; + if (trees.isEmpty()) + context.setRoot(t); + else + t.setParentAndUpdateChildren(trees.peek()); + if (element.getChildCount() > 0) { + trees.push(t); + for (fast.Fast.Element child : element.getChildList()) + buildTree(context, child); + trees.pop(); + } + pos += tail.length(); + t.setPos(start); + t.setLength(pos - start); // FIXME check if this + 1 make sense ? + // System.out.println("pos = " + start + " length = " + (pos - start + 1)); + t.setId(id++); + // System.out.println("id = " + t.getId()); + ActionsIoUtils.pb_mappings.put(t, element); + } +} diff --git a/gen.pb/src/main/java/fast/.Fast.java.swp b/gen.pb/src/main/java/fast/.Fast.java.swp new file mode 100644 index 000000000..0eb2f1b2d Binary files /dev/null and b/gen.pb/src/main/java/fast/.Fast.java.swp differ diff --git a/gen.pb/src/main/java/fast/Fast.java b/gen.pb/src/main/java/fast/Fast.java new file mode 100644 index 000000000..f65cc29a1 --- /dev/null +++ b/gen.pb/src/main/java/fast/Fast.java @@ -0,0 +1,37323 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: fast.proto + +package fast; + +public final class Fast { + private Fast() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + /** + * Protobuf enum {@code fast.SmaliKind} + */ + public enum SmaliKind + implements com.google.protobuf.ProtocolMessageEnum { + /** + * smali_file = 0; + */ + smali_file(0), + /** + * class_spec = 1; + */ + class_spec(1), + /** + * super_spec = 2; + */ + super_spec(2), + /** + * implements_spec = 3; + */ + implements_spec(3), + /** + * source_spec = 4; + */ + source_spec(4), + /** + * access_list = 5; + */ + access_list(5), + /** + * field = 6; + */ + field(6), + /** + * method = 7; + */ + method(7), + /** + * statements_and_directives = 8; + */ + statements_and_directives(8), + /** + * ordered_method_item = 9; + */ + ordered_method_item(9), + /** + * registers_directive = 10; + */ + registers_directive(10), + /** + * param_list_or_id = 11; + */ + param_list_or_id(11), + /** + * simple_name = 12; + */ + simple_name(12), + /** + * member_name = 13; + */ + member_name(13), + /** + * method_prototype = 14; + */ + method_prototype(14), + /** + * param_list_or_id_primitive_type = 15; + */ + param_list_or_id_primitive_type(15), + /** + * param_list = 16; + */ + param_list(16), + /** + * array_descriptor = 17; + */ + array_descriptor(17), + /** + * type_descriptor = 18; + */ + type_descriptor(18), + /** + * nonvoid_type_descriptor = 19; + */ + nonvoid_type_descriptor(19), + /** + * reference_type_descriptor = 20; + */ + reference_type_descriptor(20), + /** + * integer_literal = 21; + */ + integer_literal(21), + /** + * float_literal = 22; + */ + float_literal(22), + /** + * double_literal = 23; + */ + double_literal(23), + /** + * literal = 24; + */ + literal(24), + /** + * parsed_integer_literal = 25; + */ + parsed_integer_literal(25), + /** + * integral_literal = 26; + */ + integral_literal(26), + /** + * fixed_32bit_literal = 27; + */ + fixed_32bit_literal(27), + /** + * fixed_literal = 28; + */ + fixed_literal(28), + /** + * array_literal = 29; + */ + array_literal(29), + /** + * annotation_element = 30; + */ + annotation_element(30), + /** + * annotation = 31; + */ + annotation(31), + /** + * subannotation = 32; + */ + subannotation(32), + /** + * enum_literal = 33; + */ + enum_literal(33), + /** + * type_field_method_literal = 34; + */ + type_field_method_literal(34), + /** + * method_reference = 35; + */ + method_reference(35), + /** + * field_reference = 36; + */ + field_reference(36), + /** + * label = 37; + */ + label(37), + /** + * label_ref = 38; + */ + label_ref(38), + /** + * register_list = 39; + */ + register_list(39), + /** + * register_range = 40; + */ + register_range(40), + /** + * verification_error_reference = 41; + */ + verification_error_reference(41), + /** + * catch_directive = 42; + */ + catch_directive(42), + /** + * catchall_directive = 43; + */ + catchall_directive(43), + /** + * parameter_directive = 44; + */ + parameter_directive(44), + /** + * debug_directive = 45; + */ + debug_directive(45), + /** + * line_directive = 46; + */ + line_directive(46), + /** + * local_directive = 47; + */ + local_directive(47), + /** + * end_local_directive = 48; + */ + end_local_directive(48), + /** + * restart_local_directive = 49; + */ + restart_local_directive(49), + /** + * prologue_directive = 50; + */ + prologue_directive(50), + /** + * epilogue_directive = 51; + */ + epilogue_directive(51), + /** + * source_directive = 52; + */ + source_directive(52), + /** + * instruction_format12x = 53; + */ + instruction_format12x(53), + /** + * instruction_format22s = 54; + */ + instruction_format22s(54), + /** + * instruction_format31i = 55; + */ + instruction_format31i(55), + /** + * instruction = 56; + */ + instruction(56), + /** + * insn_format10t = 57; + */ + insn_format10t(57), + /** + * insn_format10x = 58; + */ + insn_format10x(58), + /** + * insn_format10x_odex = 59; + */ + insn_format10x_odex(59), + /** + * insn_format11n = 60; + */ + insn_format11n(60), + /** + * insn_format11x = 61; + */ + insn_format11x(61), + /** + * insn_format12x = 62; + */ + insn_format12x(62), + /** + * insn_format20bc = 63; + */ + insn_format20bc(63), + /** + * insn_format20t = 64; + */ + insn_format20t(64), + /** + * insn_format21c_field = 65; + */ + insn_format21c_field(65), + /** + * insn_format21c_field_odex = 66; + */ + insn_format21c_field_odex(66), + /** + * insn_format21c_string = 67; + */ + insn_format21c_string(67), + /** + * insn_format21c_type = 68; + */ + insn_format21c_type(68), + /** + * insn_format21ih = 69; + */ + insn_format21ih(69), + /** + * insn_format21lh = 70; + */ + insn_format21lh(70), + /** + * insn_format21s = 71; + */ + insn_format21s(71), + /** + * insn_format21t = 72; + */ + insn_format21t(72), + /** + * insn_format22b = 73; + */ + insn_format22b(73), + /** + * insn_format22c_field = 74; + */ + insn_format22c_field(74), + /** + * insn_format22c_field_odex = 75; + */ + insn_format22c_field_odex(75), + /** + * insn_format22c_type = 76; + */ + insn_format22c_type(76), + /** + * insn_format22cs_field = 77; + */ + insn_format22cs_field(77), + /** + * insn_format22s = 78; + */ + insn_format22s(78), + /** + * insn_format22t = 79; + */ + insn_format22t(79), + /** + * insn_format22x = 80; + */ + insn_format22x(80), + /** + * insn_format23x = 81; + */ + insn_format23x(81), + /** + * insn_format30t = 82; + */ + insn_format30t(82), + /** + * insn_format31c = 83; + */ + insn_format31c(83), + /** + * insn_format31i = 84; + */ + insn_format31i(84), + /** + * insn_format31t = 85; + */ + insn_format31t(85), + /** + * insn_format32x = 86; + */ + insn_format32x(86), + /** + * insn_format35c_method = 87; + */ + insn_format35c_method(87), + /** + * insn_format35c_type = 88; + */ + insn_format35c_type(88), + /** + * insn_format35c_method_odex = 89; + */ + insn_format35c_method_odex(89), + /** + * insn_format35mi_method = 90; + */ + insn_format35mi_method(90), + /** + * insn_format35ms_method = 91; + */ + insn_format35ms_method(91), + /** + * insn_format3rc_method = 92; + */ + insn_format3rc_method(92), + /** + * insn_format3rc_method_odex = 93; + */ + insn_format3rc_method_odex(93), + /** + * insn_format3rc_type = 94; + */ + insn_format3rc_type(94), + /** + * insn_format3rmi_method = 95; + */ + insn_format3rmi_method(95), + /** + * insn_format3rms_method = 96; + */ + insn_format3rms_method(96), + /** + * insn_format45cc_method = 97; + */ + insn_format45cc_method(97), + /** + * insn_format4rcc_method = 98; + */ + insn_format4rcc_method(98), + /** + * insn_format51l = 99; + */ + insn_format51l(99), + /** + * insn_array_data_directive = 100; + */ + insn_array_data_directive(100), + /** + * insn_packed_switch_directive = 101; + */ + insn_packed_switch_directive(101), + /** + * insn_sparse_switch_directive = 102; + */ + insn_sparse_switch_directive(102), + UNRECOGNIZED(-1), + ; + + /** + * smali_file = 0; + */ + public static final int smali_file_VALUE = 0; + /** + * class_spec = 1; + */ + public static final int class_spec_VALUE = 1; + /** + * super_spec = 2; + */ + public static final int super_spec_VALUE = 2; + /** + * implements_spec = 3; + */ + public static final int implements_spec_VALUE = 3; + /** + * source_spec = 4; + */ + public static final int source_spec_VALUE = 4; + /** + * access_list = 5; + */ + public static final int access_list_VALUE = 5; + /** + * field = 6; + */ + public static final int field_VALUE = 6; + /** + * method = 7; + */ + public static final int method_VALUE = 7; + /** + * statements_and_directives = 8; + */ + public static final int statements_and_directives_VALUE = 8; + /** + * ordered_method_item = 9; + */ + public static final int ordered_method_item_VALUE = 9; + /** + * registers_directive = 10; + */ + public static final int registers_directive_VALUE = 10; + /** + * param_list_or_id = 11; + */ + public static final int param_list_or_id_VALUE = 11; + /** + * simple_name = 12; + */ + public static final int simple_name_VALUE = 12; + /** + * member_name = 13; + */ + public static final int member_name_VALUE = 13; + /** + * method_prototype = 14; + */ + public static final int method_prototype_VALUE = 14; + /** + * param_list_or_id_primitive_type = 15; + */ + public static final int param_list_or_id_primitive_type_VALUE = 15; + /** + * param_list = 16; + */ + public static final int param_list_VALUE = 16; + /** + * array_descriptor = 17; + */ + public static final int array_descriptor_VALUE = 17; + /** + * type_descriptor = 18; + */ + public static final int type_descriptor_VALUE = 18; + /** + * nonvoid_type_descriptor = 19; + */ + public static final int nonvoid_type_descriptor_VALUE = 19; + /** + * reference_type_descriptor = 20; + */ + public static final int reference_type_descriptor_VALUE = 20; + /** + * integer_literal = 21; + */ + public static final int integer_literal_VALUE = 21; + /** + * float_literal = 22; + */ + public static final int float_literal_VALUE = 22; + /** + * double_literal = 23; + */ + public static final int double_literal_VALUE = 23; + /** + * literal = 24; + */ + public static final int literal_VALUE = 24; + /** + * parsed_integer_literal = 25; + */ + public static final int parsed_integer_literal_VALUE = 25; + /** + * integral_literal = 26; + */ + public static final int integral_literal_VALUE = 26; + /** + * fixed_32bit_literal = 27; + */ + public static final int fixed_32bit_literal_VALUE = 27; + /** + * fixed_literal = 28; + */ + public static final int fixed_literal_VALUE = 28; + /** + * array_literal = 29; + */ + public static final int array_literal_VALUE = 29; + /** + * annotation_element = 30; + */ + public static final int annotation_element_VALUE = 30; + /** + * annotation = 31; + */ + public static final int annotation_VALUE = 31; + /** + * subannotation = 32; + */ + public static final int subannotation_VALUE = 32; + /** + * enum_literal = 33; + */ + public static final int enum_literal_VALUE = 33; + /** + * type_field_method_literal = 34; + */ + public static final int type_field_method_literal_VALUE = 34; + /** + * method_reference = 35; + */ + public static final int method_reference_VALUE = 35; + /** + * field_reference = 36; + */ + public static final int field_reference_VALUE = 36; + /** + * label = 37; + */ + public static final int label_VALUE = 37; + /** + * label_ref = 38; + */ + public static final int label_ref_VALUE = 38; + /** + * register_list = 39; + */ + public static final int register_list_VALUE = 39; + /** + * register_range = 40; + */ + public static final int register_range_VALUE = 40; + /** + * verification_error_reference = 41; + */ + public static final int verification_error_reference_VALUE = 41; + /** + * catch_directive = 42; + */ + public static final int catch_directive_VALUE = 42; + /** + * catchall_directive = 43; + */ + public static final int catchall_directive_VALUE = 43; + /** + * parameter_directive = 44; + */ + public static final int parameter_directive_VALUE = 44; + /** + * debug_directive = 45; + */ + public static final int debug_directive_VALUE = 45; + /** + * line_directive = 46; + */ + public static final int line_directive_VALUE = 46; + /** + * local_directive = 47; + */ + public static final int local_directive_VALUE = 47; + /** + * end_local_directive = 48; + */ + public static final int end_local_directive_VALUE = 48; + /** + * restart_local_directive = 49; + */ + public static final int restart_local_directive_VALUE = 49; + /** + * prologue_directive = 50; + */ + public static final int prologue_directive_VALUE = 50; + /** + * epilogue_directive = 51; + */ + public static final int epilogue_directive_VALUE = 51; + /** + * source_directive = 52; + */ + public static final int source_directive_VALUE = 52; + /** + * instruction_format12x = 53; + */ + public static final int instruction_format12x_VALUE = 53; + /** + * instruction_format22s = 54; + */ + public static final int instruction_format22s_VALUE = 54; + /** + * instruction_format31i = 55; + */ + public static final int instruction_format31i_VALUE = 55; + /** + * instruction = 56; + */ + public static final int instruction_VALUE = 56; + /** + * insn_format10t = 57; + */ + public static final int insn_format10t_VALUE = 57; + /** + * insn_format10x = 58; + */ + public static final int insn_format10x_VALUE = 58; + /** + * insn_format10x_odex = 59; + */ + public static final int insn_format10x_odex_VALUE = 59; + /** + * insn_format11n = 60; + */ + public static final int insn_format11n_VALUE = 60; + /** + * insn_format11x = 61; + */ + public static final int insn_format11x_VALUE = 61; + /** + * insn_format12x = 62; + */ + public static final int insn_format12x_VALUE = 62; + /** + * insn_format20bc = 63; + */ + public static final int insn_format20bc_VALUE = 63; + /** + * insn_format20t = 64; + */ + public static final int insn_format20t_VALUE = 64; + /** + * insn_format21c_field = 65; + */ + public static final int insn_format21c_field_VALUE = 65; + /** + * insn_format21c_field_odex = 66; + */ + public static final int insn_format21c_field_odex_VALUE = 66; + /** + * insn_format21c_string = 67; + */ + public static final int insn_format21c_string_VALUE = 67; + /** + * insn_format21c_type = 68; + */ + public static final int insn_format21c_type_VALUE = 68; + /** + * insn_format21ih = 69; + */ + public static final int insn_format21ih_VALUE = 69; + /** + * insn_format21lh = 70; + */ + public static final int insn_format21lh_VALUE = 70; + /** + * insn_format21s = 71; + */ + public static final int insn_format21s_VALUE = 71; + /** + * insn_format21t = 72; + */ + public static final int insn_format21t_VALUE = 72; + /** + * insn_format22b = 73; + */ + public static final int insn_format22b_VALUE = 73; + /** + * insn_format22c_field = 74; + */ + public static final int insn_format22c_field_VALUE = 74; + /** + * insn_format22c_field_odex = 75; + */ + public static final int insn_format22c_field_odex_VALUE = 75; + /** + * insn_format22c_type = 76; + */ + public static final int insn_format22c_type_VALUE = 76; + /** + * insn_format22cs_field = 77; + */ + public static final int insn_format22cs_field_VALUE = 77; + /** + * insn_format22s = 78; + */ + public static final int insn_format22s_VALUE = 78; + /** + * insn_format22t = 79; + */ + public static final int insn_format22t_VALUE = 79; + /** + * insn_format22x = 80; + */ + public static final int insn_format22x_VALUE = 80; + /** + * insn_format23x = 81; + */ + public static final int insn_format23x_VALUE = 81; + /** + * insn_format30t = 82; + */ + public static final int insn_format30t_VALUE = 82; + /** + * insn_format31c = 83; + */ + public static final int insn_format31c_VALUE = 83; + /** + * insn_format31i = 84; + */ + public static final int insn_format31i_VALUE = 84; + /** + * insn_format31t = 85; + */ + public static final int insn_format31t_VALUE = 85; + /** + * insn_format32x = 86; + */ + public static final int insn_format32x_VALUE = 86; + /** + * insn_format35c_method = 87; + */ + public static final int insn_format35c_method_VALUE = 87; + /** + * insn_format35c_type = 88; + */ + public static final int insn_format35c_type_VALUE = 88; + /** + * insn_format35c_method_odex = 89; + */ + public static final int insn_format35c_method_odex_VALUE = 89; + /** + * insn_format35mi_method = 90; + */ + public static final int insn_format35mi_method_VALUE = 90; + /** + * insn_format35ms_method = 91; + */ + public static final int insn_format35ms_method_VALUE = 91; + /** + * insn_format3rc_method = 92; + */ + public static final int insn_format3rc_method_VALUE = 92; + /** + * insn_format3rc_method_odex = 93; + */ + public static final int insn_format3rc_method_odex_VALUE = 93; + /** + * insn_format3rc_type = 94; + */ + public static final int insn_format3rc_type_VALUE = 94; + /** + * insn_format3rmi_method = 95; + */ + public static final int insn_format3rmi_method_VALUE = 95; + /** + * insn_format3rms_method = 96; + */ + public static final int insn_format3rms_method_VALUE = 96; + /** + * insn_format45cc_method = 97; + */ + public static final int insn_format45cc_method_VALUE = 97; + /** + * insn_format4rcc_method = 98; + */ + public static final int insn_format4rcc_method_VALUE = 98; + /** + * insn_format51l = 99; + */ + public static final int insn_format51l_VALUE = 99; + /** + * insn_array_data_directive = 100; + */ + public static final int insn_array_data_directive_VALUE = 100; + /** + * insn_packed_switch_directive = 101; + */ + public static final int insn_packed_switch_directive_VALUE = 101; + /** + * insn_sparse_switch_directive = 102; + */ + public static final int insn_sparse_switch_directive_VALUE = 102; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static SmaliKind valueOf(int value) { + return forNumber(value); + } + + public static SmaliKind forNumber(int value) { + switch (value) { + case 0: return smali_file; + case 1: return class_spec; + case 2: return super_spec; + case 3: return implements_spec; + case 4: return source_spec; + case 5: return access_list; + case 6: return field; + case 7: return method; + case 8: return statements_and_directives; + case 9: return ordered_method_item; + case 10: return registers_directive; + case 11: return param_list_or_id; + case 12: return simple_name; + case 13: return member_name; + case 14: return method_prototype; + case 15: return param_list_or_id_primitive_type; + case 16: return param_list; + case 17: return array_descriptor; + case 18: return type_descriptor; + case 19: return nonvoid_type_descriptor; + case 20: return reference_type_descriptor; + case 21: return integer_literal; + case 22: return float_literal; + case 23: return double_literal; + case 24: return literal; + case 25: return parsed_integer_literal; + case 26: return integral_literal; + case 27: return fixed_32bit_literal; + case 28: return fixed_literal; + case 29: return array_literal; + case 30: return annotation_element; + case 31: return annotation; + case 32: return subannotation; + case 33: return enum_literal; + case 34: return type_field_method_literal; + case 35: return method_reference; + case 36: return field_reference; + case 37: return label; + case 38: return label_ref; + case 39: return register_list; + case 40: return register_range; + case 41: return verification_error_reference; + case 42: return catch_directive; + case 43: return catchall_directive; + case 44: return parameter_directive; + case 45: return debug_directive; + case 46: return line_directive; + case 47: return local_directive; + case 48: return end_local_directive; + case 49: return restart_local_directive; + case 50: return prologue_directive; + case 51: return epilogue_directive; + case 52: return source_directive; + case 53: return instruction_format12x; + case 54: return instruction_format22s; + case 55: return instruction_format31i; + case 56: return instruction; + case 57: return insn_format10t; + case 58: return insn_format10x; + case 59: return insn_format10x_odex; + case 60: return insn_format11n; + case 61: return insn_format11x; + case 62: return insn_format12x; + case 63: return insn_format20bc; + case 64: return insn_format20t; + case 65: return insn_format21c_field; + case 66: return insn_format21c_field_odex; + case 67: return insn_format21c_string; + case 68: return insn_format21c_type; + case 69: return insn_format21ih; + case 70: return insn_format21lh; + case 71: return insn_format21s; + case 72: return insn_format21t; + case 73: return insn_format22b; + case 74: return insn_format22c_field; + case 75: return insn_format22c_field_odex; + case 76: return insn_format22c_type; + case 77: return insn_format22cs_field; + case 78: return insn_format22s; + case 79: return insn_format22t; + case 80: return insn_format22x; + case 81: return insn_format23x; + case 82: return insn_format30t; + case 83: return insn_format31c; + case 84: return insn_format31i; + case 85: return insn_format31t; + case 86: return insn_format32x; + case 87: return insn_format35c_method; + case 88: return insn_format35c_type; + case 89: return insn_format35c_method_odex; + case 90: return insn_format35mi_method; + case 91: return insn_format35ms_method; + case 92: return insn_format3rc_method; + case 93: return insn_format3rc_method_odex; + case 94: return insn_format3rc_type; + case 95: return insn_format3rmi_method; + case 96: return insn_format3rms_method; + case 97: return insn_format45cc_method; + case 98: return insn_format4rcc_method; + case 99: return insn_format51l; + case 100: return insn_array_data_directive; + case 101: return insn_packed_switch_directive; + case 102: return insn_sparse_switch_directive; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + SmaliKind> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public SmaliKind findValueByNumber(int number) { + return SmaliKind.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.getDescriptor().getEnumTypes().get(0); + } + + private static final SmaliKind[] VALUES = values(); + + public static SmaliKind valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private SmaliKind(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.SmaliKind) + } + + public interface ElementOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Element) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     * default to srcML
+     *
+ * + * .fast.Element.Kind kind = 1; + */ + int getKindValue(); + /** + * 
+     * default to srcML
+     *
+ * + * .fast.Element.Kind kind = 1; + */ + fast.Fast.Element.Kind getKind(); + + /** + * .fast.SmaliKind smali_kind = 2; + */ + int getSmaliKindValue(); + /** + * .fast.SmaliKind smali_kind = 2; + */ + fast.Fast.SmaliKind getSmaliKind(); + + /** + * bytes text = 3; + */ + com.google.protobuf.ByteString getText(); + + /** + * int32 pos = 4; + */ + int getPos(); + + /** + * int32 length = 5; + */ + int getLength(); + + /** + * repeated .fast.Element child = 6; + */ + java.util.List + getChildList(); + /** + * repeated .fast.Element child = 6; + */ + fast.Fast.Element getChild(int index); + /** + * repeated .fast.Element child = 6; + */ + int getChildCount(); + /** + * repeated .fast.Element child = 6; + */ + java.util.List + getChildOrBuilderList(); + /** + * repeated .fast.Element child = 6; + */ + fast.Fast.ElementOrBuilder getChildOrBuilder( + int index); + + /** + * bytes tail = 7; + */ + com.google.protobuf.ByteString getTail(); + + /** + * .fast.Element.Unit unit = 8; + */ + fast.Fast.Element.Unit getUnit(); + /** + * .fast.Element.Unit unit = 8; + */ + fast.Fast.Element.UnitOrBuilder getUnitOrBuilder(); + + /** + * .fast.Element.Literal literal = 9; + */ + fast.Fast.Element.Literal getLiteral(); + /** + * .fast.Element.Literal literal = 9; + */ + fast.Fast.Element.LiteralOrBuilder getLiteralOrBuilder(); + + /** + * int32 line = 10; + */ + int getLine(); + + /** + * int32 column = 11; + */ + int getColumn(); + + /** + * float label = 12; + */ + float getLabel(); + + /** + * .fast.Element.DiffType change = 13; + */ + int getChangeValue(); + /** + * .fast.Element.DiffType change = 13; + */ + fast.Fast.Element.DiffType getChange(); + + public fast.Fast.Element.TypeCase getTypeCase(); + + public fast.Fast.Element.ExtraCase getExtraCase(); + } + /** + * 
+   * smali generated by ANTLR4-CPP
+   *
+ * + * Protobuf type {@code fast.Element} + */ + public static final class Element extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Element) + ElementOrBuilder { + // Use Element.newBuilder() to construct. + private Element(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Element() { + text_ = com.google.protobuf.ByteString.EMPTY; + pos_ = 0; + length_ = 0; + child_ = java.util.Collections.emptyList(); + tail_ = com.google.protobuf.ByteString.EMPTY; + line_ = 0; + column_ = 0; + label_ = 0F; + change_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Element( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + typeCase_ = 1; + type_ = rawValue; + break; + } + case 16: { + int rawValue = input.readEnum(); + typeCase_ = 2; + type_ = rawValue; + break; + } + case 26: { + + text_ = input.readBytes(); + break; + } + case 32: { + + pos_ = input.readInt32(); + break; + } + case 40: { + + length_ = input.readInt32(); + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + child_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + child_.add( + input.readMessage(fast.Fast.Element.parser(), extensionRegistry)); + break; + } + case 58: { + + tail_ = input.readBytes(); + break; + } + case 66: { + fast.Fast.Element.Unit.Builder subBuilder = null; + if (extraCase_ == 8) { + subBuilder = ((fast.Fast.Element.Unit) extra_).toBuilder(); + } + extra_ = + input.readMessage(fast.Fast.Element.Unit.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Element.Unit) extra_); + extra_ = subBuilder.buildPartial(); + } + extraCase_ = 8; + break; + } + case 74: { + fast.Fast.Element.Literal.Builder subBuilder = null; + if (extraCase_ == 9) { + subBuilder = ((fast.Fast.Element.Literal) extra_).toBuilder(); + } + extra_ = + input.readMessage(fast.Fast.Element.Literal.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Element.Literal) extra_); + extra_ = subBuilder.buildPartial(); + } + extraCase_ = 9; + break; + } + case 80: { + + line_ = input.readInt32(); + break; + } + case 88: { + + column_ = input.readInt32(); + break; + } + case 101: { + + label_ = input.readFloat(); + break; + } + case 104: { + int rawValue = input.readEnum(); + + change_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + child_ = java.util.Collections.unmodifiableList(child_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.class, fast.Fast.Element.Builder.class); + } + + /** + * 
+     * srcML
+     *
+ * + * Protobuf enum {@code fast.Element.Kind} + */ + public enum Kind + implements com.google.protobuf.ProtocolMessageEnum { + /** + * UNIT_KIND = 0; + */ + UNIT_KIND(0), + /** + * DECL = 1; + */ + DECL(1), + /** + * DECL_STMT = 2; + */ + DECL_STMT(2), + /** + * INIT = 3; + */ + INIT(3), + /** + * EXPR = 4; + */ + EXPR(4), + /** + * EXPR_STMT = 5; + */ + EXPR_STMT(5), + /** + * COMMENT = 6; + */ + COMMENT(6), + /** + * CALL = 7; + */ + CALL(7), + /** + * CONTROL = 8; + */ + CONTROL(8), + /** + * INCR = 9; + */ + INCR(9), + /** + * NONE = 10; + */ + NONE(10), + /** + * VARIABLE = 11; + */ + VARIABLE(11), + /** + * FUNCTION = 12; + */ + FUNCTION(12), + /** + * FUNCTION_DECL = 13; + */ + FUNCTION_DECL(13), + /** + * CONSTRUCTOR = 14; + */ + CONSTRUCTOR(14), + /** + * CONSTRUCTOR_DECL = 15; + */ + CONSTRUCTOR_DECL(15), + /** + * DESTRUCTOR = 16; + */ + DESTRUCTOR(16), + /** + * DESTRUCTOR_DECL = 17; + */ + DESTRUCTOR_DECL(17), + /** + * MACRO = 18; + */ + MACRO(18), + /** + * SINGLE_MACRO = 19; + */ + SINGLE_MACRO(19), + /** + * NULLOPERATOR = 20; + */ + NULLOPERATOR(20), + /** + * ENUM_DEFN = 21; + */ + ENUM_DEFN(21), + /** + * ENUM_DECL = 22; + */ + ENUM_DECL(22), + /** + * GLOBAL_ATTRIBUTE = 23; + */ + GLOBAL_ATTRIBUTE(23), + /** + * PROPERTY_ACCESSOR = 24; + */ + PROPERTY_ACCESSOR(24), + /** + * PROPERTY_ACCESSOR_DECL = 25; + */ + PROPERTY_ACCESSOR_DECL(25), + /** + * EXPRESSION = 26; + */ + EXPRESSION(26), + /** + * CLASS_DEFN = 27; + */ + CLASS_DEFN(27), + /** + * CLASS_DECL = 28; + */ + CLASS_DECL(28), + /** + * UNION_DEFN = 29; + */ + UNION_DEFN(29), + /** + * UNION_DECL = 30; + */ + UNION_DECL(30), + /** + * STRUCT_DEFN = 31; + */ + STRUCT_DEFN(31), + /** + * STRUCT_DECL = 32; + */ + STRUCT_DECL(32), + /** + * INTERFACE_DEFN = 33; + */ + INTERFACE_DEFN(33), + /** + * INTERFACE_DECL = 34; + */ + INTERFACE_DECL(34), + /** + * ACCESS_REGION = 35; + */ + ACCESS_REGION(35), + /** + * USING = 36; + */ + USING(36), + /** + * OPERATOR_FUNCTION = 37; + */ + OPERATOR_FUNCTION(37), + /** + * OPERATOR_FUNCTION_DECL = 38; + */ + OPERATOR_FUNCTION_DECL(38), + /** + * EVENT = 39; + */ + EVENT(39), + /** + * PROPERTY = 40; + */ + PROPERTY(40), + /** + * ANNOTATION_DEFN = 41; + */ + ANNOTATION_DEFN(41), + /** + * GLOBAL_TEMPLATE = 42; + */ + GLOBAL_TEMPLATE(42), + /** + * 
+       * entire source file
+       *
+ * + * UNIT = 43; + */ + UNIT(43), + /** + * 
+       * First token used for boundary
+       *
+ * + * TART_ELEMENT_TOKEN = 44; + */ + TART_ELEMENT_TOKEN(44), + /** + * 
+       * No output at all.  Only a placeholder
+       *
+ * + * NOP = 45; + */ + NOP(45), + /** + * 
+       * literal types
+       *
+ * + * STRING = 46; + */ + STRING(46), + /** + * 
+       * string or char marked by single quotes
+       *
+ * + * CHAR = 47; + */ + CHAR(47), + /** + * 
+       * literal number, constant
+       *
+ * + * LITERAL = 48; + */ + LITERAL(48), + /** + * 
+       * boolean literal, i.e., true, false
+       *
+ * + * BOOLEAN = 49; + */ + BOOLEAN(49), + /** + * 
+       * null types null, nullptr
+       *
+ * + * NULL = 50; + */ + NULL(50), + /** + * 
+       * complex numbers
+       *
+ * + * COMPLEX = 51; + */ + COMPLEX(51), + /** + * 
+       * operators
+       *
+ * + * OPERATOR = 52; + */ + OPERATOR(52), + /** + * 
+       * type modifiers
+       *
+ * + * MODIFIER = 53; + */ + MODIFIER(53), + /** + * 
+       * internal statement elements used in multiple statements
+       *
+ * + * NAME = 54; + */ + NAME(54), + /** + * ONAME = 55; + */ + ONAME(55), + /** + * CNAME = 56; + */ + CNAME(56), + /** + * TYPE = 57; + */ + TYPE(57), + /** + * TYPEPREV = 58; + */ + TYPEPREV(58), + /** + * CONDITION = 59; + */ + CONDITION(59), + /** + * BLOCK = 60; + */ + BLOCK(60), + /** + * PSEUDO_BLOCK = 61; + */ + PSEUDO_BLOCK(61), + /** + * INDEX = 62; + */ + INDEX(62), + /** + * 
+       * statements
+       *
+ * + * ENUM = 63; + */ + ENUM(63), + /** + * ENUM_DECLARATION = 64; + */ + ENUM_DECLARATION(64), + /** + * IF_STATEMENT = 65; + */ + IF_STATEMENT(65), + /** + * TERNARY = 66; + */ + TERNARY(66), + /** + * THEN = 67; + */ + THEN(67), + /** + * ELSE = 68; + */ + ELSE(68), + /** + * ELSEIF = 69; + */ + ELSEIF(69), + /** + * WHILE_STATEMENT = 70; + */ + WHILE_STATEMENT(70), + /** + * DO_STATEMENT = 71; + */ + DO_STATEMENT(71), + /** + * FOR_STATEMENT = 72; + */ + FOR_STATEMENT(72), + /** + * FOREACH_STATEMENT = 73; + */ + FOREACH_STATEMENT(73), + /** + * FOR_CONTROL = 74; + */ + FOR_CONTROL(74), + /** + * FOR_INITIALIZATION = 75; + */ + FOR_INITIALIZATION(75), + /** + * FOR_CONDITION = 76; + */ + FOR_CONDITION(76), + /** + * FOR_INCREMENT = 77; + */ + FOR_INCREMENT(77), + /** + * FOR_LIKE_CONTROL = 78; + */ + FOR_LIKE_CONTROL(78), + /** + * EXPRESSION_STATEMENT = 79; + */ + EXPRESSION_STATEMENT(79), + /** + * 
+       * EXPRESSION = 80;
+       *
+ * + * FUNCTION_CALL = 81; + */ + FUNCTION_CALL(81), + /** + * DECLARATION_STATEMENT = 82; + */ + DECLARATION_STATEMENT(82), + /** + * DECLARATION = 83; + */ + DECLARATION(83), + /** + * DECLARATION_INITIALIZATION = 84; + */ + DECLARATION_INITIALIZATION(84), + /** + * DECLARATION_RANGE = 85; + */ + DECLARATION_RANGE(85), + /** + * RANGE = 86; + */ + RANGE(86), + /** + * GOTO_STATEMENT = 87; + */ + GOTO_STATEMENT(87), + /** + * CONTINUE_STATEMENT = 88; + */ + CONTINUE_STATEMENT(88), + /** + * BREAK_STATEMENT = 89; + */ + BREAK_STATEMENT(89), + /** + * LABEL_STATEMENT = 90; + */ + LABEL_STATEMENT(90), + /** + * LABEL = 91; + */ + LABEL(91), + /** + * SWITCH = 92; + */ + SWITCH(92), + /** + * CASE = 93; + */ + CASE(93), + /** + * DEFAULT = 94; + */ + DEFAULT(94), + /** + * 
+       * functions
+       *
+ * + * FUNCTION_DEFINITION = 95; + */ + FUNCTION_DEFINITION(95), + /** + * FUNCTION_DECLARATION = 96; + */ + FUNCTION_DECLARATION(96), + /** + * LAMBDA = 97; + */ + LAMBDA(97), + /** + * FUNCTION_LAMBDA = 98; + */ + FUNCTION_LAMBDA(98), + /** + * FUNCTION_SPECIFIER = 99; + */ + FUNCTION_SPECIFIER(99), + /** + * RETURN_STATEMENT = 100; + */ + RETURN_STATEMENT(100), + /** + * PARAMETER_LIST = 101; + */ + PARAMETER_LIST(101), + /** + * PARAMETER = 102; + */ + PARAMETER(102), + /** + * KRPARAMETER_LIST = 103; + */ + KRPARAMETER_LIST(103), + /** + * KRPARAMETER = 104; + */ + KRPARAMETER(104), + /** + * ARGUMENT_LIST = 105; + */ + ARGUMENT_LIST(105), + /** + * ARGUMENT = 106; + */ + ARGUMENT(106), + /** + * PSEUDO_PARAMETER_LIST = 107; + */ + PSEUDO_PARAMETER_LIST(107), + /** + * INDEXER_PARAMETER_LIST = 108; + */ + INDEXER_PARAMETER_LIST(108), + /** + * 
+       * class, struct, union
+       *
+ * + * CLASS = 109; + */ + CLASS(109), + /** + * CLASS_DECLARATION = 110; + */ + CLASS_DECLARATION(110), + /** + * STRUCT = 111; + */ + STRUCT(111), + /** + * STRUCT_DECLARATION = 112; + */ + STRUCT_DECLARATION(112), + /** + * UNION = 113; + */ + UNION(113), + /** + * UNION_DECLARATION = 114; + */ + UNION_DECLARATION(114), + /** + * DERIVATION_LIST = 115; + */ + DERIVATION_LIST(115), + /** + * PUBLIC_ACCESS = 116; + */ + PUBLIC_ACCESS(116), + /** + * PUBLIC_ACCESS_DEFAULT = 117; + */ + PUBLIC_ACCESS_DEFAULT(117), + /** + * PRIVATE_ACCESS = 118; + */ + PRIVATE_ACCESS(118), + /** + * PRIVATE_ACCESS_DEFAULT = 119; + */ + PRIVATE_ACCESS_DEFAULT(119), + /** + * PROTECTED_ACCESS = 120; + */ + PROTECTED_ACCESS(120), + /** + * PROTECTED_ACCESS_DEFAULT = 121; + */ + PROTECTED_ACCESS_DEFAULT(121), + /** + * MEMBER_INIT_LIST = 122; + */ + MEMBER_INIT_LIST(122), + /** + * MEMBER_INITIALIZATION_LIST = 123; + */ + MEMBER_INITIALIZATION_LIST(123), + /** + * MEMBER_INITIALIZATION = 124; + */ + MEMBER_INITIALIZATION(124), + /** + * CONSTRUCTOR_DEFINITION = 125; + */ + CONSTRUCTOR_DEFINITION(125), + /** + * CONSTRUCTOR_DECLARATION = 126; + */ + CONSTRUCTOR_DECLARATION(126), + /** + * DESTRUCTOR_DEFINITION = 127; + */ + DESTRUCTOR_DEFINITION(127), + /** + * DESTRUCTOR_DECLARATION = 128; + */ + DESTRUCTOR_DECLARATION(128), + /** + * FRIEND = 129; + */ + FRIEND(129), + /** + * CLASS_SPECIFIER = 130; + */ + CLASS_SPECIFIER(130), + /** + * 
+       * exception handling
+       *
+ * + * TRY_BLOCK = 131; + */ + TRY_BLOCK(131), + /** + * CATCH_BLOCK = 132; + */ + CATCH_BLOCK(132), + /** + * FINALLY_BLOCK = 133; + */ + FINALLY_BLOCK(133), + /** + * THROW_STATEMENT = 134; + */ + THROW_STATEMENT(134), + /** + * THROW_SPECIFIER = 135; + */ + THROW_SPECIFIER(135), + /** + * THROW_SPECIFIER_JAVA = 136; + */ + THROW_SPECIFIER_JAVA(136), + /** + * TEMPLATE = 137; + */ + TEMPLATE(137), + /** + * GENERIC_ARGUMENT = 138; + */ + GENERIC_ARGUMENT(138), + /** + * GENERIC_ARGUMENT_LIST = 139; + */ + GENERIC_ARGUMENT_LIST(139), + /** + * TEMPLATE_PARAMETER = 140; + */ + TEMPLATE_PARAMETER(140), + /** + * TEMPLATE_PARAMETER_LIST = 141; + */ + TEMPLATE_PARAMETER_LIST(141), + /** + * GENERIC_PARAMETER = 142; + */ + GENERIC_PARAMETER(142), + /** + * GENERIC_PARAMETER_LIST = 143; + */ + GENERIC_PARAMETER_LIST(143), + /** + * 
+       * C Family elements
+       *
+ * + * TYPEDEF = 144; + */ + TYPEDEF(144), + /** + * ASM = 145; + */ + ASM(145), + /** + * MACRO_CALL = 146; + */ + MACRO_CALL(146), + /** + * SIZEOF_CALL = 147; + */ + SIZEOF_CALL(147), + /** + * EXTERN = 148; + */ + EXTERN(148), + /** + * NAMESPACE = 149; + */ + NAMESPACE(149), + /** + * USING_DIRECTIVE = 150; + */ + USING_DIRECTIVE(150), + /** + * DIRECTIVE = 151; + */ + DIRECTIVE(151), + /** + * 
+       * C
+       *
+ * + * ATOMIC = 152; + */ + ATOMIC(152), + /** + * STATIC_ASSERT_STATEMENT = 153; + */ + STATIC_ASSERT_STATEMENT(153), + /** + * GENERIC_SELECTION = 154; + */ + GENERIC_SELECTION(154), + /** + * GENERIC_SELECTOR = 155; + */ + GENERIC_SELECTOR(155), + /** + * GENERIC_ASSOCIATION_LIST = 156; + */ + GENERIC_ASSOCIATION_LIST(156), + /** + * GENERIC_ASSOCIATION = 157; + */ + GENERIC_ASSOCIATION(157), + /** + * 
+       * C++
+       *
+ * + * ALIGNAS = 158; + */ + ALIGNAS(158), + /** + * DECLTYPE = 159; + */ + DECLTYPE(159), + /** + * CAPTURE = 160; + */ + CAPTURE(160), + /** + * LAMBDA_CAPTURE = 161; + */ + LAMBDA_CAPTURE(161), + /** + * NOEXCEPT = 162; + */ + NOEXCEPT(162), + /** + * TYPENAME = 163; + */ + TYPENAME(163), + /** + * ALIGNOF = 164; + */ + ALIGNOF(164), + /** + * TYPEID = 165; + */ + TYPEID(165), + /** + * SIZEOF_PACK = 166; + */ + SIZEOF_PACK(166), + /** + * ENUM_CLASS = 167; + */ + ENUM_CLASS(167), + /** + * ENUM_CLASS_DECLARATION = 168; + */ + ENUM_CLASS_DECLARATION(168), + /** + * 
+       * OPERATOR_FUNCTION = 169;
+       * OPERATOR_FUNCTION_DECL = 170;
+       *
+ * + * REF_QUALIFIER = 171; + */ + REF_QUALIFIER(171), + /** + * 
+       * Qt
+       *
+ * + * SIGNAL_ACCESS = 172; + */ + SIGNAL_ACCESS(172), + /** + * FOREVER_STATEMENT = 173; + */ + FOREVER_STATEMENT(173), + /** + * EMIT_STATEMENT = 174; + */ + EMIT_STATEMENT(174), + /** + * 
+       * cpp directive internal elements
+       *
+ * + * CPP_DIRECTIVE = 175; + */ + CPP_DIRECTIVE(175), + /** + * CPP_FILENAME = 176; + */ + CPP_FILENAME(176), + /** + * FILE = 177; + */ + FILE(177), + /** + * NUMBER = 178; + */ + NUMBER(178), + /** + * CPP_NUMBER = 179; + */ + CPP_NUMBER(179), + /** + * CPP_LITERAL = 180; + */ + CPP_LITERAL(180), + /** + * CPP_MACRO_DEFN = 181; + */ + CPP_MACRO_DEFN(181), + /** + * CPP_MACRO_VALUE = 182; + */ + CPP_MACRO_VALUE(182), + /** + * 
+       * cpp directives
+       *
+ * + * ERROR = 183; + */ + ERROR(183), + /** + * CPP_ERROR = 184; + */ + CPP_ERROR(184), + /** + * CPP_WARNING = 185; + */ + CPP_WARNING(185), + /** + * CPP_PRAGMA = 186; + */ + CPP_PRAGMA(186), + /** + * CPP_INCLUDE = 187; + */ + CPP_INCLUDE(187), + /** + * CPP_DEFINE = 188; + */ + CPP_DEFINE(188), + /** + * CPP_UNDEF = 189; + */ + CPP_UNDEF(189), + /** + * CPP_LINE = 190; + */ + CPP_LINE(190), + /** + * CPP_IF = 191; + */ + CPP_IF(191), + /** + * CPP_IFDEF = 192; + */ + CPP_IFDEF(192), + /** + * CPP_IFNDEF = 193; + */ + CPP_IFNDEF(193), + /** + * CPP_THEN = 194; + */ + CPP_THEN(194), + /** + * CPP_ELSE = 195; + */ + CPP_ELSE(195), + /** + * CPP_ELIF = 196; + */ + CPP_ELIF(196), + /** + * CPP_EMPTY = 197; + */ + CPP_EMPTY(197), + /** + * 
+       * C# cpp directives
+       *
+ * + * CPP_REGION = 198; + */ + CPP_REGION(198), + /** + * CPP_ENDREGION = 199; + */ + CPP_ENDREGION(199), + /** + * USING_STMT = 200; + */ + USING_STMT(200), + /** + * ESCAPE = 201; + */ + ESCAPE(201), + /** + * 
+       * Objective-C cpp directives
+       *
+ * + * VALUE = 202; + */ + VALUE(202), + /** + * CPP_IMPORT = 203; + */ + CPP_IMPORT(203), + /** + * 
+       * This HAS to mark the end of the CPP directives
+       *
+ * + * CPP_ENDIF = 204; + */ + CPP_ENDIF(204), + /** + * 
+       * Debug elements
+       *
+ * + * MARKER = 205; + */ + MARKER(205), + /** + * ERROR_PARSE = 206; + */ + ERROR_PARSE(206), + /** + * ERROR_MODE = 207; + */ + ERROR_MODE(207), + /** + * 
+       * Java elements
+       *
+ * + * IMPLEMENTS = 208; + */ + IMPLEMENTS(208), + /** + * EXTENDS = 209; + */ + EXTENDS(209), + /** + * IMPORT = 210; + */ + IMPORT(210), + /** + * PACKAGE = 211; + */ + PACKAGE(211), + /** + * ASSERT_STATEMENT = 212; + */ + ASSERT_STATEMENT(212), + /** + * INTERFACE = 213; + */ + INTERFACE(213), + /** + * INTERFACE_DECLARATION = 214; + */ + INTERFACE_DECLARATION(214), + /** + * SYNCHRONIZED_STATEMENT = 215; + */ + SYNCHRONIZED_STATEMENT(215), + /** + * ANNOTATION = 216; + */ + ANNOTATION(216), + /** + * 
+       * ANNOTATION_DEFN = 217;
+       *
+ * + * STATIC_BLOCK = 218; + */ + STATIC_BLOCK(218), + /** + * 
+       * C#
+       *
+ * + * CHECKED_STATEMENT = 219; + */ + CHECKED_STATEMENT(219), + /** + * UNCHECKED_STATEMENT = 220; + */ + UNCHECKED_STATEMENT(220), + /** + * ATTRIBUTE = 221; + */ + ATTRIBUTE(221), + /** + * TARGET = 222; + */ + TARGET(222), + /** + * UNSAFE_STATEMENT = 223; + */ + UNSAFE_STATEMENT(223), + /** + * LOCK_STATEMENT = 224; + */ + LOCK_STATEMENT(224), + /** + * FIXED_STATEMENT = 225; + */ + FIXED_STATEMENT(225), + /** + * TYPEOF = 226; + */ + TYPEOF(226), + /** + * USING_STATEMENT = 227; + */ + USING_STATEMENT(227), + /** + * FUNCTION_DELEGATE = 228; + */ + FUNCTION_DELEGATE(228), + /** + * 
+       * EVENT = 229;
+       *
+ * + * CONSTRAINT = 230; + */ + CONSTRAINT(230), + /** + * 
+       * linq
+       *
+ * + * LINQ = 231; + */ + LINQ(231), + /** + * FROM = 232; + */ + FROM(232), + /** + * WHERE = 233; + */ + WHERE(233), + /** + * SELECT = 234; + */ + SELECT(234), + /** + * LET = 235; + */ + LET(235), + /** + * ORDERBY = 236; + */ + ORDERBY(236), + /** + * JOIN = 237; + */ + JOIN(237), + /** + * GROUP = 238; + */ + GROUP(238), + /** + * IN = 239; + */ + IN(239), + /** + * ON = 240; + */ + ON(240), + /** + * EQUALS = 241; + */ + EQUALS(241), + /** + * BY = 242; + */ + BY(242), + /** + * INTO = 243; + */ + INTO(243), + /** + * 
+       * misc
+       *
+ * + * EMPTY = 244; + */ + EMPTY(244), + /** + * 
+       * empty statement
+       *
+ * + * EMPTY_STMT = 245; + */ + EMPTY_STMT(245), + /** + * 
+       * Objective-C
+       *
+ * + * RECEIVER = 246; + */ + RECEIVER(246), + /** + * MESSAGE = 247; + */ + MESSAGE(247), + /** + * SELECTOR = 248; + */ + SELECTOR(248), + /** + * PROTOCOL_LIST = 249; + */ + PROTOCOL_LIST(249), + /** + * CATEGORY = 250; + */ + CATEGORY(250), + /** + * PROTOCOL = 251; + */ + PROTOCOL(251), + /** + * REQUIRED_DEFAULT = 252; + */ + REQUIRED_DEFAULT(252), + /** + * REQUIRED = 253; + */ + REQUIRED(253), + /** + * OPTIONAL = 254; + */ + OPTIONAL(254), + /** + * 
+       * PROPERTY = 255;
+       *
+ * + * ATTRIBUTE_LIST = 256; + */ + ATTRIBUTE_LIST(256), + /** + * SYNTHESIZE = 257; + */ + SYNTHESIZE(257), + /** + * DYNAMIC = 258; + */ + DYNAMIC(258), + /** + * ENCODE = 259; + */ + ENCODE(259), + /** + * AUTORELEASEPOOL = 260; + */ + AUTORELEASEPOOL(260), + /** + * COMPATIBILITY_ALIAS = 261; + */ + COMPATIBILITY_ALIAS(261), + /** + * NIL = 262; + */ + NIL(262), + /** + * CLASS_INTERFACE = 263; + */ + CLASS_INTERFACE(263), + /** + * CLASS_IMPLEMENTATION = 264; + */ + CLASS_IMPLEMENTATION(264), + /** + * PROTOCOL_DECLARATION = 265; + */ + PROTOCOL_DECLARATION(265), + /** + * 
+       * casting
+       *
+ * + * CAST = 266; + */ + CAST(266), + /** + * CONST_CAST = 267; + */ + CONST_CAST(267), + /** + * DYNAMIC_CAST = 268; + */ + DYNAMIC_CAST(268), + /** + * REINTERPRET_CAST = 269; + */ + REINTERPRET_CAST(269), + /** + * STATIC_CAST = 270; + */ + STATIC_CAST(270), + /** + * 
+       * srcMLOutput used only
+       *
+ * + * POSITION = 271; + */ + POSITION(271), + /** + * 
+       * Other
+       *
+ * + * CUDA_ARGUMENT_LIST = 272; + */ + CUDA_ARGUMENT_LIST(272), + /** + * 
+       * OpenMP
+       *
+ * + * OMP_DIRECTIVE = 273; + */ + OMP_DIRECTIVE(273), + /** + * OMP_NAME = 274; + */ + OMP_NAME(274), + /** + * OMP_CLAUSE = 275; + */ + OMP_CLAUSE(275), + /** + * OMP_ARGUMENT_LIST = 276; + */ + OMP_ARGUMENT_LIST(276), + /** + * OMP_ARGUMENT = 277; + */ + OMP_ARGUMENT(277), + /** + * OMP_EXPRESSION = 278; + */ + OMP_EXPRESSION(278), + /** + * 
+       * Last token used for boundary
+       *
+ * + * END_ELEMENT_TOKEN = 279; + */ + END_ELEMENT_TOKEN(279), + /** + * 
+       * special identifier
+       *
+ * + * MAIN = 280; + */ + MAIN(280), + /** + * 
+       * statements
+       *
+ * + * BREAK = 281; + */ + BREAK(281), + /** + * CONTINUE = 282; + */ + CONTINUE(282), + /** + * WHILE = 283; + */ + WHILE(283), + /** + * DO = 284; + */ + DO(284), + /** + * FOR = 285; + */ + FOR(285), + /** + * IF = 286; + */ + IF(286), + /** + * 
+       * ELSE = 287;
+       * SWITCH = 288;
+       * CASE = 289;
+       * DEFAULT = 290;
+       * ENUM = 291;
+       * C Family
+       * TYPEDEF = 292;
+       *
+ * + * GOTO = 293; + */ + GOTO(293), + /** + * 
+       * ASM = 294;
+       *
+ * + * VISUAL_CXX_ASM = 295; + */ + VISUAL_CXX_ASM(295), + /** + * SIZEOF = 296; + */ + SIZEOF(296), + /** + * 
+       * EXTERN = 297;
+       *
+ * + * AUTO = 298; + */ + AUTO(298), + /** + * 
+       * C
+       *
+ * + * REGISTER = 299; + */ + REGISTER(299), + /** + * RESTRICT = 300; + */ + RESTRICT(300), + /** + * 
+       * ATOMIC = 301;
+       * COMPLEX = 302;
+       * GENERIC_SELECTION = 303;
+       *
+ * + * IMAGINARY = 304; + */ + IMAGINARY(304), + /** + * NORETURN = 305; + */ + NORETURN(305), + /** + * STATIC_ASSERT = 306; + */ + STATIC_ASSERT(306), + /** + * 
+       * Combined C/C++
+       *
+ * + * CRESTRICT = 307; + */ + CRESTRICT(307), + /** + * CXX_TRY = 308; + */ + CXX_TRY(308), + /** + * CXX_CATCH = 309; + */ + CXX_CATCH(309), + /** + * CXX_CLASS = 310; + */ + CXX_CLASS(310), + /** + * 
+       * C++
+       *
+ * + * CONSTEXPR = 311; + */ + CONSTEXPR(311), + /** + * 
+       * NOEXCEPT = 312;
+       *
+ * + * THREAD_LOCAL = 313; + */ + THREAD_LOCAL(313), + /** + * NULLPTR = 314; + */ + NULLPTR(314), + /** + * 
+       * DECLTYPE = 315;
+       * ALIGNAS = 316;
+       * TYPENAME = 317;
+       * ALIGNOF = 318;
+       * TYPEID = 319;
+       * CONST_CAST = 320;
+       * DYNAMIC_CAST = 321;
+       * REINTERPRET_CAST = 322;
+       * STATIC_CAST = 323;
+       * aggregate types
+       * UNION = 324;
+       * STRUCT = 325;
+       * types
+       *
+ * + * VOID = 326; + */ + VOID(326), + /** + * 
+       * functions
+       *
+ * + * RETURN = 327; + */ + RETURN(327), + /** + * 
+       * cpp
+       *
+ * + * INCLUDE = 328; + */ + INCLUDE(328), + /** + * DEFINE = 329; + */ + DEFINE(329), + /** + * ELIF = 330; + */ + ELIF(330), + /** + * ENDIF = 331; + */ + ENDIF(331), + /** + * ERRORPREC = 332; + */ + ERRORPREC(332), + /** + * WARNING = 333; + */ + WARNING(333), + /** + * IFDEF = 334; + */ + IFDEF(334), + /** + * IFNDEF = 335; + */ + IFNDEF(335), + /** + * LINE = 336; + */ + LINE(336), + /** + * PRAGMA = 337; + */ + PRAGMA(337), + /** + * UNDEF = 338; + */ + UNDEF(338), + /** + * INLINE = 339; + */ + INLINE(339), + /** + * 
+       * macro
+       *
+ * + * MACRO_TYPE_NAME = 340; + */ + MACRO_TYPE_NAME(340), + /** + * MACRO_CASE = 341; + */ + MACRO_CASE(341), + /** + * MACRO_LABEL = 342; + */ + MACRO_LABEL(342), + /** + * 
+       * MACRO_SPECIFIER = 343;
+       *
+ * + * SPECIFIER = 344; + */ + SPECIFIER(344), + /** + * 
+       * specifiers that are not needed for parsing
+       * exception handling
+       *
+ * + * TRY = 345; + */ + TRY(345), + /** + * CATCH = 346; + */ + CATCH(346), + /** + * THROW = 347; + */ + THROW(347), + /** + * THROWS = 348; + */ + THROWS(348), + /** + * 
+       * class
+       * CLASS = 349;
+       *
+ * + * PUBLIC = 350; + */ + PUBLIC(350), + /** + * PRIVATE = 351; + */ + PRIVATE(351), + /** + * PROTECTED = 352; + */ + PROTECTED(352), + /** + * VIRTUAL = 353; + */ + VIRTUAL(353), + /** + * 
+       * FRIEND = 354;
+       * OPERATOR = 355;
+       *
+ * + * EXPLICIT = 356; + */ + EXPLICIT(356), + /** + * 
+       * Qt
+       *
+ * + * FOREVER = 357; + */ + FOREVER(357), + /** + * SIGNAL = 358; + */ + SIGNAL(358), + /** + * EMIT = 359; + */ + EMIT(359), + /** + * 
+       * namespaces
+       * NAMESPACE = 360;
+       * USING = 361;
+       * templates
+       * TEMPLATE = 362;
+       *
+ * + * NEW = 363; + */ + NEW(363), + /** + * DELETE = 364; + */ + DELETE(364), + /** + * 
+       * specifiers
+       *
+ * + * STATIC = 365; + */ + STATIC(365), + /** + * CONST = 366; + */ + CONST(366), + /** + * MUTABLE = 367; + */ + MUTABLE(367), + /** + * VOLATILE = 368; + */ + VOLATILE(368), + /** + * TRANSIENT = 369; + */ + TRANSIENT(369), + /** + * 
+       * Java tokens
+       * IMPORT = 370;
+       * PACKAGE = 371;
+       *
+ * + * FINALLY = 372; + */ + FINALLY(372), + /** + * 
+       * EXTENDS = 373;
+       * IMPLEMENTS = 374;
+       * INTERFACE = 375;
+       *
+ * + * FINAL = 376; + */ + FINAL(376), + /** + * ABSTRACT = 377; + */ + ABSTRACT(377), + /** + * SUPER = 378; + */ + SUPER(378), + /** + * SYNCHRONIZED = 379; + */ + SYNCHRONIZED(379), + /** + * NATIVE = 380; + */ + NATIVE(380), + /** + * STRICTFP = 381; + */ + STRICTFP(381), + /** + * NULLLITERAL = 382; + */ + NULLLITERAL(382), + /** + * ASSERT = 383; + */ + ASSERT(383), + /** + * 
+       * C# tokens
+       *
+ * + * FOREACH = 384; + */ + FOREACH(384), + /** + * REF = 385; + */ + REF(385), + /** + * OUT = 386; + */ + OUT(386), + /** + * 
+       * IN = 387;
+       *
+ * + * LOCK = 388; + */ + LOCK(388), + /** + * IS = 389; + */ + IS(389), + /** + * INTERNAL = 390; + */ + INTERNAL(390), + /** + * SEALED = 391; + */ + SEALED(391), + /** + * OVERRIDE = 392; + */ + OVERRIDE(392), + /** + * IMPLICIT = 393; + */ + IMPLICIT(393), + /** + * STACKALLOC = 394; + */ + STACKALLOC(394), + /** + * AS = 395; + */ + AS(395), + /** + * DELEGATE = 396; + */ + DELEGATE(396), + /** + * FIXED = 397; + */ + FIXED(397), + /** + * CHECKED = 398; + */ + CHECKED(398), + /** + * UNCHECKED = 399; + */ + UNCHECKED(399), + /** + * REGION = 400; + */ + REGION(400), + /** + * ENDREGION = 401; + */ + ENDREGION(401), + /** + * UNSAFE = 402; + */ + UNSAFE(402), + /** + * READONLY = 403; + */ + READONLY(403), + /** + * GET = 404; + */ + GET(404), + /** + * SET = 405; + */ + SET(405), + /** + * ADD = 406; + */ + ADD(406), + /** + * REMOVE = 407; + */ + REMOVE(407), + /** + * YIELD = 408; + */ + YIELD(408), + /** + * PARTIAL = 409; + */ + PARTIAL(409), + /** + * AWAIT = 410; + */ + AWAIT(410), + /** + * 
+       * EVENT = 411;
+       *
+ * + * ASYNC = 412; + */ + ASYNC(412), + /** + * THIS = 413; + */ + THIS(413), + /** + * PARAMS = 414; + */ + PARAMS(414), + /** + * 
+       * TYPEOF = 415;
+       *
+ * + * ALIAS = 416; + */ + ALIAS(416), + /** + * 
+       * linq
+       * FROM = 417;
+       * WHERE = 418;
+       * SELECT = 419;
+       * LET = 420;
+       * ORDERBY = 421;
+       *
+ * + * ASCENDING = 422; + */ + ASCENDING(422), + /** + * DESCENDING = 423; + */ + DESCENDING(423), + /** + * 
+       * GROUP = 424;
+       * BY = 425;
+       * JOIN = 426;
+       * ON = 427;
+       * EQUALS = 428;
+       * INTO = 429;
+       * Objective-C
+       *
+ * + * ATINTERFACE = 430; + */ + ATINTERFACE(430), + /** + * ATIMPLEMENTATION = 431; + */ + ATIMPLEMENTATION(431), + /** + * ATEND = 432; + */ + ATEND(432), + /** + * ATPROTOCOL = 433; + */ + ATPROTOCOL(433), + /** + * ATREQUIRED = 434; + */ + ATREQUIRED(434), + /** + * ATOPTIONAL = 435; + */ + ATOPTIONAL(435), + /** + * 
+       * PROPERTY = 436;
+       * SYNTHESIZE = 437;
+       * DYNAMIC = 438;
+       * ENCODE = 439;
+       * SELECTOR = 440;
+       *
+ * + * ATCLASS = 441; + */ + ATCLASS(441), + /** + * 
+       * Apple
+       * BLOCK = 442;
+       *
+ * + * WEAK = 443; + */ + WEAK(443), + /** + * STRONG = 444; + */ + STRONG(444), + /** + * 
+       * AUTORELEASEPOOL = 445;
+       * COMPATIBILITY_ALIAS = 446;
+       * NIL = 447;
+       * OpenMp
+       *
+ * + * OMP_OMP = 448; + */ + OMP_OMP(448), + /** + * SPECIAL_CHARS = 449; + */ + SPECIAL_CHARS(449), + UNRECOGNIZED(-1), + ; + + /** + * UNIT_KIND = 0; + */ + public static final int UNIT_KIND_VALUE = 0; + /** + * DECL = 1; + */ + public static final int DECL_VALUE = 1; + /** + * DECL_STMT = 2; + */ + public static final int DECL_STMT_VALUE = 2; + /** + * INIT = 3; + */ + public static final int INIT_VALUE = 3; + /** + * EXPR = 4; + */ + public static final int EXPR_VALUE = 4; + /** + * EXPR_STMT = 5; + */ + public static final int EXPR_STMT_VALUE = 5; + /** + * COMMENT = 6; + */ + public static final int COMMENT_VALUE = 6; + /** + * CALL = 7; + */ + public static final int CALL_VALUE = 7; + /** + * CONTROL = 8; + */ + public static final int CONTROL_VALUE = 8; + /** + * INCR = 9; + */ + public static final int INCR_VALUE = 9; + /** + * NONE = 10; + */ + public static final int NONE_VALUE = 10; + /** + * VARIABLE = 11; + */ + public static final int VARIABLE_VALUE = 11; + /** + * FUNCTION = 12; + */ + public static final int FUNCTION_VALUE = 12; + /** + * FUNCTION_DECL = 13; + */ + public static final int FUNCTION_DECL_VALUE = 13; + /** + * CONSTRUCTOR = 14; + */ + public static final int CONSTRUCTOR_VALUE = 14; + /** + * CONSTRUCTOR_DECL = 15; + */ + public static final int CONSTRUCTOR_DECL_VALUE = 15; + /** + * DESTRUCTOR = 16; + */ + public static final int DESTRUCTOR_VALUE = 16; + /** + * DESTRUCTOR_DECL = 17; + */ + public static final int DESTRUCTOR_DECL_VALUE = 17; + /** + * MACRO = 18; + */ + public static final int MACRO_VALUE = 18; + /** + * SINGLE_MACRO = 19; + */ + public static final int SINGLE_MACRO_VALUE = 19; + /** + * NULLOPERATOR = 20; + */ + public static final int NULLOPERATOR_VALUE = 20; + /** + * ENUM_DEFN = 21; + */ + public static final int ENUM_DEFN_VALUE = 21; + /** + * ENUM_DECL = 22; + */ + public static final int ENUM_DECL_VALUE = 22; + /** + * GLOBAL_ATTRIBUTE = 23; + */ + public static final int GLOBAL_ATTRIBUTE_VALUE = 23; + /** + * PROPERTY_ACCESSOR = 24; + */ + public static final int PROPERTY_ACCESSOR_VALUE = 24; + /** + * PROPERTY_ACCESSOR_DECL = 25; + */ + public static final int PROPERTY_ACCESSOR_DECL_VALUE = 25; + /** + * EXPRESSION = 26; + */ + public static final int EXPRESSION_VALUE = 26; + /** + * CLASS_DEFN = 27; + */ + public static final int CLASS_DEFN_VALUE = 27; + /** + * CLASS_DECL = 28; + */ + public static final int CLASS_DECL_VALUE = 28; + /** + * UNION_DEFN = 29; + */ + public static final int UNION_DEFN_VALUE = 29; + /** + * UNION_DECL = 30; + */ + public static final int UNION_DECL_VALUE = 30; + /** + * STRUCT_DEFN = 31; + */ + public static final int STRUCT_DEFN_VALUE = 31; + /** + * STRUCT_DECL = 32; + */ + public static final int STRUCT_DECL_VALUE = 32; + /** + * INTERFACE_DEFN = 33; + */ + public static final int INTERFACE_DEFN_VALUE = 33; + /** + * INTERFACE_DECL = 34; + */ + public static final int INTERFACE_DECL_VALUE = 34; + /** + * ACCESS_REGION = 35; + */ + public static final int ACCESS_REGION_VALUE = 35; + /** + * USING = 36; + */ + public static final int USING_VALUE = 36; + /** + * OPERATOR_FUNCTION = 37; + */ + public static final int OPERATOR_FUNCTION_VALUE = 37; + /** + * OPERATOR_FUNCTION_DECL = 38; + */ + public static final int OPERATOR_FUNCTION_DECL_VALUE = 38; + /** + * EVENT = 39; + */ + public static final int EVENT_VALUE = 39; + /** + * PROPERTY = 40; + */ + public static final int PROPERTY_VALUE = 40; + /** + * ANNOTATION_DEFN = 41; + */ + public static final int ANNOTATION_DEFN_VALUE = 41; + /** + * GLOBAL_TEMPLATE = 42; + */ + public static final int GLOBAL_TEMPLATE_VALUE = 42; + /** + * 
+       * entire source file
+       *
+ * + * UNIT = 43; + */ + public static final int UNIT_VALUE = 43; + /** + * 
+       * First token used for boundary
+       *
+ * + * TART_ELEMENT_TOKEN = 44; + */ + public static final int TART_ELEMENT_TOKEN_VALUE = 44; + /** + * 
+       * No output at all.  Only a placeholder
+       *
+ * + * NOP = 45; + */ + public static final int NOP_VALUE = 45; + /** + * 
+       * literal types
+       *
+ * + * STRING = 46; + */ + public static final int STRING_VALUE = 46; + /** + * 
+       * string or char marked by single quotes
+       *
+ * + * CHAR = 47; + */ + public static final int CHAR_VALUE = 47; + /** + * 
+       * literal number, constant
+       *
+ * + * LITERAL = 48; + */ + public static final int LITERAL_VALUE = 48; + /** + * 
+       * boolean literal, i.e., true, false
+       *
+ * + * BOOLEAN = 49; + */ + public static final int BOOLEAN_VALUE = 49; + /** + * 
+       * null types null, nullptr
+       *
+ * + * NULL = 50; + */ + public static final int NULL_VALUE = 50; + /** + * 
+       * complex numbers
+       *
+ * + * COMPLEX = 51; + */ + public static final int COMPLEX_VALUE = 51; + /** + * 
+       * operators
+       *
+ * + * OPERATOR = 52; + */ + public static final int OPERATOR_VALUE = 52; + /** + * 
+       * type modifiers
+       *
+ * + * MODIFIER = 53; + */ + public static final int MODIFIER_VALUE = 53; + /** + * 
+       * internal statement elements used in multiple statements
+       *
+ * + * NAME = 54; + */ + public static final int NAME_VALUE = 54; + /** + * ONAME = 55; + */ + public static final int ONAME_VALUE = 55; + /** + * CNAME = 56; + */ + public static final int CNAME_VALUE = 56; + /** + * TYPE = 57; + */ + public static final int TYPE_VALUE = 57; + /** + * TYPEPREV = 58; + */ + public static final int TYPEPREV_VALUE = 58; + /** + * CONDITION = 59; + */ + public static final int CONDITION_VALUE = 59; + /** + * BLOCK = 60; + */ + public static final int BLOCK_VALUE = 60; + /** + * PSEUDO_BLOCK = 61; + */ + public static final int PSEUDO_BLOCK_VALUE = 61; + /** + * INDEX = 62; + */ + public static final int INDEX_VALUE = 62; + /** + * 
+       * statements
+       *
+ * + * ENUM = 63; + */ + public static final int ENUM_VALUE = 63; + /** + * ENUM_DECLARATION = 64; + */ + public static final int ENUM_DECLARATION_VALUE = 64; + /** + * IF_STATEMENT = 65; + */ + public static final int IF_STATEMENT_VALUE = 65; + /** + * TERNARY = 66; + */ + public static final int TERNARY_VALUE = 66; + /** + * THEN = 67; + */ + public static final int THEN_VALUE = 67; + /** + * ELSE = 68; + */ + public static final int ELSE_VALUE = 68; + /** + * ELSEIF = 69; + */ + public static final int ELSEIF_VALUE = 69; + /** + * WHILE_STATEMENT = 70; + */ + public static final int WHILE_STATEMENT_VALUE = 70; + /** + * DO_STATEMENT = 71; + */ + public static final int DO_STATEMENT_VALUE = 71; + /** + * FOR_STATEMENT = 72; + */ + public static final int FOR_STATEMENT_VALUE = 72; + /** + * FOREACH_STATEMENT = 73; + */ + public static final int FOREACH_STATEMENT_VALUE = 73; + /** + * FOR_CONTROL = 74; + */ + public static final int FOR_CONTROL_VALUE = 74; + /** + * FOR_INITIALIZATION = 75; + */ + public static final int FOR_INITIALIZATION_VALUE = 75; + /** + * FOR_CONDITION = 76; + */ + public static final int FOR_CONDITION_VALUE = 76; + /** + * FOR_INCREMENT = 77; + */ + public static final int FOR_INCREMENT_VALUE = 77; + /** + * FOR_LIKE_CONTROL = 78; + */ + public static final int FOR_LIKE_CONTROL_VALUE = 78; + /** + * EXPRESSION_STATEMENT = 79; + */ + public static final int EXPRESSION_STATEMENT_VALUE = 79; + /** + * 
+       * EXPRESSION = 80;
+       *
+ * + * FUNCTION_CALL = 81; + */ + public static final int FUNCTION_CALL_VALUE = 81; + /** + * DECLARATION_STATEMENT = 82; + */ + public static final int DECLARATION_STATEMENT_VALUE = 82; + /** + * DECLARATION = 83; + */ + public static final int DECLARATION_VALUE = 83; + /** + * DECLARATION_INITIALIZATION = 84; + */ + public static final int DECLARATION_INITIALIZATION_VALUE = 84; + /** + * DECLARATION_RANGE = 85; + */ + public static final int DECLARATION_RANGE_VALUE = 85; + /** + * RANGE = 86; + */ + public static final int RANGE_VALUE = 86; + /** + * GOTO_STATEMENT = 87; + */ + public static final int GOTO_STATEMENT_VALUE = 87; + /** + * CONTINUE_STATEMENT = 88; + */ + public static final int CONTINUE_STATEMENT_VALUE = 88; + /** + * BREAK_STATEMENT = 89; + */ + public static final int BREAK_STATEMENT_VALUE = 89; + /** + * LABEL_STATEMENT = 90; + */ + public static final int LABEL_STATEMENT_VALUE = 90; + /** + * LABEL = 91; + */ + public static final int LABEL_VALUE = 91; + /** + * SWITCH = 92; + */ + public static final int SWITCH_VALUE = 92; + /** + * CASE = 93; + */ + public static final int CASE_VALUE = 93; + /** + * DEFAULT = 94; + */ + public static final int DEFAULT_VALUE = 94; + /** + * 
+       * functions
+       *
+ * + * FUNCTION_DEFINITION = 95; + */ + public static final int FUNCTION_DEFINITION_VALUE = 95; + /** + * FUNCTION_DECLARATION = 96; + */ + public static final int FUNCTION_DECLARATION_VALUE = 96; + /** + * LAMBDA = 97; + */ + public static final int LAMBDA_VALUE = 97; + /** + * FUNCTION_LAMBDA = 98; + */ + public static final int FUNCTION_LAMBDA_VALUE = 98; + /** + * FUNCTION_SPECIFIER = 99; + */ + public static final int FUNCTION_SPECIFIER_VALUE = 99; + /** + * RETURN_STATEMENT = 100; + */ + public static final int RETURN_STATEMENT_VALUE = 100; + /** + * PARAMETER_LIST = 101; + */ + public static final int PARAMETER_LIST_VALUE = 101; + /** + * PARAMETER = 102; + */ + public static final int PARAMETER_VALUE = 102; + /** + * KRPARAMETER_LIST = 103; + */ + public static final int KRPARAMETER_LIST_VALUE = 103; + /** + * KRPARAMETER = 104; + */ + public static final int KRPARAMETER_VALUE = 104; + /** + * ARGUMENT_LIST = 105; + */ + public static final int ARGUMENT_LIST_VALUE = 105; + /** + * ARGUMENT = 106; + */ + public static final int ARGUMENT_VALUE = 106; + /** + * PSEUDO_PARAMETER_LIST = 107; + */ + public static final int PSEUDO_PARAMETER_LIST_VALUE = 107; + /** + * INDEXER_PARAMETER_LIST = 108; + */ + public static final int INDEXER_PARAMETER_LIST_VALUE = 108; + /** + * 
+       * class, struct, union
+       *
+ * + * CLASS = 109; + */ + public static final int CLASS_VALUE = 109; + /** + * CLASS_DECLARATION = 110; + */ + public static final int CLASS_DECLARATION_VALUE = 110; + /** + * STRUCT = 111; + */ + public static final int STRUCT_VALUE = 111; + /** + * STRUCT_DECLARATION = 112; + */ + public static final int STRUCT_DECLARATION_VALUE = 112; + /** + * UNION = 113; + */ + public static final int UNION_VALUE = 113; + /** + * UNION_DECLARATION = 114; + */ + public static final int UNION_DECLARATION_VALUE = 114; + /** + * DERIVATION_LIST = 115; + */ + public static final int DERIVATION_LIST_VALUE = 115; + /** + * PUBLIC_ACCESS = 116; + */ + public static final int PUBLIC_ACCESS_VALUE = 116; + /** + * PUBLIC_ACCESS_DEFAULT = 117; + */ + public static final int PUBLIC_ACCESS_DEFAULT_VALUE = 117; + /** + * PRIVATE_ACCESS = 118; + */ + public static final int PRIVATE_ACCESS_VALUE = 118; + /** + * PRIVATE_ACCESS_DEFAULT = 119; + */ + public static final int PRIVATE_ACCESS_DEFAULT_VALUE = 119; + /** + * PROTECTED_ACCESS = 120; + */ + public static final int PROTECTED_ACCESS_VALUE = 120; + /** + * PROTECTED_ACCESS_DEFAULT = 121; + */ + public static final int PROTECTED_ACCESS_DEFAULT_VALUE = 121; + /** + * MEMBER_INIT_LIST = 122; + */ + public static final int MEMBER_INIT_LIST_VALUE = 122; + /** + * MEMBER_INITIALIZATION_LIST = 123; + */ + public static final int MEMBER_INITIALIZATION_LIST_VALUE = 123; + /** + * MEMBER_INITIALIZATION = 124; + */ + public static final int MEMBER_INITIALIZATION_VALUE = 124; + /** + * CONSTRUCTOR_DEFINITION = 125; + */ + public static final int CONSTRUCTOR_DEFINITION_VALUE = 125; + /** + * CONSTRUCTOR_DECLARATION = 126; + */ + public static final int CONSTRUCTOR_DECLARATION_VALUE = 126; + /** + * DESTRUCTOR_DEFINITION = 127; + */ + public static final int DESTRUCTOR_DEFINITION_VALUE = 127; + /** + * DESTRUCTOR_DECLARATION = 128; + */ + public static final int DESTRUCTOR_DECLARATION_VALUE = 128; + /** + * FRIEND = 129; + */ + public static final int FRIEND_VALUE = 129; + /** + * CLASS_SPECIFIER = 130; + */ + public static final int CLASS_SPECIFIER_VALUE = 130; + /** + * 
+       * exception handling
+       *
+ * + * TRY_BLOCK = 131; + */ + public static final int TRY_BLOCK_VALUE = 131; + /** + * CATCH_BLOCK = 132; + */ + public static final int CATCH_BLOCK_VALUE = 132; + /** + * FINALLY_BLOCK = 133; + */ + public static final int FINALLY_BLOCK_VALUE = 133; + /** + * THROW_STATEMENT = 134; + */ + public static final int THROW_STATEMENT_VALUE = 134; + /** + * THROW_SPECIFIER = 135; + */ + public static final int THROW_SPECIFIER_VALUE = 135; + /** + * THROW_SPECIFIER_JAVA = 136; + */ + public static final int THROW_SPECIFIER_JAVA_VALUE = 136; + /** + * TEMPLATE = 137; + */ + public static final int TEMPLATE_VALUE = 137; + /** + * GENERIC_ARGUMENT = 138; + */ + public static final int GENERIC_ARGUMENT_VALUE = 138; + /** + * GENERIC_ARGUMENT_LIST = 139; + */ + public static final int GENERIC_ARGUMENT_LIST_VALUE = 139; + /** + * TEMPLATE_PARAMETER = 140; + */ + public static final int TEMPLATE_PARAMETER_VALUE = 140; + /** + * TEMPLATE_PARAMETER_LIST = 141; + */ + public static final int TEMPLATE_PARAMETER_LIST_VALUE = 141; + /** + * GENERIC_PARAMETER = 142; + */ + public static final int GENERIC_PARAMETER_VALUE = 142; + /** + * GENERIC_PARAMETER_LIST = 143; + */ + public static final int GENERIC_PARAMETER_LIST_VALUE = 143; + /** + * 
+       * C Family elements
+       *
+ * + * TYPEDEF = 144; + */ + public static final int TYPEDEF_VALUE = 144; + /** + * ASM = 145; + */ + public static final int ASM_VALUE = 145; + /** + * MACRO_CALL = 146; + */ + public static final int MACRO_CALL_VALUE = 146; + /** + * SIZEOF_CALL = 147; + */ + public static final int SIZEOF_CALL_VALUE = 147; + /** + * EXTERN = 148; + */ + public static final int EXTERN_VALUE = 148; + /** + * NAMESPACE = 149; + */ + public static final int NAMESPACE_VALUE = 149; + /** + * USING_DIRECTIVE = 150; + */ + public static final int USING_DIRECTIVE_VALUE = 150; + /** + * DIRECTIVE = 151; + */ + public static final int DIRECTIVE_VALUE = 151; + /** + * 
+       * C
+       *
+ * + * ATOMIC = 152; + */ + public static final int ATOMIC_VALUE = 152; + /** + * STATIC_ASSERT_STATEMENT = 153; + */ + public static final int STATIC_ASSERT_STATEMENT_VALUE = 153; + /** + * GENERIC_SELECTION = 154; + */ + public static final int GENERIC_SELECTION_VALUE = 154; + /** + * GENERIC_SELECTOR = 155; + */ + public static final int GENERIC_SELECTOR_VALUE = 155; + /** + * GENERIC_ASSOCIATION_LIST = 156; + */ + public static final int GENERIC_ASSOCIATION_LIST_VALUE = 156; + /** + * GENERIC_ASSOCIATION = 157; + */ + public static final int GENERIC_ASSOCIATION_VALUE = 157; + /** + * 
+       * C++
+       *
+ * + * ALIGNAS = 158; + */ + public static final int ALIGNAS_VALUE = 158; + /** + * DECLTYPE = 159; + */ + public static final int DECLTYPE_VALUE = 159; + /** + * CAPTURE = 160; + */ + public static final int CAPTURE_VALUE = 160; + /** + * LAMBDA_CAPTURE = 161; + */ + public static final int LAMBDA_CAPTURE_VALUE = 161; + /** + * NOEXCEPT = 162; + */ + public static final int NOEXCEPT_VALUE = 162; + /** + * TYPENAME = 163; + */ + public static final int TYPENAME_VALUE = 163; + /** + * ALIGNOF = 164; + */ + public static final int ALIGNOF_VALUE = 164; + /** + * TYPEID = 165; + */ + public static final int TYPEID_VALUE = 165; + /** + * SIZEOF_PACK = 166; + */ + public static final int SIZEOF_PACK_VALUE = 166; + /** + * ENUM_CLASS = 167; + */ + public static final int ENUM_CLASS_VALUE = 167; + /** + * ENUM_CLASS_DECLARATION = 168; + */ + public static final int ENUM_CLASS_DECLARATION_VALUE = 168; + /** + * 
+       * OPERATOR_FUNCTION = 169;
+       * OPERATOR_FUNCTION_DECL = 170;
+       *
+ * + * REF_QUALIFIER = 171; + */ + public static final int REF_QUALIFIER_VALUE = 171; + /** + * 
+       * Qt
+       *
+ * + * SIGNAL_ACCESS = 172; + */ + public static final int SIGNAL_ACCESS_VALUE = 172; + /** + * FOREVER_STATEMENT = 173; + */ + public static final int FOREVER_STATEMENT_VALUE = 173; + /** + * EMIT_STATEMENT = 174; + */ + public static final int EMIT_STATEMENT_VALUE = 174; + /** + * 
+       * cpp directive internal elements
+       *
+ * + * CPP_DIRECTIVE = 175; + */ + public static final int CPP_DIRECTIVE_VALUE = 175; + /** + * CPP_FILENAME = 176; + */ + public static final int CPP_FILENAME_VALUE = 176; + /** + * FILE = 177; + */ + public static final int FILE_VALUE = 177; + /** + * NUMBER = 178; + */ + public static final int NUMBER_VALUE = 178; + /** + * CPP_NUMBER = 179; + */ + public static final int CPP_NUMBER_VALUE = 179; + /** + * CPP_LITERAL = 180; + */ + public static final int CPP_LITERAL_VALUE = 180; + /** + * CPP_MACRO_DEFN = 181; + */ + public static final int CPP_MACRO_DEFN_VALUE = 181; + /** + * CPP_MACRO_VALUE = 182; + */ + public static final int CPP_MACRO_VALUE_VALUE = 182; + /** + * 
+       * cpp directives
+       *
+ * + * ERROR = 183; + */ + public static final int ERROR_VALUE = 183; + /** + * CPP_ERROR = 184; + */ + public static final int CPP_ERROR_VALUE = 184; + /** + * CPP_WARNING = 185; + */ + public static final int CPP_WARNING_VALUE = 185; + /** + * CPP_PRAGMA = 186; + */ + public static final int CPP_PRAGMA_VALUE = 186; + /** + * CPP_INCLUDE = 187; + */ + public static final int CPP_INCLUDE_VALUE = 187; + /** + * CPP_DEFINE = 188; + */ + public static final int CPP_DEFINE_VALUE = 188; + /** + * CPP_UNDEF = 189; + */ + public static final int CPP_UNDEF_VALUE = 189; + /** + * CPP_LINE = 190; + */ + public static final int CPP_LINE_VALUE = 190; + /** + * CPP_IF = 191; + */ + public static final int CPP_IF_VALUE = 191; + /** + * CPP_IFDEF = 192; + */ + public static final int CPP_IFDEF_VALUE = 192; + /** + * CPP_IFNDEF = 193; + */ + public static final int CPP_IFNDEF_VALUE = 193; + /** + * CPP_THEN = 194; + */ + public static final int CPP_THEN_VALUE = 194; + /** + * CPP_ELSE = 195; + */ + public static final int CPP_ELSE_VALUE = 195; + /** + * CPP_ELIF = 196; + */ + public static final int CPP_ELIF_VALUE = 196; + /** + * CPP_EMPTY = 197; + */ + public static final int CPP_EMPTY_VALUE = 197; + /** + * 
+       * C# cpp directives
+       *
+ * + * CPP_REGION = 198; + */ + public static final int CPP_REGION_VALUE = 198; + /** + * CPP_ENDREGION = 199; + */ + public static final int CPP_ENDREGION_VALUE = 199; + /** + * USING_STMT = 200; + */ + public static final int USING_STMT_VALUE = 200; + /** + * ESCAPE = 201; + */ + public static final int ESCAPE_VALUE = 201; + /** + * 
+       * Objective-C cpp directives
+       *
+ * + * VALUE = 202; + */ + public static final int VALUE_VALUE = 202; + /** + * CPP_IMPORT = 203; + */ + public static final int CPP_IMPORT_VALUE = 203; + /** + * 
+       * This HAS to mark the end of the CPP directives
+       *
+ * + * CPP_ENDIF = 204; + */ + public static final int CPP_ENDIF_VALUE = 204; + /** + * 
+       * Debug elements
+       *
+ * + * MARKER = 205; + */ + public static final int MARKER_VALUE = 205; + /** + * ERROR_PARSE = 206; + */ + public static final int ERROR_PARSE_VALUE = 206; + /** + * ERROR_MODE = 207; + */ + public static final int ERROR_MODE_VALUE = 207; + /** + * 
+       * Java elements
+       *
+ * + * IMPLEMENTS = 208; + */ + public static final int IMPLEMENTS_VALUE = 208; + /** + * EXTENDS = 209; + */ + public static final int EXTENDS_VALUE = 209; + /** + * IMPORT = 210; + */ + public static final int IMPORT_VALUE = 210; + /** + * PACKAGE = 211; + */ + public static final int PACKAGE_VALUE = 211; + /** + * ASSERT_STATEMENT = 212; + */ + public static final int ASSERT_STATEMENT_VALUE = 212; + /** + * INTERFACE = 213; + */ + public static final int INTERFACE_VALUE = 213; + /** + * INTERFACE_DECLARATION = 214; + */ + public static final int INTERFACE_DECLARATION_VALUE = 214; + /** + * SYNCHRONIZED_STATEMENT = 215; + */ + public static final int SYNCHRONIZED_STATEMENT_VALUE = 215; + /** + * ANNOTATION = 216; + */ + public static final int ANNOTATION_VALUE = 216; + /** + * 
+       * ANNOTATION_DEFN = 217;
+       *
+ * + * STATIC_BLOCK = 218; + */ + public static final int STATIC_BLOCK_VALUE = 218; + /** + * 
+       * C#
+       *
+ * + * CHECKED_STATEMENT = 219; + */ + public static final int CHECKED_STATEMENT_VALUE = 219; + /** + * UNCHECKED_STATEMENT = 220; + */ + public static final int UNCHECKED_STATEMENT_VALUE = 220; + /** + * ATTRIBUTE = 221; + */ + public static final int ATTRIBUTE_VALUE = 221; + /** + * TARGET = 222; + */ + public static final int TARGET_VALUE = 222; + /** + * UNSAFE_STATEMENT = 223; + */ + public static final int UNSAFE_STATEMENT_VALUE = 223; + /** + * LOCK_STATEMENT = 224; + */ + public static final int LOCK_STATEMENT_VALUE = 224; + /** + * FIXED_STATEMENT = 225; + */ + public static final int FIXED_STATEMENT_VALUE = 225; + /** + * TYPEOF = 226; + */ + public static final int TYPEOF_VALUE = 226; + /** + * USING_STATEMENT = 227; + */ + public static final int USING_STATEMENT_VALUE = 227; + /** + * FUNCTION_DELEGATE = 228; + */ + public static final int FUNCTION_DELEGATE_VALUE = 228; + /** + * 
+       * EVENT = 229;
+       *
+ * + * CONSTRAINT = 230; + */ + public static final int CONSTRAINT_VALUE = 230; + /** + * 
+       * linq
+       *
+ * + * LINQ = 231; + */ + public static final int LINQ_VALUE = 231; + /** + * FROM = 232; + */ + public static final int FROM_VALUE = 232; + /** + * WHERE = 233; + */ + public static final int WHERE_VALUE = 233; + /** + * SELECT = 234; + */ + public static final int SELECT_VALUE = 234; + /** + * LET = 235; + */ + public static final int LET_VALUE = 235; + /** + * ORDERBY = 236; + */ + public static final int ORDERBY_VALUE = 236; + /** + * JOIN = 237; + */ + public static final int JOIN_VALUE = 237; + /** + * GROUP = 238; + */ + public static final int GROUP_VALUE = 238; + /** + * IN = 239; + */ + public static final int IN_VALUE = 239; + /** + * ON = 240; + */ + public static final int ON_VALUE = 240; + /** + * EQUALS = 241; + */ + public static final int EQUALS_VALUE = 241; + /** + * BY = 242; + */ + public static final int BY_VALUE = 242; + /** + * INTO = 243; + */ + public static final int INTO_VALUE = 243; + /** + * 
+       * misc
+       *
+ * + * EMPTY = 244; + */ + public static final int EMPTY_VALUE = 244; + /** + * 
+       * empty statement
+       *
+ * + * EMPTY_STMT = 245; + */ + public static final int EMPTY_STMT_VALUE = 245; + /** + * 
+       * Objective-C
+       *
+ * + * RECEIVER = 246; + */ + public static final int RECEIVER_VALUE = 246; + /** + * MESSAGE = 247; + */ + public static final int MESSAGE_VALUE = 247; + /** + * SELECTOR = 248; + */ + public static final int SELECTOR_VALUE = 248; + /** + * PROTOCOL_LIST = 249; + */ + public static final int PROTOCOL_LIST_VALUE = 249; + /** + * CATEGORY = 250; + */ + public static final int CATEGORY_VALUE = 250; + /** + * PROTOCOL = 251; + */ + public static final int PROTOCOL_VALUE = 251; + /** + * REQUIRED_DEFAULT = 252; + */ + public static final int REQUIRED_DEFAULT_VALUE = 252; + /** + * REQUIRED = 253; + */ + public static final int REQUIRED_VALUE = 253; + /** + * OPTIONAL = 254; + */ + public static final int OPTIONAL_VALUE = 254; + /** + * 
+       * PROPERTY = 255;
+       *
+ * + * ATTRIBUTE_LIST = 256; + */ + public static final int ATTRIBUTE_LIST_VALUE = 256; + /** + * SYNTHESIZE = 257; + */ + public static final int SYNTHESIZE_VALUE = 257; + /** + * DYNAMIC = 258; + */ + public static final int DYNAMIC_VALUE = 258; + /** + * ENCODE = 259; + */ + public static final int ENCODE_VALUE = 259; + /** + * AUTORELEASEPOOL = 260; + */ + public static final int AUTORELEASEPOOL_VALUE = 260; + /** + * COMPATIBILITY_ALIAS = 261; + */ + public static final int COMPATIBILITY_ALIAS_VALUE = 261; + /** + * NIL = 262; + */ + public static final int NIL_VALUE = 262; + /** + * CLASS_INTERFACE = 263; + */ + public static final int CLASS_INTERFACE_VALUE = 263; + /** + * CLASS_IMPLEMENTATION = 264; + */ + public static final int CLASS_IMPLEMENTATION_VALUE = 264; + /** + * PROTOCOL_DECLARATION = 265; + */ + public static final int PROTOCOL_DECLARATION_VALUE = 265; + /** + * 
+       * casting
+       *
+ * + * CAST = 266; + */ + public static final int CAST_VALUE = 266; + /** + * CONST_CAST = 267; + */ + public static final int CONST_CAST_VALUE = 267; + /** + * DYNAMIC_CAST = 268; + */ + public static final int DYNAMIC_CAST_VALUE = 268; + /** + * REINTERPRET_CAST = 269; + */ + public static final int REINTERPRET_CAST_VALUE = 269; + /** + * STATIC_CAST = 270; + */ + public static final int STATIC_CAST_VALUE = 270; + /** + * 
+       * srcMLOutput used only
+       *
+ * + * POSITION = 271; + */ + public static final int POSITION_VALUE = 271; + /** + * 
+       * Other
+       *
+ * + * CUDA_ARGUMENT_LIST = 272; + */ + public static final int CUDA_ARGUMENT_LIST_VALUE = 272; + /** + * 
+       * OpenMP
+       *
+ * + * OMP_DIRECTIVE = 273; + */ + public static final int OMP_DIRECTIVE_VALUE = 273; + /** + * OMP_NAME = 274; + */ + public static final int OMP_NAME_VALUE = 274; + /** + * OMP_CLAUSE = 275; + */ + public static final int OMP_CLAUSE_VALUE = 275; + /** + * OMP_ARGUMENT_LIST = 276; + */ + public static final int OMP_ARGUMENT_LIST_VALUE = 276; + /** + * OMP_ARGUMENT = 277; + */ + public static final int OMP_ARGUMENT_VALUE = 277; + /** + * OMP_EXPRESSION = 278; + */ + public static final int OMP_EXPRESSION_VALUE = 278; + /** + * 
+       * Last token used for boundary
+       *
+ * + * END_ELEMENT_TOKEN = 279; + */ + public static final int END_ELEMENT_TOKEN_VALUE = 279; + /** + * 
+       * special identifier
+       *
+ * + * MAIN = 280; + */ + public static final int MAIN_VALUE = 280; + /** + * 
+       * statements
+       *
+ * + * BREAK = 281; + */ + public static final int BREAK_VALUE = 281; + /** + * CONTINUE = 282; + */ + public static final int CONTINUE_VALUE = 282; + /** + * WHILE = 283; + */ + public static final int WHILE_VALUE = 283; + /** + * DO = 284; + */ + public static final int DO_VALUE = 284; + /** + * FOR = 285; + */ + public static final int FOR_VALUE = 285; + /** + * IF = 286; + */ + public static final int IF_VALUE = 286; + /** + * 
+       * ELSE = 287;
+       * SWITCH = 288;
+       * CASE = 289;
+       * DEFAULT = 290;
+       * ENUM = 291;
+       * C Family
+       * TYPEDEF = 292;
+       *
+ * + * GOTO = 293; + */ + public static final int GOTO_VALUE = 293; + /** + * 
+       * ASM = 294;
+       *
+ * + * VISUAL_CXX_ASM = 295; + */ + public static final int VISUAL_CXX_ASM_VALUE = 295; + /** + * SIZEOF = 296; + */ + public static final int SIZEOF_VALUE = 296; + /** + * 
+       * EXTERN = 297;
+       *
+ * + * AUTO = 298; + */ + public static final int AUTO_VALUE = 298; + /** + * 
+       * C
+       *
+ * + * REGISTER = 299; + */ + public static final int REGISTER_VALUE = 299; + /** + * RESTRICT = 300; + */ + public static final int RESTRICT_VALUE = 300; + /** + * 
+       * ATOMIC = 301;
+       * COMPLEX = 302;
+       * GENERIC_SELECTION = 303;
+       *
+ * + * IMAGINARY = 304; + */ + public static final int IMAGINARY_VALUE = 304; + /** + * NORETURN = 305; + */ + public static final int NORETURN_VALUE = 305; + /** + * STATIC_ASSERT = 306; + */ + public static final int STATIC_ASSERT_VALUE = 306; + /** + * 
+       * Combined C/C++
+       *
+ * + * CRESTRICT = 307; + */ + public static final int CRESTRICT_VALUE = 307; + /** + * CXX_TRY = 308; + */ + public static final int CXX_TRY_VALUE = 308; + /** + * CXX_CATCH = 309; + */ + public static final int CXX_CATCH_VALUE = 309; + /** + * CXX_CLASS = 310; + */ + public static final int CXX_CLASS_VALUE = 310; + /** + * 
+       * C++
+       *
+ * + * CONSTEXPR = 311; + */ + public static final int CONSTEXPR_VALUE = 311; + /** + * 
+       * NOEXCEPT = 312;
+       *
+ * + * THREAD_LOCAL = 313; + */ + public static final int THREAD_LOCAL_VALUE = 313; + /** + * NULLPTR = 314; + */ + public static final int NULLPTR_VALUE = 314; + /** + * 
+       * DECLTYPE = 315;
+       * ALIGNAS = 316;
+       * TYPENAME = 317;
+       * ALIGNOF = 318;
+       * TYPEID = 319;
+       * CONST_CAST = 320;
+       * DYNAMIC_CAST = 321;
+       * REINTERPRET_CAST = 322;
+       * STATIC_CAST = 323;
+       * aggregate types
+       * UNION = 324;
+       * STRUCT = 325;
+       * types
+       *
+ * + * VOID = 326; + */ + public static final int VOID_VALUE = 326; + /** + * 
+       * functions
+       *
+ * + * RETURN = 327; + */ + public static final int RETURN_VALUE = 327; + /** + * 
+       * cpp
+       *
+ * + * INCLUDE = 328; + */ + public static final int INCLUDE_VALUE = 328; + /** + * DEFINE = 329; + */ + public static final int DEFINE_VALUE = 329; + /** + * ELIF = 330; + */ + public static final int ELIF_VALUE = 330; + /** + * ENDIF = 331; + */ + public static final int ENDIF_VALUE = 331; + /** + * ERRORPREC = 332; + */ + public static final int ERRORPREC_VALUE = 332; + /** + * WARNING = 333; + */ + public static final int WARNING_VALUE = 333; + /** + * IFDEF = 334; + */ + public static final int IFDEF_VALUE = 334; + /** + * IFNDEF = 335; + */ + public static final int IFNDEF_VALUE = 335; + /** + * LINE = 336; + */ + public static final int LINE_VALUE = 336; + /** + * PRAGMA = 337; + */ + public static final int PRAGMA_VALUE = 337; + /** + * UNDEF = 338; + */ + public static final int UNDEF_VALUE = 338; + /** + * INLINE = 339; + */ + public static final int INLINE_VALUE = 339; + /** + * 
+       * macro
+       *
+ * + * MACRO_TYPE_NAME = 340; + */ + public static final int MACRO_TYPE_NAME_VALUE = 340; + /** + * MACRO_CASE = 341; + */ + public static final int MACRO_CASE_VALUE = 341; + /** + * MACRO_LABEL = 342; + */ + public static final int MACRO_LABEL_VALUE = 342; + /** + * 
+       * MACRO_SPECIFIER = 343;
+       *
+ * + * SPECIFIER = 344; + */ + public static final int SPECIFIER_VALUE = 344; + /** + * 
+       * specifiers that are not needed for parsing
+       * exception handling
+       *
+ * + * TRY = 345; + */ + public static final int TRY_VALUE = 345; + /** + * CATCH = 346; + */ + public static final int CATCH_VALUE = 346; + /** + * THROW = 347; + */ + public static final int THROW_VALUE = 347; + /** + * THROWS = 348; + */ + public static final int THROWS_VALUE = 348; + /** + * 
+       * class
+       * CLASS = 349;
+       *
+ * + * PUBLIC = 350; + */ + public static final int PUBLIC_VALUE = 350; + /** + * PRIVATE = 351; + */ + public static final int PRIVATE_VALUE = 351; + /** + * PROTECTED = 352; + */ + public static final int PROTECTED_VALUE = 352; + /** + * VIRTUAL = 353; + */ + public static final int VIRTUAL_VALUE = 353; + /** + * 
+       * FRIEND = 354;
+       * OPERATOR = 355;
+       *
+ * + * EXPLICIT = 356; + */ + public static final int EXPLICIT_VALUE = 356; + /** + * 
+       * Qt
+       *
+ * + * FOREVER = 357; + */ + public static final int FOREVER_VALUE = 357; + /** + * SIGNAL = 358; + */ + public static final int SIGNAL_VALUE = 358; + /** + * EMIT = 359; + */ + public static final int EMIT_VALUE = 359; + /** + * 
+       * namespaces
+       * NAMESPACE = 360;
+       * USING = 361;
+       * templates
+       * TEMPLATE = 362;
+       *
+ * + * NEW = 363; + */ + public static final int NEW_VALUE = 363; + /** + * DELETE = 364; + */ + public static final int DELETE_VALUE = 364; + /** + * 
+       * specifiers
+       *
+ * + * STATIC = 365; + */ + public static final int STATIC_VALUE = 365; + /** + * CONST = 366; + */ + public static final int CONST_VALUE = 366; + /** + * MUTABLE = 367; + */ + public static final int MUTABLE_VALUE = 367; + /** + * VOLATILE = 368; + */ + public static final int VOLATILE_VALUE = 368; + /** + * TRANSIENT = 369; + */ + public static final int TRANSIENT_VALUE = 369; + /** + * 
+       * Java tokens
+       * IMPORT = 370;
+       * PACKAGE = 371;
+       *
+ * + * FINALLY = 372; + */ + public static final int FINALLY_VALUE = 372; + /** + * 
+       * EXTENDS = 373;
+       * IMPLEMENTS = 374;
+       * INTERFACE = 375;
+       *
+ * + * FINAL = 376; + */ + public static final int FINAL_VALUE = 376; + /** + * ABSTRACT = 377; + */ + public static final int ABSTRACT_VALUE = 377; + /** + * SUPER = 378; + */ + public static final int SUPER_VALUE = 378; + /** + * SYNCHRONIZED = 379; + */ + public static final int SYNCHRONIZED_VALUE = 379; + /** + * NATIVE = 380; + */ + public static final int NATIVE_VALUE = 380; + /** + * STRICTFP = 381; + */ + public static final int STRICTFP_VALUE = 381; + /** + * NULLLITERAL = 382; + */ + public static final int NULLLITERAL_VALUE = 382; + /** + * ASSERT = 383; + */ + public static final int ASSERT_VALUE = 383; + /** + * 
+       * C# tokens
+       *
+ * + * FOREACH = 384; + */ + public static final int FOREACH_VALUE = 384; + /** + * REF = 385; + */ + public static final int REF_VALUE = 385; + /** + * OUT = 386; + */ + public static final int OUT_VALUE = 386; + /** + * 
+       * IN = 387;
+       *
+ * + * LOCK = 388; + */ + public static final int LOCK_VALUE = 388; + /** + * IS = 389; + */ + public static final int IS_VALUE = 389; + /** + * INTERNAL = 390; + */ + public static final int INTERNAL_VALUE = 390; + /** + * SEALED = 391; + */ + public static final int SEALED_VALUE = 391; + /** + * OVERRIDE = 392; + */ + public static final int OVERRIDE_VALUE = 392; + /** + * IMPLICIT = 393; + */ + public static final int IMPLICIT_VALUE = 393; + /** + * STACKALLOC = 394; + */ + public static final int STACKALLOC_VALUE = 394; + /** + * AS = 395; + */ + public static final int AS_VALUE = 395; + /** + * DELEGATE = 396; + */ + public static final int DELEGATE_VALUE = 396; + /** + * FIXED = 397; + */ + public static final int FIXED_VALUE = 397; + /** + * CHECKED = 398; + */ + public static final int CHECKED_VALUE = 398; + /** + * UNCHECKED = 399; + */ + public static final int UNCHECKED_VALUE = 399; + /** + * REGION = 400; + */ + public static final int REGION_VALUE = 400; + /** + * ENDREGION = 401; + */ + public static final int ENDREGION_VALUE = 401; + /** + * UNSAFE = 402; + */ + public static final int UNSAFE_VALUE = 402; + /** + * READONLY = 403; + */ + public static final int READONLY_VALUE = 403; + /** + * GET = 404; + */ + public static final int GET_VALUE = 404; + /** + * SET = 405; + */ + public static final int SET_VALUE = 405; + /** + * ADD = 406; + */ + public static final int ADD_VALUE = 406; + /** + * REMOVE = 407; + */ + public static final int REMOVE_VALUE = 407; + /** + * YIELD = 408; + */ + public static final int YIELD_VALUE = 408; + /** + * PARTIAL = 409; + */ + public static final int PARTIAL_VALUE = 409; + /** + * AWAIT = 410; + */ + public static final int AWAIT_VALUE = 410; + /** + * 
+       * EVENT = 411;
+       *
+ * + * ASYNC = 412; + */ + public static final int ASYNC_VALUE = 412; + /** + * THIS = 413; + */ + public static final int THIS_VALUE = 413; + /** + * PARAMS = 414; + */ + public static final int PARAMS_VALUE = 414; + /** + * 
+       * TYPEOF = 415;
+       *
+ * + * ALIAS = 416; + */ + public static final int ALIAS_VALUE = 416; + /** + * 
+       * linq
+       * FROM = 417;
+       * WHERE = 418;
+       * SELECT = 419;
+       * LET = 420;
+       * ORDERBY = 421;
+       *
+ * + * ASCENDING = 422; + */ + public static final int ASCENDING_VALUE = 422; + /** + * DESCENDING = 423; + */ + public static final int DESCENDING_VALUE = 423; + /** + * 
+       * GROUP = 424;
+       * BY = 425;
+       * JOIN = 426;
+       * ON = 427;
+       * EQUALS = 428;
+       * INTO = 429;
+       * Objective-C
+       *
+ * + * ATINTERFACE = 430; + */ + public static final int ATINTERFACE_VALUE = 430; + /** + * ATIMPLEMENTATION = 431; + */ + public static final int ATIMPLEMENTATION_VALUE = 431; + /** + * ATEND = 432; + */ + public static final int ATEND_VALUE = 432; + /** + * ATPROTOCOL = 433; + */ + public static final int ATPROTOCOL_VALUE = 433; + /** + * ATREQUIRED = 434; + */ + public static final int ATREQUIRED_VALUE = 434; + /** + * ATOPTIONAL = 435; + */ + public static final int ATOPTIONAL_VALUE = 435; + /** + * 
+       * PROPERTY = 436;
+       * SYNTHESIZE = 437;
+       * DYNAMIC = 438;
+       * ENCODE = 439;
+       * SELECTOR = 440;
+       *
+ * + * ATCLASS = 441; + */ + public static final int ATCLASS_VALUE = 441; + /** + * 
+       * Apple
+       * BLOCK = 442;
+       *
+ * + * WEAK = 443; + */ + public static final int WEAK_VALUE = 443; + /** + * STRONG = 444; + */ + public static final int STRONG_VALUE = 444; + /** + * 
+       * AUTORELEASEPOOL = 445;
+       * COMPATIBILITY_ALIAS = 446;
+       * NIL = 447;
+       * OpenMp
+       *
+ * + * OMP_OMP = 448; + */ + public static final int OMP_OMP_VALUE = 448; + /** + * SPECIAL_CHARS = 449; + */ + public static final int SPECIAL_CHARS_VALUE = 449; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Kind valueOf(int value) { + return forNumber(value); + } + + public static Kind forNumber(int value) { + switch (value) { + case 0: return UNIT_KIND; + case 1: return DECL; + case 2: return DECL_STMT; + case 3: return INIT; + case 4: return EXPR; + case 5: return EXPR_STMT; + case 6: return COMMENT; + case 7: return CALL; + case 8: return CONTROL; + case 9: return INCR; + case 10: return NONE; + case 11: return VARIABLE; + case 12: return FUNCTION; + case 13: return FUNCTION_DECL; + case 14: return CONSTRUCTOR; + case 15: return CONSTRUCTOR_DECL; + case 16: return DESTRUCTOR; + case 17: return DESTRUCTOR_DECL; + case 18: return MACRO; + case 19: return SINGLE_MACRO; + case 20: return NULLOPERATOR; + case 21: return ENUM_DEFN; + case 22: return ENUM_DECL; + case 23: return GLOBAL_ATTRIBUTE; + case 24: return PROPERTY_ACCESSOR; + case 25: return PROPERTY_ACCESSOR_DECL; + case 26: return EXPRESSION; + case 27: return CLASS_DEFN; + case 28: return CLASS_DECL; + case 29: return UNION_DEFN; + case 30: return UNION_DECL; + case 31: return STRUCT_DEFN; + case 32: return STRUCT_DECL; + case 33: return INTERFACE_DEFN; + case 34: return INTERFACE_DECL; + case 35: return ACCESS_REGION; + case 36: return USING; + case 37: return OPERATOR_FUNCTION; + case 38: return OPERATOR_FUNCTION_DECL; + case 39: return EVENT; + case 40: return PROPERTY; + case 41: return ANNOTATION_DEFN; + case 42: return GLOBAL_TEMPLATE; + case 43: return UNIT; + case 44: return TART_ELEMENT_TOKEN; + case 45: return NOP; + case 46: return STRING; + case 47: return CHAR; + case 48: return LITERAL; + case 49: return BOOLEAN; + case 50: return NULL; + case 51: return COMPLEX; + case 52: return OPERATOR; + case 53: return MODIFIER; + case 54: return NAME; + case 55: return ONAME; + case 56: return CNAME; + case 57: return TYPE; + case 58: return TYPEPREV; + case 59: return CONDITION; + case 60: return BLOCK; + case 61: return PSEUDO_BLOCK; + case 62: return INDEX; + case 63: return ENUM; + case 64: return ENUM_DECLARATION; + case 65: return IF_STATEMENT; + case 66: return TERNARY; + case 67: return THEN; + case 68: return ELSE; + case 69: return ELSEIF; + case 70: return WHILE_STATEMENT; + case 71: return DO_STATEMENT; + case 72: return FOR_STATEMENT; + case 73: return FOREACH_STATEMENT; + case 74: return FOR_CONTROL; + case 75: return FOR_INITIALIZATION; + case 76: return FOR_CONDITION; + case 77: return FOR_INCREMENT; + case 78: return FOR_LIKE_CONTROL; + case 79: return EXPRESSION_STATEMENT; + case 81: return FUNCTION_CALL; + case 82: return DECLARATION_STATEMENT; + case 83: return DECLARATION; + case 84: return DECLARATION_INITIALIZATION; + case 85: return DECLARATION_RANGE; + case 86: return RANGE; + case 87: return GOTO_STATEMENT; + case 88: return CONTINUE_STATEMENT; + case 89: return BREAK_STATEMENT; + case 90: return LABEL_STATEMENT; + case 91: return LABEL; + case 92: return SWITCH; + case 93: return CASE; + case 94: return DEFAULT; + case 95: return FUNCTION_DEFINITION; + case 96: return FUNCTION_DECLARATION; + case 97: return LAMBDA; + case 98: return FUNCTION_LAMBDA; + case 99: return FUNCTION_SPECIFIER; + case 100: return RETURN_STATEMENT; + case 101: return PARAMETER_LIST; + case 102: return PARAMETER; + case 103: return KRPARAMETER_LIST; + case 104: return KRPARAMETER; + case 105: return ARGUMENT_LIST; + case 106: return ARGUMENT; + case 107: return PSEUDO_PARAMETER_LIST; + case 108: return INDEXER_PARAMETER_LIST; + case 109: return CLASS; + case 110: return CLASS_DECLARATION; + case 111: return STRUCT; + case 112: return STRUCT_DECLARATION; + case 113: return UNION; + case 114: return UNION_DECLARATION; + case 115: return DERIVATION_LIST; + case 116: return PUBLIC_ACCESS; + case 117: return PUBLIC_ACCESS_DEFAULT; + case 118: return PRIVATE_ACCESS; + case 119: return PRIVATE_ACCESS_DEFAULT; + case 120: return PROTECTED_ACCESS; + case 121: return PROTECTED_ACCESS_DEFAULT; + case 122: return MEMBER_INIT_LIST; + case 123: return MEMBER_INITIALIZATION_LIST; + case 124: return MEMBER_INITIALIZATION; + case 125: return CONSTRUCTOR_DEFINITION; + case 126: return CONSTRUCTOR_DECLARATION; + case 127: return DESTRUCTOR_DEFINITION; + case 128: return DESTRUCTOR_DECLARATION; + case 129: return FRIEND; + case 130: return CLASS_SPECIFIER; + case 131: return TRY_BLOCK; + case 132: return CATCH_BLOCK; + case 133: return FINALLY_BLOCK; + case 134: return THROW_STATEMENT; + case 135: return THROW_SPECIFIER; + case 136: return THROW_SPECIFIER_JAVA; + case 137: return TEMPLATE; + case 138: return GENERIC_ARGUMENT; + case 139: return GENERIC_ARGUMENT_LIST; + case 140: return TEMPLATE_PARAMETER; + case 141: return TEMPLATE_PARAMETER_LIST; + case 142: return GENERIC_PARAMETER; + case 143: return GENERIC_PARAMETER_LIST; + case 144: return TYPEDEF; + case 145: return ASM; + case 146: return MACRO_CALL; + case 147: return SIZEOF_CALL; + case 148: return EXTERN; + case 149: return NAMESPACE; + case 150: return USING_DIRECTIVE; + case 151: return DIRECTIVE; + case 152: return ATOMIC; + case 153: return STATIC_ASSERT_STATEMENT; + case 154: return GENERIC_SELECTION; + case 155: return GENERIC_SELECTOR; + case 156: return GENERIC_ASSOCIATION_LIST; + case 157: return GENERIC_ASSOCIATION; + case 158: return ALIGNAS; + case 159: return DECLTYPE; + case 160: return CAPTURE; + case 161: return LAMBDA_CAPTURE; + case 162: return NOEXCEPT; + case 163: return TYPENAME; + case 164: return ALIGNOF; + case 165: return TYPEID; + case 166: return SIZEOF_PACK; + case 167: return ENUM_CLASS; + case 168: return ENUM_CLASS_DECLARATION; + case 171: return REF_QUALIFIER; + case 172: return SIGNAL_ACCESS; + case 173: return FOREVER_STATEMENT; + case 174: return EMIT_STATEMENT; + case 175: return CPP_DIRECTIVE; + case 176: return CPP_FILENAME; + case 177: return FILE; + case 178: return NUMBER; + case 179: return CPP_NUMBER; + case 180: return CPP_LITERAL; + case 181: return CPP_MACRO_DEFN; + case 182: return CPP_MACRO_VALUE; + case 183: return ERROR; + case 184: return CPP_ERROR; + case 185: return CPP_WARNING; + case 186: return CPP_PRAGMA; + case 187: return CPP_INCLUDE; + case 188: return CPP_DEFINE; + case 189: return CPP_UNDEF; + case 190: return CPP_LINE; + case 191: return CPP_IF; + case 192: return CPP_IFDEF; + case 193: return CPP_IFNDEF; + case 194: return CPP_THEN; + case 195: return CPP_ELSE; + case 196: return CPP_ELIF; + case 197: return CPP_EMPTY; + case 198: return CPP_REGION; + case 199: return CPP_ENDREGION; + case 200: return USING_STMT; + case 201: return ESCAPE; + case 202: return VALUE; + case 203: return CPP_IMPORT; + case 204: return CPP_ENDIF; + case 205: return MARKER; + case 206: return ERROR_PARSE; + case 207: return ERROR_MODE; + case 208: return IMPLEMENTS; + case 209: return EXTENDS; + case 210: return IMPORT; + case 211: return PACKAGE; + case 212: return ASSERT_STATEMENT; + case 213: return INTERFACE; + case 214: return INTERFACE_DECLARATION; + case 215: return SYNCHRONIZED_STATEMENT; + case 216: return ANNOTATION; + case 218: return STATIC_BLOCK; + case 219: return CHECKED_STATEMENT; + case 220: return UNCHECKED_STATEMENT; + case 221: return ATTRIBUTE; + case 222: return TARGET; + case 223: return UNSAFE_STATEMENT; + case 224: return LOCK_STATEMENT; + case 225: return FIXED_STATEMENT; + case 226: return TYPEOF; + case 227: return USING_STATEMENT; + case 228: return FUNCTION_DELEGATE; + case 230: return CONSTRAINT; + case 231: return LINQ; + case 232: return FROM; + case 233: return WHERE; + case 234: return SELECT; + case 235: return LET; + case 236: return ORDERBY; + case 237: return JOIN; + case 238: return GROUP; + case 239: return IN; + case 240: return ON; + case 241: return EQUALS; + case 242: return BY; + case 243: return INTO; + case 244: return EMPTY; + case 245: return EMPTY_STMT; + case 246: return RECEIVER; + case 247: return MESSAGE; + case 248: return SELECTOR; + case 249: return PROTOCOL_LIST; + case 250: return CATEGORY; + case 251: return PROTOCOL; + case 252: return REQUIRED_DEFAULT; + case 253: return REQUIRED; + case 254: return OPTIONAL; + case 256: return ATTRIBUTE_LIST; + case 257: return SYNTHESIZE; + case 258: return DYNAMIC; + case 259: return ENCODE; + case 260: return AUTORELEASEPOOL; + case 261: return COMPATIBILITY_ALIAS; + case 262: return NIL; + case 263: return CLASS_INTERFACE; + case 264: return CLASS_IMPLEMENTATION; + case 265: return PROTOCOL_DECLARATION; + case 266: return CAST; + case 267: return CONST_CAST; + case 268: return DYNAMIC_CAST; + case 269: return REINTERPRET_CAST; + case 270: return STATIC_CAST; + case 271: return POSITION; + case 272: return CUDA_ARGUMENT_LIST; + case 273: return OMP_DIRECTIVE; + case 274: return OMP_NAME; + case 275: return OMP_CLAUSE; + case 276: return OMP_ARGUMENT_LIST; + case 277: return OMP_ARGUMENT; + case 278: return OMP_EXPRESSION; + case 279: return END_ELEMENT_TOKEN; + case 280: return MAIN; + case 281: return BREAK; + case 282: return CONTINUE; + case 283: return WHILE; + case 284: return DO; + case 285: return FOR; + case 286: return IF; + case 293: return GOTO; + case 295: return VISUAL_CXX_ASM; + case 296: return SIZEOF; + case 298: return AUTO; + case 299: return REGISTER; + case 300: return RESTRICT; + case 304: return IMAGINARY; + case 305: return NORETURN; + case 306: return STATIC_ASSERT; + case 307: return CRESTRICT; + case 308: return CXX_TRY; + case 309: return CXX_CATCH; + case 310: return CXX_CLASS; + case 311: return CONSTEXPR; + case 313: return THREAD_LOCAL; + case 314: return NULLPTR; + case 326: return VOID; + case 327: return RETURN; + case 328: return INCLUDE; + case 329: return DEFINE; + case 330: return ELIF; + case 331: return ENDIF; + case 332: return ERRORPREC; + case 333: return WARNING; + case 334: return IFDEF; + case 335: return IFNDEF; + case 336: return LINE; + case 337: return PRAGMA; + case 338: return UNDEF; + case 339: return INLINE; + case 340: return MACRO_TYPE_NAME; + case 341: return MACRO_CASE; + case 342: return MACRO_LABEL; + case 344: return SPECIFIER; + case 345: return TRY; + case 346: return CATCH; + case 347: return THROW; + case 348: return THROWS; + case 350: return PUBLIC; + case 351: return PRIVATE; + case 352: return PROTECTED; + case 353: return VIRTUAL; + case 356: return EXPLICIT; + case 357: return FOREVER; + case 358: return SIGNAL; + case 359: return EMIT; + case 363: return NEW; + case 364: return DELETE; + case 365: return STATIC; + case 366: return CONST; + case 367: return MUTABLE; + case 368: return VOLATILE; + case 369: return TRANSIENT; + case 372: return FINALLY; + case 376: return FINAL; + case 377: return ABSTRACT; + case 378: return SUPER; + case 379: return SYNCHRONIZED; + case 380: return NATIVE; + case 381: return STRICTFP; + case 382: return NULLLITERAL; + case 383: return ASSERT; + case 384: return FOREACH; + case 385: return REF; + case 386: return OUT; + case 388: return LOCK; + case 389: return IS; + case 390: return INTERNAL; + case 391: return SEALED; + case 392: return OVERRIDE; + case 393: return IMPLICIT; + case 394: return STACKALLOC; + case 395: return AS; + case 396: return DELEGATE; + case 397: return FIXED; + case 398: return CHECKED; + case 399: return UNCHECKED; + case 400: return REGION; + case 401: return ENDREGION; + case 402: return UNSAFE; + case 403: return READONLY; + case 404: return GET; + case 405: return SET; + case 406: return ADD; + case 407: return REMOVE; + case 408: return YIELD; + case 409: return PARTIAL; + case 410: return AWAIT; + case 412: return ASYNC; + case 413: return THIS; + case 414: return PARAMS; + case 416: return ALIAS; + case 422: return ASCENDING; + case 423: return DESCENDING; + case 430: return ATINTERFACE; + case 431: return ATIMPLEMENTATION; + case 432: return ATEND; + case 433: return ATPROTOCOL; + case 434: return ATREQUIRED; + case 435: return ATOPTIONAL; + case 441: return ATCLASS; + case 443: return WEAK; + case 444: return STRONG; + case 448: return OMP_OMP; + case 449: return SPECIAL_CHARS; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Kind> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Kind findValueByNumber(int number) { + return Kind.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Element.getDescriptor().getEnumTypes().get(0); + } + + private static final Kind[] VALUES = values(); + + public static Kind valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Kind(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Element.Kind) + } + + /** + * Protobuf enum {@code fast.Element.DiffType} + */ + public enum DiffType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       * matched, denoted by empty
+       *
+ * + * MATCHED = 0; + */ + MATCHED(0), + /** + * 
+       * added, denoted by +
+       *
+ * + * ADDED = 1; + */ + ADDED(1), + /** + * 
+       * deleted, denoted by -
+       *
+ * + * DELETED = 2; + */ + DELETED(2), + /** + * 
+       * changed from, denoted by -+
+       *
+ * + * CHANGED_FROM = 3; + */ + CHANGED_FROM(3), + /** + * 
+       * changed to, denoted by +-
+       *
+ * + * CHANGED_TO = 4; + */ + CHANGED_TO(4), + UNRECOGNIZED(-1), + ; + + /** + * 
+       * matched, denoted by empty
+       *
+ * + * MATCHED = 0; + */ + public static final int MATCHED_VALUE = 0; + /** + * 
+       * added, denoted by +
+       *
+ * + * ADDED = 1; + */ + public static final int ADDED_VALUE = 1; + /** + * 
+       * deleted, denoted by -
+       *
+ * + * DELETED = 2; + */ + public static final int DELETED_VALUE = 2; + /** + * 
+       * changed from, denoted by -+
+       *
+ * + * CHANGED_FROM = 3; + */ + public static final int CHANGED_FROM_VALUE = 3; + /** + * 
+       * changed to, denoted by +-
+       *
+ * + * CHANGED_TO = 4; + */ + public static final int CHANGED_TO_VALUE = 4; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static DiffType valueOf(int value) { + return forNumber(value); + } + + public static DiffType forNumber(int value) { + switch (value) { + case 0: return MATCHED; + case 1: return ADDED; + case 2: return DELETED; + case 3: return CHANGED_FROM; + case 4: return CHANGED_TO; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + DiffType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public DiffType findValueByNumber(int number) { + return DiffType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Element.getDescriptor().getEnumTypes().get(1); + } + + private static final DiffType[] VALUES = values(); + + public static DiffType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private DiffType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Element.DiffType) + } + + public interface UnitOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Element.Unit) + com.google.protobuf.MessageOrBuilder { + + /** + * string filename = 1; + */ + java.lang.String getFilename(); + /** + * string filename = 1; + */ + com.google.protobuf.ByteString + getFilenameBytes(); + + /** + * string revision = 2; + */ + java.lang.String getRevision(); + /** + * string revision = 2; + */ + com.google.protobuf.ByteString + getRevisionBytes(); + + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + int getLanguageValue(); + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + fast.Fast.Element.Unit.LanguageType getLanguage(); + + /** + * int32 item = 4; + */ + int getItem(); + } + /** + * Protobuf type {@code fast.Element.Unit} + */ + public static final class Unit extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Element.Unit) + UnitOrBuilder { + // Use Unit.newBuilder() to construct. + private Unit(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Unit() { + filename_ = ""; + revision_ = ""; + language_ = 0; + item_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Unit( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + filename_ = s; + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + revision_ = s; + break; + } + case 24: { + int rawValue = input.readEnum(); + + language_ = rawValue; + break; + } + case 32: { + + item_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_Unit_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_Unit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.Unit.class, fast.Fast.Element.Unit.Builder.class); + } + + /** + * Protobuf enum {@code fast.Element.Unit.LanguageType} + */ + public enum LanguageType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * DUMMY = 0; + */ + DUMMY(0), + /** + * ALL = 1; + */ + ALL(1), + /** + * OO = 2; + */ + OO(2), + /** + * CXX = 3; + */ + CXX(3), + /** + * C = 4; + */ + C(4), + /** + * C_FAMILY = 5; + */ + C_FAMILY(5), + /** + * JAVA = 6; + */ + JAVA(6), + /** + * CSHARP = 7; + */ + CSHARP(7), + /** + * OBJECTIVE_C = 8; + */ + OBJECTIVE_C(8), + UNRECOGNIZED(-1), + ; + + /** + * DUMMY = 0; + */ + public static final int DUMMY_VALUE = 0; + /** + * ALL = 1; + */ + public static final int ALL_VALUE = 1; + /** + * OO = 2; + */ + public static final int OO_VALUE = 2; + /** + * CXX = 3; + */ + public static final int CXX_VALUE = 3; + /** + * C = 4; + */ + public static final int C_VALUE = 4; + /** + * C_FAMILY = 5; + */ + public static final int C_FAMILY_VALUE = 5; + /** + * JAVA = 6; + */ + public static final int JAVA_VALUE = 6; + /** + * CSHARP = 7; + */ + public static final int CSHARP_VALUE = 7; + /** + * OBJECTIVE_C = 8; + */ + public static final int OBJECTIVE_C_VALUE = 8; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static LanguageType valueOf(int value) { + return forNumber(value); + } + + public static LanguageType forNumber(int value) { + switch (value) { + case 0: return DUMMY; + case 1: return ALL; + case 2: return OO; + case 3: return CXX; + case 4: return C; + case 5: return C_FAMILY; + case 6: return JAVA; + case 7: return CSHARP; + case 8: return OBJECTIVE_C; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + LanguageType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public LanguageType findValueByNumber(int number) { + return LanguageType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Element.Unit.getDescriptor().getEnumTypes().get(0); + } + + private static final LanguageType[] VALUES = values(); + + public static LanguageType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private LanguageType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Element.Unit.LanguageType) + } + + public static final int FILENAME_FIELD_NUMBER = 1; + private volatile java.lang.Object filename_; + /** + * string filename = 1; + */ + public java.lang.String getFilename() { + java.lang.Object ref = filename_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + filename_ = s; + return s; + } + } + /** + * string filename = 1; + */ + public com.google.protobuf.ByteString + getFilenameBytes() { + java.lang.Object ref = filename_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + filename_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int REVISION_FIELD_NUMBER = 2; + private volatile java.lang.Object revision_; + /** + * string revision = 2; + */ + public java.lang.String getRevision() { + java.lang.Object ref = revision_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + revision_ = s; + return s; + } + } + /** + * string revision = 2; + */ + public com.google.protobuf.ByteString + getRevisionBytes() { + java.lang.Object ref = revision_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + revision_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int LANGUAGE_FIELD_NUMBER = 3; + private int language_; + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public int getLanguageValue() { + return language_; + } + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public fast.Fast.Element.Unit.LanguageType getLanguage() { + fast.Fast.Element.Unit.LanguageType result = fast.Fast.Element.Unit.LanguageType.valueOf(language_); + return result == null ? fast.Fast.Element.Unit.LanguageType.UNRECOGNIZED : result; + } + + public static final int ITEM_FIELD_NUMBER = 4; + private int item_; + /** + * int32 item = 4; + */ + public int getItem() { + return item_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getFilenameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, filename_); + } + if (!getRevisionBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, revision_); + } + if (language_ != fast.Fast.Element.Unit.LanguageType.DUMMY.getNumber()) { + output.writeEnum(3, language_); + } + if (item_ != 0) { + output.writeInt32(4, item_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getFilenameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, filename_); + } + if (!getRevisionBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, revision_); + } + if (language_ != fast.Fast.Element.Unit.LanguageType.DUMMY.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, language_); + } + if (item_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, item_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Element.Unit)) { + return super.equals(obj); + } + fast.Fast.Element.Unit other = (fast.Fast.Element.Unit) obj; + + boolean result = true; + result = result && getFilename() + .equals(other.getFilename()); + result = result && getRevision() + .equals(other.getRevision()); + result = result && language_ == other.language_; + result = result && (getItem() + == other.getItem()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + FILENAME_FIELD_NUMBER; + hash = (53 * hash) + getFilename().hashCode(); + hash = (37 * hash) + REVISION_FIELD_NUMBER; + hash = (53 * hash) + getRevision().hashCode(); + hash = (37 * hash) + LANGUAGE_FIELD_NUMBER; + hash = (53 * hash) + language_; + hash = (37 * hash) + ITEM_FIELD_NUMBER; + hash = (53 * hash) + getItem(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Element.Unit parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Unit parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Unit parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Unit parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Unit parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Unit parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Unit parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element.Unit parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element.Unit parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Element.Unit parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element.Unit parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element.Unit parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Element.Unit prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Element.Unit} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Element.Unit) + fast.Fast.Element.UnitOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_Unit_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_Unit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.Unit.class, fast.Fast.Element.Unit.Builder.class); + } + + // Construct using fast.Fast.Element.Unit.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + filename_ = ""; + + revision_ = ""; + + language_ = 0; + + item_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Element_Unit_descriptor; + } + + public fast.Fast.Element.Unit getDefaultInstanceForType() { + return fast.Fast.Element.Unit.getDefaultInstance(); + } + + public fast.Fast.Element.Unit build() { + fast.Fast.Element.Unit result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Element.Unit buildPartial() { + fast.Fast.Element.Unit result = new fast.Fast.Element.Unit(this); + result.filename_ = filename_; + result.revision_ = revision_; + result.language_ = language_; + result.item_ = item_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Element.Unit) { + return mergeFrom((fast.Fast.Element.Unit)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Element.Unit other) { + if (other == fast.Fast.Element.Unit.getDefaultInstance()) return this; + if (!other.getFilename().isEmpty()) { + filename_ = other.filename_; + onChanged(); + } + if (!other.getRevision().isEmpty()) { + revision_ = other.revision_; + onChanged(); + } + if (other.language_ != 0) { + setLanguageValue(other.getLanguageValue()); + } + if (other.getItem() != 0) { + setItem(other.getItem()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Element.Unit parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Element.Unit) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object filename_ = ""; + /** + * string filename = 1; + */ + public java.lang.String getFilename() { + java.lang.Object ref = filename_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + filename_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string filename = 1; + */ + public com.google.protobuf.ByteString + getFilenameBytes() { + java.lang.Object ref = filename_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + filename_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string filename = 1; + */ + public Builder setFilename( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + filename_ = value; + onChanged(); + return this; + } + /** + * string filename = 1; + */ + public Builder clearFilename() { + + filename_ = getDefaultInstance().getFilename(); + onChanged(); + return this; + } + /** + * string filename = 1; + */ + public Builder setFilenameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + filename_ = value; + onChanged(); + return this; + } + + private java.lang.Object revision_ = ""; + /** + * string revision = 2; + */ + public java.lang.String getRevision() { + java.lang.Object ref = revision_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + revision_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string revision = 2; + */ + public com.google.protobuf.ByteString + getRevisionBytes() { + java.lang.Object ref = revision_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + revision_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string revision = 2; + */ + public Builder setRevision( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + revision_ = value; + onChanged(); + return this; + } + /** + * string revision = 2; + */ + public Builder clearRevision() { + + revision_ = getDefaultInstance().getRevision(); + onChanged(); + return this; + } + /** + * string revision = 2; + */ + public Builder setRevisionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + revision_ = value; + onChanged(); + return this; + } + + private int language_ = 0; + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public int getLanguageValue() { + return language_; + } + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public Builder setLanguageValue(int value) { + language_ = value; + onChanged(); + return this; + } + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public fast.Fast.Element.Unit.LanguageType getLanguage() { + fast.Fast.Element.Unit.LanguageType result = fast.Fast.Element.Unit.LanguageType.valueOf(language_); + return result == null ? fast.Fast.Element.Unit.LanguageType.UNRECOGNIZED : result; + } + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public Builder setLanguage(fast.Fast.Element.Unit.LanguageType value) { + if (value == null) { + throw new NullPointerException(); + } + + language_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Element.Unit.LanguageType language = 3; + */ + public Builder clearLanguage() { + + language_ = 0; + onChanged(); + return this; + } + + private int item_ ; + /** + * int32 item = 4; + */ + public int getItem() { + return item_; + } + /** + * int32 item = 4; + */ + public Builder setItem(int value) { + + item_ = value; + onChanged(); + return this; + } + /** + * int32 item = 4; + */ + public Builder clearItem() { + + item_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Element.Unit) + } + + // @@protoc_insertion_point(class_scope:fast.Element.Unit) + private static final fast.Fast.Element.Unit DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Element.Unit(); + } + + public static fast.Fast.Element.Unit getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Unit parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Unit(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Element.Unit getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface LiteralOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Element.Literal) + com.google.protobuf.MessageOrBuilder { + + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + int getTypeValue(); + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + fast.Fast.Element.Literal.LiteralType getType(); + } + /** + * Protobuf type {@code fast.Element.Literal} + */ + public static final class Literal extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Element.Literal) + LiteralOrBuilder { + // Use Literal.newBuilder() to construct. + private Literal(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Literal() { + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Literal( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_Literal_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_Literal_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.Literal.class, fast.Fast.Element.Literal.Builder.class); + } + + /** + * Protobuf enum {@code fast.Element.Literal.LiteralType} + */ + public enum LiteralType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * dummy_type = 0; + */ + dummy_type(0), + /** + * number_type = 1; + */ + number_type(1), + /** + * char_type = 2; + */ + char_type(2), + /** + * string_type = 3; + */ + string_type(3), + /** + * boolean_type = 4; + */ + boolean_type(4), + /** + * null_type = 5; + */ + null_type(5), + UNRECOGNIZED(-1), + ; + + /** + * dummy_type = 0; + */ + public static final int dummy_type_VALUE = 0; + /** + * number_type = 1; + */ + public static final int number_type_VALUE = 1; + /** + * char_type = 2; + */ + public static final int char_type_VALUE = 2; + /** + * string_type = 3; + */ + public static final int string_type_VALUE = 3; + /** + * boolean_type = 4; + */ + public static final int boolean_type_VALUE = 4; + /** + * null_type = 5; + */ + public static final int null_type_VALUE = 5; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static LiteralType valueOf(int value) { + return forNumber(value); + } + + public static LiteralType forNumber(int value) { + switch (value) { + case 0: return dummy_type; + case 1: return number_type; + case 2: return char_type; + case 3: return string_type; + case 4: return boolean_type; + case 5: return null_type; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + LiteralType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public LiteralType findValueByNumber(int number) { + return LiteralType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Element.Literal.getDescriptor().getEnumTypes().get(0); + } + + private static final LiteralType[] VALUES = values(); + + public static LiteralType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private LiteralType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Element.Literal.LiteralType) + } + + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public fast.Fast.Element.Literal.LiteralType getType() { + fast.Fast.Element.Literal.LiteralType result = fast.Fast.Element.Literal.LiteralType.valueOf(type_); + return result == null ? fast.Fast.Element.Literal.LiteralType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (type_ != fast.Fast.Element.Literal.LiteralType.dummy_type.getNumber()) { + output.writeEnum(1, type_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (type_ != fast.Fast.Element.Literal.LiteralType.dummy_type.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Element.Literal)) { + return super.equals(obj); + } + fast.Fast.Element.Literal other = (fast.Fast.Element.Literal) obj; + + boolean result = true; + result = result && type_ == other.type_; + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Element.Literal parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Literal parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Literal parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Literal parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Literal parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element.Literal parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element.Literal parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element.Literal parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element.Literal parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Element.Literal parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element.Literal parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element.Literal parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Element.Literal prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Element.Literal} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Element.Literal) + fast.Fast.Element.LiteralOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_Literal_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_Literal_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.Literal.class, fast.Fast.Element.Literal.Builder.class); + } + + // Construct using fast.Fast.Element.Literal.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + type_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Element_Literal_descriptor; + } + + public fast.Fast.Element.Literal getDefaultInstanceForType() { + return fast.Fast.Element.Literal.getDefaultInstance(); + } + + public fast.Fast.Element.Literal build() { + fast.Fast.Element.Literal result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Element.Literal buildPartial() { + fast.Fast.Element.Literal result = new fast.Fast.Element.Literal(this); + result.type_ = type_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Element.Literal) { + return mergeFrom((fast.Fast.Element.Literal)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Element.Literal other) { + if (other == fast.Fast.Element.Literal.getDefaultInstance()) return this; + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Element.Literal parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Element.Literal) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int type_ = 0; + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public fast.Fast.Element.Literal.LiteralType getType() { + fast.Fast.Element.Literal.LiteralType result = fast.Fast.Element.Literal.LiteralType.valueOf(type_); + return result == null ? fast.Fast.Element.Literal.LiteralType.UNRECOGNIZED : result; + } + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public Builder setType(fast.Fast.Element.Literal.LiteralType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Element.Literal.LiteralType type = 1; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Element.Literal) + } + + // @@protoc_insertion_point(class_scope:fast.Element.Literal) + private static final fast.Fast.Element.Literal DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Element.Literal(); + } + + public static fast.Fast.Element.Literal getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Literal parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Literal(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Element.Literal getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + private int typeCase_ = 0; + private java.lang.Object type_; + public enum TypeCase + implements com.google.protobuf.Internal.EnumLite { + KIND(1), + SMALI_KIND(2), + TYPE_NOT_SET(0); + private final int value; + private TypeCase(int value) { + this.value = value; + } + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static TypeCase valueOf(int value) { + return forNumber(value); + } + + public static TypeCase forNumber(int value) { + switch (value) { + case 1: return KIND; + case 2: return SMALI_KIND; + case 0: return TYPE_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public TypeCase + getTypeCase() { + return TypeCase.forNumber( + typeCase_); + } + + private int extraCase_ = 0; + private java.lang.Object extra_; + public enum ExtraCase + implements com.google.protobuf.Internal.EnumLite { + UNIT(8), + LITERAL(9), + EXTRA_NOT_SET(0); + private final int value; + private ExtraCase(int value) { + this.value = value; + } + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ExtraCase valueOf(int value) { + return forNumber(value); + } + + public static ExtraCase forNumber(int value) { + switch (value) { + case 8: return UNIT; + case 9: return LITERAL; + case 0: return EXTRA_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public ExtraCase + getExtraCase() { + return ExtraCase.forNumber( + extraCase_); + } + + public static final int KIND_FIELD_NUMBER = 1; + /** + * 
+     * default to srcML
+     *
+ * + * .fast.Element.Kind kind = 1; + */ + public int getKindValue() { + if (typeCase_ == 1) { + return (java.lang.Integer) type_; + } + return 0; + } + /** + * 
+     * default to srcML
+     *
+ * + * .fast.Element.Kind kind = 1; + */ + public fast.Fast.Element.Kind getKind() { + if (typeCase_ == 1) { + fast.Fast.Element.Kind result = fast.Fast.Element.Kind.valueOf( + (java.lang.Integer) type_); + return result == null ? fast.Fast.Element.Kind.UNRECOGNIZED : result; + } + return fast.Fast.Element.Kind.UNIT_KIND; + } + + public static final int SMALI_KIND_FIELD_NUMBER = 2; + /** + * .fast.SmaliKind smali_kind = 2; + */ + public int getSmaliKindValue() { + if (typeCase_ == 2) { + return (java.lang.Integer) type_; + } + return 0; + } + /** + * .fast.SmaliKind smali_kind = 2; + */ + public fast.Fast.SmaliKind getSmaliKind() { + if (typeCase_ == 2) { + fast.Fast.SmaliKind result = fast.Fast.SmaliKind.valueOf( + (java.lang.Integer) type_); + return result == null ? fast.Fast.SmaliKind.UNRECOGNIZED : result; + } + return fast.Fast.SmaliKind.smali_file; + } + + public static final int TEXT_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString text_; + /** + * bytes text = 3; + */ + public com.google.protobuf.ByteString getText() { + return text_; + } + + public static final int POS_FIELD_NUMBER = 4; + private int pos_; + /** + * int32 pos = 4; + */ + public int getPos() { + return pos_; + } + + public static final int LENGTH_FIELD_NUMBER = 5; + private int length_; + /** + * int32 length = 5; + */ + public int getLength() { + return length_; + } + + public static final int CHILD_FIELD_NUMBER = 6; + private java.util.List child_; + /** + * repeated .fast.Element child = 6; + */ + public java.util.List getChildList() { + return child_; + } + /** + * repeated .fast.Element child = 6; + */ + public java.util.List + getChildOrBuilderList() { + return child_; + } + /** + * repeated .fast.Element child = 6; + */ + public int getChildCount() { + return child_.size(); + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.Element getChild(int index) { + return child_.get(index); + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.ElementOrBuilder getChildOrBuilder( + int index) { + return child_.get(index); + } + + public static final int TAIL_FIELD_NUMBER = 7; + private com.google.protobuf.ByteString tail_; + /** + * bytes tail = 7; + */ + public com.google.protobuf.ByteString getTail() { + return tail_; + } + + public static final int UNIT_FIELD_NUMBER = 8; + /** + * .fast.Element.Unit unit = 8; + */ + public fast.Fast.Element.Unit getUnit() { + if (extraCase_ == 8) { + return (fast.Fast.Element.Unit) extra_; + } + return fast.Fast.Element.Unit.getDefaultInstance(); + } + /** + * .fast.Element.Unit unit = 8; + */ + public fast.Fast.Element.UnitOrBuilder getUnitOrBuilder() { + if (extraCase_ == 8) { + return (fast.Fast.Element.Unit) extra_; + } + return fast.Fast.Element.Unit.getDefaultInstance(); + } + + public static final int LITERAL_FIELD_NUMBER = 9; + /** + * .fast.Element.Literal literal = 9; + */ + public fast.Fast.Element.Literal getLiteral() { + if (extraCase_ == 9) { + return (fast.Fast.Element.Literal) extra_; + } + return fast.Fast.Element.Literal.getDefaultInstance(); + } + /** + * .fast.Element.Literal literal = 9; + */ + public fast.Fast.Element.LiteralOrBuilder getLiteralOrBuilder() { + if (extraCase_ == 9) { + return (fast.Fast.Element.Literal) extra_; + } + return fast.Fast.Element.Literal.getDefaultInstance(); + } + + public static final int LINE_FIELD_NUMBER = 10; + private int line_; + /** + * int32 line = 10; + */ + public int getLine() { + return line_; + } + + public static final int COLUMN_FIELD_NUMBER = 11; + private int column_; + /** + * int32 column = 11; + */ + public int getColumn() { + return column_; + } + + public static final int LABEL_FIELD_NUMBER = 12; + private float label_; + /** + * float label = 12; + */ + public float getLabel() { + return label_; + } + + public static final int CHANGE_FIELD_NUMBER = 13; + private int change_; + /** + * .fast.Element.DiffType change = 13; + */ + public int getChangeValue() { + return change_; + } + /** + * .fast.Element.DiffType change = 13; + */ + public fast.Fast.Element.DiffType getChange() { + fast.Fast.Element.DiffType result = fast.Fast.Element.DiffType.valueOf(change_); + return result == null ? fast.Fast.Element.DiffType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (typeCase_ == 1) { + output.writeEnum(1, ((java.lang.Integer) type_)); + } + if (typeCase_ == 2) { + output.writeEnum(2, ((java.lang.Integer) type_)); + } + if (!text_.isEmpty()) { + output.writeBytes(3, text_); + } + if (pos_ != 0) { + output.writeInt32(4, pos_); + } + if (length_ != 0) { + output.writeInt32(5, length_); + } + for (int i = 0; i < child_.size(); i++) { + output.writeMessage(6, child_.get(i)); + } + if (!tail_.isEmpty()) { + output.writeBytes(7, tail_); + } + if (extraCase_ == 8) { + output.writeMessage(8, (fast.Fast.Element.Unit) extra_); + } + if (extraCase_ == 9) { + output.writeMessage(9, (fast.Fast.Element.Literal) extra_); + } + if (line_ != 0) { + output.writeInt32(10, line_); + } + if (column_ != 0) { + output.writeInt32(11, column_); + } + if (label_ != 0F) { + output.writeFloat(12, label_); + } + if (change_ != fast.Fast.Element.DiffType.MATCHED.getNumber()) { + output.writeEnum(13, change_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (typeCase_ == 1) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, ((java.lang.Integer) type_)); + } + if (typeCase_ == 2) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, ((java.lang.Integer) type_)); + } + if (!text_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, text_); + } + if (pos_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, pos_); + } + if (length_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(5, length_); + } + for (int i = 0; i < child_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, child_.get(i)); + } + if (!tail_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(7, tail_); + } + if (extraCase_ == 8) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, (fast.Fast.Element.Unit) extra_); + } + if (extraCase_ == 9) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, (fast.Fast.Element.Literal) extra_); + } + if (line_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(10, line_); + } + if (column_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(11, column_); + } + if (label_ != 0F) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(12, label_); + } + if (change_ != fast.Fast.Element.DiffType.MATCHED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(13, change_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Element)) { + return super.equals(obj); + } + fast.Fast.Element other = (fast.Fast.Element) obj; + + boolean result = true; + result = result && getText() + .equals(other.getText()); + result = result && (getPos() + == other.getPos()); + result = result && (getLength() + == other.getLength()); + result = result && getChildList() + .equals(other.getChildList()); + result = result && getTail() + .equals(other.getTail()); + result = result && (getLine() + == other.getLine()); + result = result && (getColumn() + == other.getColumn()); + result = result && ( + java.lang.Float.floatToIntBits(getLabel()) + == java.lang.Float.floatToIntBits( + other.getLabel())); + result = result && change_ == other.change_; + result = result && getTypeCase().equals( + other.getTypeCase()); + if (!result) return false; + switch (typeCase_) { + case 1: + result = result && getKindValue() + == other.getKindValue(); + break; + case 2: + result = result && getSmaliKindValue() + == other.getSmaliKindValue(); + break; + case 0: + default: + } + result = result && getExtraCase().equals( + other.getExtraCase()); + if (!result) return false; + switch (extraCase_) { + case 8: + result = result && getUnit() + .equals(other.getUnit()); + break; + case 9: + result = result && getLiteral() + .equals(other.getLiteral()); + break; + case 0: + default: + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TEXT_FIELD_NUMBER; + hash = (53 * hash) + getText().hashCode(); + hash = (37 * hash) + POS_FIELD_NUMBER; + hash = (53 * hash) + getPos(); + hash = (37 * hash) + LENGTH_FIELD_NUMBER; + hash = (53 * hash) + getLength(); + if (getChildCount() > 0) { + hash = (37 * hash) + CHILD_FIELD_NUMBER; + hash = (53 * hash) + getChildList().hashCode(); + } + hash = (37 * hash) + TAIL_FIELD_NUMBER; + hash = (53 * hash) + getTail().hashCode(); + hash = (37 * hash) + LINE_FIELD_NUMBER; + hash = (53 * hash) + getLine(); + hash = (37 * hash) + COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getColumn(); + hash = (37 * hash) + LABEL_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getLabel()); + hash = (37 * hash) + CHANGE_FIELD_NUMBER; + hash = (53 * hash) + change_; + switch (typeCase_) { + case 1: + hash = (37 * hash) + KIND_FIELD_NUMBER; + hash = (53 * hash) + getKindValue(); + break; + case 2: + hash = (37 * hash) + SMALI_KIND_FIELD_NUMBER; + hash = (53 * hash) + getSmaliKindValue(); + break; + case 0: + default: + } + switch (extraCase_) { + case 8: + hash = (37 * hash) + UNIT_FIELD_NUMBER; + hash = (53 * hash) + getUnit().hashCode(); + break; + case 9: + hash = (37 * hash) + LITERAL_FIELD_NUMBER; + hash = (53 * hash) + getLiteral().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Element parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Element parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Element parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Element parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Element parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Element parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Element prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     * smali generated by ANTLR4-CPP
+     *
+ * + * Protobuf type {@code fast.Element} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Element) + fast.Fast.ElementOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Element_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Element_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Element.class, fast.Fast.Element.Builder.class); + } + + // Construct using fast.Fast.Element.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getChildFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + text_ = com.google.protobuf.ByteString.EMPTY; + + pos_ = 0; + + length_ = 0; + + if (childBuilder_ == null) { + child_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + } else { + childBuilder_.clear(); + } + tail_ = com.google.protobuf.ByteString.EMPTY; + + line_ = 0; + + column_ = 0; + + label_ = 0F; + + change_ = 0; + + typeCase_ = 0; + type_ = null; + extraCase_ = 0; + extra_ = null; + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Element_descriptor; + } + + public fast.Fast.Element getDefaultInstanceForType() { + return fast.Fast.Element.getDefaultInstance(); + } + + public fast.Fast.Element build() { + fast.Fast.Element result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Element buildPartial() { + fast.Fast.Element result = new fast.Fast.Element(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (typeCase_ == 1) { + result.type_ = type_; + } + if (typeCase_ == 2) { + result.type_ = type_; + } + result.text_ = text_; + result.pos_ = pos_; + result.length_ = length_; + if (childBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020)) { + child_ = java.util.Collections.unmodifiableList(child_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.child_ = child_; + } else { + result.child_ = childBuilder_.build(); + } + result.tail_ = tail_; + if (extraCase_ == 8) { + if (unitBuilder_ == null) { + result.extra_ = extra_; + } else { + result.extra_ = unitBuilder_.build(); + } + } + if (extraCase_ == 9) { + if (literalBuilder_ == null) { + result.extra_ = extra_; + } else { + result.extra_ = literalBuilder_.build(); + } + } + result.line_ = line_; + result.column_ = column_; + result.label_ = label_; + result.change_ = change_; + result.bitField0_ = to_bitField0_; + result.typeCase_ = typeCase_; + result.extraCase_ = extraCase_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Element) { + return mergeFrom((fast.Fast.Element)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Element other) { + if (other == fast.Fast.Element.getDefaultInstance()) return this; + if (other.getText() != com.google.protobuf.ByteString.EMPTY) { + setText(other.getText()); + } + if (other.getPos() != 0) { + setPos(other.getPos()); + } + if (other.getLength() != 0) { + setLength(other.getLength()); + } + if (childBuilder_ == null) { + if (!other.child_.isEmpty()) { + if (child_.isEmpty()) { + child_ = other.child_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureChildIsMutable(); + child_.addAll(other.child_); + } + onChanged(); + } + } else { + if (!other.child_.isEmpty()) { + if (childBuilder_.isEmpty()) { + childBuilder_.dispose(); + childBuilder_ = null; + child_ = other.child_; + bitField0_ = (bitField0_ & ~0x00000020); + childBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getChildFieldBuilder() : null; + } else { + childBuilder_.addAllMessages(other.child_); + } + } + } + if (other.getTail() != com.google.protobuf.ByteString.EMPTY) { + setTail(other.getTail()); + } + if (other.getLine() != 0) { + setLine(other.getLine()); + } + if (other.getColumn() != 0) { + setColumn(other.getColumn()); + } + if (other.getLabel() != 0F) { + setLabel(other.getLabel()); + } + if (other.change_ != 0) { + setChangeValue(other.getChangeValue()); + } + switch (other.getTypeCase()) { + case KIND: { + setKindValue(other.getKindValue()); + break; + } + case SMALI_KIND: { + setSmaliKindValue(other.getSmaliKindValue()); + break; + } + case TYPE_NOT_SET: { + break; + } + } + switch (other.getExtraCase()) { + case UNIT: { + mergeUnit(other.getUnit()); + break; + } + case LITERAL: { + mergeLiteral(other.getLiteral()); + break; + } + case EXTRA_NOT_SET: { + break; + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Element parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Element) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int typeCase_ = 0; + private java.lang.Object type_; + public TypeCase + getTypeCase() { + return TypeCase.forNumber( + typeCase_); + } + + public Builder clearType() { + typeCase_ = 0; + type_ = null; + onChanged(); + return this; + } + + private int extraCase_ = 0; + private java.lang.Object extra_; + public ExtraCase + getExtraCase() { + return ExtraCase.forNumber( + extraCase_); + } + + public Builder clearExtra() { + extraCase_ = 0; + extra_ = null; + onChanged(); + return this; + } + + private int bitField0_; + + /** + * 
+       * default to srcML
+       *
+ * + * .fast.Element.Kind kind = 1; + */ + public int getKindValue() { + if (typeCase_ == 1) { + return ((java.lang.Integer) type_).intValue(); + } + return 0; + } + /** + * 
+       * default to srcML
+       *
+ * + * .fast.Element.Kind kind = 1; + */ + public Builder setKindValue(int value) { + typeCase_ = 1; + type_ = value; + onChanged(); + return this; + } + /** + * 
+       * default to srcML
+       *
+ * + * .fast.Element.Kind kind = 1; + */ + public fast.Fast.Element.Kind getKind() { + if (typeCase_ == 1) { + fast.Fast.Element.Kind result = fast.Fast.Element.Kind.valueOf( + (java.lang.Integer) type_); + return result == null ? fast.Fast.Element.Kind.UNRECOGNIZED : result; + } + return fast.Fast.Element.Kind.UNIT_KIND; + } + /** + * 
+       * default to srcML
+       *
+ * + * .fast.Element.Kind kind = 1; + */ + public Builder setKind(fast.Fast.Element.Kind value) { + if (value == null) { + throw new NullPointerException(); + } + typeCase_ = 1; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       * default to srcML
+       *
+ * + * .fast.Element.Kind kind = 1; + */ + public Builder clearKind() { + if (typeCase_ == 1) { + typeCase_ = 0; + type_ = null; + onChanged(); + } + return this; + } + + /** + * .fast.SmaliKind smali_kind = 2; + */ + public int getSmaliKindValue() { + if (typeCase_ == 2) { + return ((java.lang.Integer) type_).intValue(); + } + return 0; + } + /** + * .fast.SmaliKind smali_kind = 2; + */ + public Builder setSmaliKindValue(int value) { + typeCase_ = 2; + type_ = value; + onChanged(); + return this; + } + /** + * .fast.SmaliKind smali_kind = 2; + */ + public fast.Fast.SmaliKind getSmaliKind() { + if (typeCase_ == 2) { + fast.Fast.SmaliKind result = fast.Fast.SmaliKind.valueOf( + (java.lang.Integer) type_); + return result == null ? fast.Fast.SmaliKind.UNRECOGNIZED : result; + } + return fast.Fast.SmaliKind.smali_file; + } + /** + * .fast.SmaliKind smali_kind = 2; + */ + public Builder setSmaliKind(fast.Fast.SmaliKind value) { + if (value == null) { + throw new NullPointerException(); + } + typeCase_ = 2; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.SmaliKind smali_kind = 2; + */ + public Builder clearSmaliKind() { + if (typeCase_ == 2) { + typeCase_ = 0; + type_ = null; + onChanged(); + } + return this; + } + + private com.google.protobuf.ByteString text_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes text = 3; + */ + public com.google.protobuf.ByteString getText() { + return text_; + } + /** + * bytes text = 3; + */ + public Builder setText(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + text_ = value; + onChanged(); + return this; + } + /** + * bytes text = 3; + */ + public Builder clearText() { + + text_ = getDefaultInstance().getText(); + onChanged(); + return this; + } + + private int pos_ ; + /** + * int32 pos = 4; + */ + public int getPos() { + return pos_; + } + /** + * int32 pos = 4; + */ + public Builder setPos(int value) { + + pos_ = value; + onChanged(); + return this; + } + /** + * int32 pos = 4; + */ + public Builder clearPos() { + + pos_ = 0; + onChanged(); + return this; + } + + private int length_ ; + /** + * int32 length = 5; + */ + public int getLength() { + return length_; + } + /** + * int32 length = 5; + */ + public Builder setLength(int value) { + + length_ = value; + onChanged(); + return this; + } + /** + * int32 length = 5; + */ + public Builder clearLength() { + + length_ = 0; + onChanged(); + return this; + } + + private java.util.List child_ = + java.util.Collections.emptyList(); + private void ensureChildIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + child_ = new java.util.ArrayList(child_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> childBuilder_; + + /** + * repeated .fast.Element child = 6; + */ + public java.util.List getChildList() { + if (childBuilder_ == null) { + return java.util.Collections.unmodifiableList(child_); + } else { + return childBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Element child = 6; + */ + public int getChildCount() { + if (childBuilder_ == null) { + return child_.size(); + } else { + return childBuilder_.getCount(); + } + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.Element getChild(int index) { + if (childBuilder_ == null) { + return child_.get(index); + } else { + return childBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Element child = 6; + */ + public Builder setChild( + int index, fast.Fast.Element value) { + if (childBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureChildIsMutable(); + child_.set(index, value); + onChanged(); + } else { + childBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder setChild( + int index, fast.Fast.Element.Builder builderForValue) { + if (childBuilder_ == null) { + ensureChildIsMutable(); + child_.set(index, builderForValue.build()); + onChanged(); + } else { + childBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder addChild(fast.Fast.Element value) { + if (childBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureChildIsMutable(); + child_.add(value); + onChanged(); + } else { + childBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder addChild( + int index, fast.Fast.Element value) { + if (childBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureChildIsMutable(); + child_.add(index, value); + onChanged(); + } else { + childBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder addChild( + fast.Fast.Element.Builder builderForValue) { + if (childBuilder_ == null) { + ensureChildIsMutable(); + child_.add(builderForValue.build()); + onChanged(); + } else { + childBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder addChild( + int index, fast.Fast.Element.Builder builderForValue) { + if (childBuilder_ == null) { + ensureChildIsMutable(); + child_.add(index, builderForValue.build()); + onChanged(); + } else { + childBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder addAllChild( + java.lang.Iterable values) { + if (childBuilder_ == null) { + ensureChildIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, child_); + onChanged(); + } else { + childBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder clearChild() { + if (childBuilder_ == null) { + child_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + childBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public Builder removeChild(int index) { + if (childBuilder_ == null) { + ensureChildIsMutable(); + child_.remove(index); + onChanged(); + } else { + childBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.Element.Builder getChildBuilder( + int index) { + return getChildFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.ElementOrBuilder getChildOrBuilder( + int index) { + if (childBuilder_ == null) { + return child_.get(index); } else { + return childBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Element child = 6; + */ + public java.util.List + getChildOrBuilderList() { + if (childBuilder_ != null) { + return childBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(child_); + } + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.Element.Builder addChildBuilder() { + return getChildFieldBuilder().addBuilder( + fast.Fast.Element.getDefaultInstance()); + } + /** + * repeated .fast.Element child = 6; + */ + public fast.Fast.Element.Builder addChildBuilder( + int index) { + return getChildFieldBuilder().addBuilder( + index, fast.Fast.Element.getDefaultInstance()); + } + /** + * repeated .fast.Element child = 6; + */ + public java.util.List + getChildBuilderList() { + return getChildFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> + getChildFieldBuilder() { + if (childBuilder_ == null) { + childBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder>( + child_, + ((bitField0_ & 0x00000020) == 0x00000020), + getParentForChildren(), + isClean()); + child_ = null; + } + return childBuilder_; + } + + private com.google.protobuf.ByteString tail_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes tail = 7; + */ + public com.google.protobuf.ByteString getTail() { + return tail_; + } + /** + * bytes tail = 7; + */ + public Builder setTail(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + tail_ = value; + onChanged(); + return this; + } + /** + * bytes tail = 7; + */ + public Builder clearTail() { + + tail_ = getDefaultInstance().getTail(); + onChanged(); + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Unit, fast.Fast.Element.Unit.Builder, fast.Fast.Element.UnitOrBuilder> unitBuilder_; + /** + * .fast.Element.Unit unit = 8; + */ + public fast.Fast.Element.Unit getUnit() { + if (unitBuilder_ == null) { + if (extraCase_ == 8) { + return (fast.Fast.Element.Unit) extra_; + } + return fast.Fast.Element.Unit.getDefaultInstance(); + } else { + if (extraCase_ == 8) { + return unitBuilder_.getMessage(); + } + return fast.Fast.Element.Unit.getDefaultInstance(); + } + } + /** + * .fast.Element.Unit unit = 8; + */ + public Builder setUnit(fast.Fast.Element.Unit value) { + if (unitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + extra_ = value; + onChanged(); + } else { + unitBuilder_.setMessage(value); + } + extraCase_ = 8; + return this; + } + /** + * .fast.Element.Unit unit = 8; + */ + public Builder setUnit( + fast.Fast.Element.Unit.Builder builderForValue) { + if (unitBuilder_ == null) { + extra_ = builderForValue.build(); + onChanged(); + } else { + unitBuilder_.setMessage(builderForValue.build()); + } + extraCase_ = 8; + return this; + } + /** + * .fast.Element.Unit unit = 8; + */ + public Builder mergeUnit(fast.Fast.Element.Unit value) { + if (unitBuilder_ == null) { + if (extraCase_ == 8 && + extra_ != fast.Fast.Element.Unit.getDefaultInstance()) { + extra_ = fast.Fast.Element.Unit.newBuilder((fast.Fast.Element.Unit) extra_) + .mergeFrom(value).buildPartial(); + } else { + extra_ = value; + } + onChanged(); + } else { + if (extraCase_ == 8) { + unitBuilder_.mergeFrom(value); + } + unitBuilder_.setMessage(value); + } + extraCase_ = 8; + return this; + } + /** + * .fast.Element.Unit unit = 8; + */ + public Builder clearUnit() { + if (unitBuilder_ == null) { + if (extraCase_ == 8) { + extraCase_ = 0; + extra_ = null; + onChanged(); + } + } else { + if (extraCase_ == 8) { + extraCase_ = 0; + extra_ = null; + } + unitBuilder_.clear(); + } + return this; + } + /** + * .fast.Element.Unit unit = 8; + */ + public fast.Fast.Element.Unit.Builder getUnitBuilder() { + return getUnitFieldBuilder().getBuilder(); + } + /** + * .fast.Element.Unit unit = 8; + */ + public fast.Fast.Element.UnitOrBuilder getUnitOrBuilder() { + if ((extraCase_ == 8) && (unitBuilder_ != null)) { + return unitBuilder_.getMessageOrBuilder(); + } else { + if (extraCase_ == 8) { + return (fast.Fast.Element.Unit) extra_; + } + return fast.Fast.Element.Unit.getDefaultInstance(); + } + } + /** + * .fast.Element.Unit unit = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Unit, fast.Fast.Element.Unit.Builder, fast.Fast.Element.UnitOrBuilder> + getUnitFieldBuilder() { + if (unitBuilder_ == null) { + if (!(extraCase_ == 8)) { + extra_ = fast.Fast.Element.Unit.getDefaultInstance(); + } + unitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Unit, fast.Fast.Element.Unit.Builder, fast.Fast.Element.UnitOrBuilder>( + (fast.Fast.Element.Unit) extra_, + getParentForChildren(), + isClean()); + extra_ = null; + } + extraCase_ = 8; + onChanged();; + return unitBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Literal, fast.Fast.Element.Literal.Builder, fast.Fast.Element.LiteralOrBuilder> literalBuilder_; + /** + * .fast.Element.Literal literal = 9; + */ + public fast.Fast.Element.Literal getLiteral() { + if (literalBuilder_ == null) { + if (extraCase_ == 9) { + return (fast.Fast.Element.Literal) extra_; + } + return fast.Fast.Element.Literal.getDefaultInstance(); + } else { + if (extraCase_ == 9) { + return literalBuilder_.getMessage(); + } + return fast.Fast.Element.Literal.getDefaultInstance(); + } + } + /** + * .fast.Element.Literal literal = 9; + */ + public Builder setLiteral(fast.Fast.Element.Literal value) { + if (literalBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + extra_ = value; + onChanged(); + } else { + literalBuilder_.setMessage(value); + } + extraCase_ = 9; + return this; + } + /** + * .fast.Element.Literal literal = 9; + */ + public Builder setLiteral( + fast.Fast.Element.Literal.Builder builderForValue) { + if (literalBuilder_ == null) { + extra_ = builderForValue.build(); + onChanged(); + } else { + literalBuilder_.setMessage(builderForValue.build()); + } + extraCase_ = 9; + return this; + } + /** + * .fast.Element.Literal literal = 9; + */ + public Builder mergeLiteral(fast.Fast.Element.Literal value) { + if (literalBuilder_ == null) { + if (extraCase_ == 9 && + extra_ != fast.Fast.Element.Literal.getDefaultInstance()) { + extra_ = fast.Fast.Element.Literal.newBuilder((fast.Fast.Element.Literal) extra_) + .mergeFrom(value).buildPartial(); + } else { + extra_ = value; + } + onChanged(); + } else { + if (extraCase_ == 9) { + literalBuilder_.mergeFrom(value); + } + literalBuilder_.setMessage(value); + } + extraCase_ = 9; + return this; + } + /** + * .fast.Element.Literal literal = 9; + */ + public Builder clearLiteral() { + if (literalBuilder_ == null) { + if (extraCase_ == 9) { + extraCase_ = 0; + extra_ = null; + onChanged(); + } + } else { + if (extraCase_ == 9) { + extraCase_ = 0; + extra_ = null; + } + literalBuilder_.clear(); + } + return this; + } + /** + * .fast.Element.Literal literal = 9; + */ + public fast.Fast.Element.Literal.Builder getLiteralBuilder() { + return getLiteralFieldBuilder().getBuilder(); + } + /** + * .fast.Element.Literal literal = 9; + */ + public fast.Fast.Element.LiteralOrBuilder getLiteralOrBuilder() { + if ((extraCase_ == 9) && (literalBuilder_ != null)) { + return literalBuilder_.getMessageOrBuilder(); + } else { + if (extraCase_ == 9) { + return (fast.Fast.Element.Literal) extra_; + } + return fast.Fast.Element.Literal.getDefaultInstance(); + } + } + /** + * .fast.Element.Literal literal = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Literal, fast.Fast.Element.Literal.Builder, fast.Fast.Element.LiteralOrBuilder> + getLiteralFieldBuilder() { + if (literalBuilder_ == null) { + if (!(extraCase_ == 9)) { + extra_ = fast.Fast.Element.Literal.getDefaultInstance(); + } + literalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element.Literal, fast.Fast.Element.Literal.Builder, fast.Fast.Element.LiteralOrBuilder>( + (fast.Fast.Element.Literal) extra_, + getParentForChildren(), + isClean()); + extra_ = null; + } + extraCase_ = 9; + onChanged();; + return literalBuilder_; + } + + private int line_ ; + /** + * int32 line = 10; + */ + public int getLine() { + return line_; + } + /** + * int32 line = 10; + */ + public Builder setLine(int value) { + + line_ = value; + onChanged(); + return this; + } + /** + * int32 line = 10; + */ + public Builder clearLine() { + + line_ = 0; + onChanged(); + return this; + } + + private int column_ ; + /** + * int32 column = 11; + */ + public int getColumn() { + return column_; + } + /** + * int32 column = 11; + */ + public Builder setColumn(int value) { + + column_ = value; + onChanged(); + return this; + } + /** + * int32 column = 11; + */ + public Builder clearColumn() { + + column_ = 0; + onChanged(); + return this; + } + + private float label_ ; + /** + * float label = 12; + */ + public float getLabel() { + return label_; + } + /** + * float label = 12; + */ + public Builder setLabel(float value) { + + label_ = value; + onChanged(); + return this; + } + /** + * float label = 12; + */ + public Builder clearLabel() { + + label_ = 0F; + onChanged(); + return this; + } + + private int change_ = 0; + /** + * .fast.Element.DiffType change = 13; + */ + public int getChangeValue() { + return change_; + } + /** + * .fast.Element.DiffType change = 13; + */ + public Builder setChangeValue(int value) { + change_ = value; + onChanged(); + return this; + } + /** + * .fast.Element.DiffType change = 13; + */ + public fast.Fast.Element.DiffType getChange() { + fast.Fast.Element.DiffType result = fast.Fast.Element.DiffType.valueOf(change_); + return result == null ? fast.Fast.Element.DiffType.UNRECOGNIZED : result; + } + /** + * .fast.Element.DiffType change = 13; + */ + public Builder setChange(fast.Fast.Element.DiffType value) { + if (value == null) { + throw new NullPointerException(); + } + + change_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Element.DiffType change = 13; + */ + public Builder clearChange() { + + change_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Element) + } + + // @@protoc_insertion_point(class_scope:fast.Element) + private static final fast.Fast.Element DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Element(); + } + + public static fast.Fast.Element getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Element parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Element(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Element getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DeltaOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta) + com.google.protobuf.MessageOrBuilder { + + /** + * string src = 1; + */ + java.lang.String getSrc(); + /** + * string src = 1; + */ + com.google.protobuf.ByteString + getSrcBytes(); + + /** + * string dst = 2; + */ + java.lang.String getDst(); + /** + * string dst = 2; + */ + com.google.protobuf.ByteString + getDstBytes(); + + /** + * repeated .fast.Delta.Diff diff = 3; + */ + java.util.List + getDiffList(); + /** + * repeated .fast.Delta.Diff diff = 3; + */ + fast.Fast.Delta.Diff getDiff(int index); + /** + * repeated .fast.Delta.Diff diff = 3; + */ + int getDiffCount(); + /** + * repeated .fast.Delta.Diff diff = 3; + */ + java.util.List + getDiffOrBuilderList(); + /** + * repeated .fast.Delta.Diff diff = 3; + */ + fast.Fast.Delta.DiffOrBuilder getDiffOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Delta} + */ + public static final class Delta extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta) + DeltaOrBuilder { + // Use Delta.newBuilder() to construct. + private Delta(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Delta() { + src_ = ""; + dst_ = ""; + diff_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Delta( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + src_ = s; + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + dst_ = s; + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + diff_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + diff_.add( + input.readMessage(fast.Fast.Delta.Diff.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + diff_ = java.util.Collections.unmodifiableList(diff_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.class, fast.Fast.Delta.Builder.class); + } + + public interface DiffOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff) + com.google.protobuf.MessageOrBuilder { + + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + int getTypeValue(); + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + fast.Fast.Delta.Diff.DeltaType getType(); + + /** + * .fast.Delta.Diff.Match match = 2; + */ + fast.Fast.Delta.Diff.Match getMatch(); + /** + * .fast.Delta.Diff.Match match = 2; + */ + fast.Fast.Delta.Diff.MatchOrBuilder getMatchOrBuilder(); + + /** + * .fast.Delta.Diff.Add add = 3; + */ + fast.Fast.Delta.Diff.Add getAdd(); + /** + * .fast.Delta.Diff.Add add = 3; + */ + fast.Fast.Delta.Diff.AddOrBuilder getAddOrBuilder(); + + /** + * .fast.Delta.Diff.Del del = 4; + */ + fast.Fast.Delta.Diff.Del getDel(); + /** + * .fast.Delta.Diff.Del del = 4; + */ + fast.Fast.Delta.Diff.DelOrBuilder getDelOrBuilder(); + + /** + * .fast.Delta.Diff.Move move = 5; + */ + fast.Fast.Delta.Diff.Move getMove(); + /** + * .fast.Delta.Diff.Move move = 5; + */ + fast.Fast.Delta.Diff.MoveOrBuilder getMoveOrBuilder(); + + /** + * .fast.Delta.Diff.Update update = 6; + */ + fast.Fast.Delta.Diff.Update getUpdate(); + /** + * .fast.Delta.Diff.Update update = 6; + */ + fast.Fast.Delta.Diff.UpdateOrBuilder getUpdateOrBuilder(); + + public fast.Fast.Delta.Diff.DeltaCase getDeltaCase(); + } + /** + * Protobuf type {@code fast.Delta.Diff} + */ + public static final class Diff extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff) + DiffOrBuilder { + // Use Diff.newBuilder() to construct. + private Diff(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Diff() { + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Diff( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + case 18: { + fast.Fast.Delta.Diff.Match.Builder subBuilder = null; + if (deltaCase_ == 2) { + subBuilder = ((fast.Fast.Delta.Diff.Match) delta_).toBuilder(); + } + delta_ = + input.readMessage(fast.Fast.Delta.Diff.Match.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta.Diff.Match) delta_); + delta_ = subBuilder.buildPartial(); + } + deltaCase_ = 2; + break; + } + case 26: { + fast.Fast.Delta.Diff.Add.Builder subBuilder = null; + if (deltaCase_ == 3) { + subBuilder = ((fast.Fast.Delta.Diff.Add) delta_).toBuilder(); + } + delta_ = + input.readMessage(fast.Fast.Delta.Diff.Add.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta.Diff.Add) delta_); + delta_ = subBuilder.buildPartial(); + } + deltaCase_ = 3; + break; + } + case 34: { + fast.Fast.Delta.Diff.Del.Builder subBuilder = null; + if (deltaCase_ == 4) { + subBuilder = ((fast.Fast.Delta.Diff.Del) delta_).toBuilder(); + } + delta_ = + input.readMessage(fast.Fast.Delta.Diff.Del.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta.Diff.Del) delta_); + delta_ = subBuilder.buildPartial(); + } + deltaCase_ = 4; + break; + } + case 42: { + fast.Fast.Delta.Diff.Move.Builder subBuilder = null; + if (deltaCase_ == 5) { + subBuilder = ((fast.Fast.Delta.Diff.Move) delta_).toBuilder(); + } + delta_ = + input.readMessage(fast.Fast.Delta.Diff.Move.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta.Diff.Move) delta_); + delta_ = subBuilder.buildPartial(); + } + deltaCase_ = 5; + break; + } + case 50: { + fast.Fast.Delta.Diff.Update.Builder subBuilder = null; + if (deltaCase_ == 6) { + subBuilder = ((fast.Fast.Delta.Diff.Update) delta_).toBuilder(); + } + delta_ = + input.readMessage(fast.Fast.Delta.Diff.Update.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta.Diff.Update) delta_); + delta_ = subBuilder.buildPartial(); + } + deltaCase_ = 6; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.class, fast.Fast.Delta.Diff.Builder.class); + } + + /** + * Protobuf enum {@code fast.Delta.Diff.DeltaType} + */ + public enum DeltaType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * MATCH = 0; + */ + MATCH(0), + /** + * ADD = 1; + */ + ADD(1), + /** + * DEL = 2; + */ + DEL(2), + /** + * MOVE = 3; + */ + MOVE(3), + /** + * UPDATE = 4; + */ + UPDATE(4), + UNRECOGNIZED(-1), + ; + + /** + * MATCH = 0; + */ + public static final int MATCH_VALUE = 0; + /** + * ADD = 1; + */ + public static final int ADD_VALUE = 1; + /** + * DEL = 2; + */ + public static final int DEL_VALUE = 2; + /** + * MOVE = 3; + */ + public static final int MOVE_VALUE = 3; + /** + * UPDATE = 4; + */ + public static final int UPDATE_VALUE = 4; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static DeltaType valueOf(int value) { + return forNumber(value); + } + + public static DeltaType forNumber(int value) { + switch (value) { + case 0: return MATCH; + case 1: return ADD; + case 2: return DEL; + case 3: return MOVE; + case 4: return UPDATE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + DeltaType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public DeltaType findValueByNumber(int number) { + return DeltaType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Delta.Diff.getDescriptor().getEnumTypes().get(0); + } + + private static final DeltaType[] VALUES = values(); + + public static DeltaType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private DeltaType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Delta.Diff.DeltaType) + } + + public interface MatchOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff.Match) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 src = 1; + */ + int getSrc(); + + /** + * int32 dst = 2; + */ + int getDst(); + } + /** + * Protobuf type {@code fast.Delta.Diff.Match} + */ + public static final class Match extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff.Match) + MatchOrBuilder { + // Use Match.newBuilder() to construct. + private Match(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Match() { + src_ = 0; + dst_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Match( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + src_ = input.readInt32(); + break; + } + case 16: { + + dst_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Match_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Match_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Match.class, fast.Fast.Delta.Diff.Match.Builder.class); + } + + public static final int SRC_FIELD_NUMBER = 1; + private int src_; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + + public static final int DST_FIELD_NUMBER = 2; + private int dst_; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (src_ != 0) { + output.writeInt32(1, src_); + } + if (dst_ != 0) { + output.writeInt32(2, dst_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (src_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, src_); + } + if (dst_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, dst_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff.Match)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff.Match other = (fast.Fast.Delta.Diff.Match) obj; + + boolean result = true; + result = result && (getSrc() + == other.getSrc()); + result = result && (getDst() + == other.getDst()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc(); + hash = (37 * hash) + DST_FIELD_NUMBER; + hash = (53 * hash) + getDst(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff.Match parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Match parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Match parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Match parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Match parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Match parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff.Match prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff.Match} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff.Match) + fast.Fast.Delta.Diff.MatchOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Match_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Match_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Match.class, fast.Fast.Delta.Diff.Match.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.Match.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + src_ = 0; + + dst_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_Match_descriptor; + } + + public fast.Fast.Delta.Diff.Match getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff.Match build() { + fast.Fast.Delta.Diff.Match result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff.Match buildPartial() { + fast.Fast.Delta.Diff.Match result = new fast.Fast.Delta.Diff.Match(this); + result.src_ = src_; + result.dst_ = dst_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff.Match) { + return mergeFrom((fast.Fast.Delta.Diff.Match)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff.Match other) { + if (other == fast.Fast.Delta.Diff.Match.getDefaultInstance()) return this; + if (other.getSrc() != 0) { + setSrc(other.getSrc()); + } + if (other.getDst() != 0) { + setDst(other.getDst()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff.Match parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff.Match) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int src_ ; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + /** + * int32 src = 1; + */ + public Builder setSrc(int value) { + + src_ = value; + onChanged(); + return this; + } + /** + * int32 src = 1; + */ + public Builder clearSrc() { + + src_ = 0; + onChanged(); + return this; + } + + private int dst_ ; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + /** + * int32 dst = 2; + */ + public Builder setDst(int value) { + + dst_ = value; + onChanged(); + return this; + } + /** + * int32 dst = 2; + */ + public Builder clearDst() { + + dst_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff.Match) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff.Match) + private static final fast.Fast.Delta.Diff.Match DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff.Match(); + } + + public static fast.Fast.Delta.Diff.Match getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Match parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Match(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff.Match getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface AddOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff.Add) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 src = 1; + */ + int getSrc(); + + /** + * int32 dst = 2; + */ + int getDst(); + + /** + * int32 position = 3; + */ + int getPosition(); + } + /** + * Protobuf type {@code fast.Delta.Diff.Add} + */ + public static final class Add extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff.Add) + AddOrBuilder { + // Use Add.newBuilder() to construct. + private Add(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Add() { + src_ = 0; + dst_ = 0; + position_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Add( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + src_ = input.readInt32(); + break; + } + case 16: { + + dst_ = input.readInt32(); + break; + } + case 24: { + + position_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Add_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Add_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Add.class, fast.Fast.Delta.Diff.Add.Builder.class); + } + + public static final int SRC_FIELD_NUMBER = 1; + private int src_; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + + public static final int DST_FIELD_NUMBER = 2; + private int dst_; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + + public static final int POSITION_FIELD_NUMBER = 3; + private int position_; + /** + * int32 position = 3; + */ + public int getPosition() { + return position_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (src_ != 0) { + output.writeInt32(1, src_); + } + if (dst_ != 0) { + output.writeInt32(2, dst_); + } + if (position_ != 0) { + output.writeInt32(3, position_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (src_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, src_); + } + if (dst_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, dst_); + } + if (position_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, position_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff.Add)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff.Add other = (fast.Fast.Delta.Diff.Add) obj; + + boolean result = true; + result = result && (getSrc() + == other.getSrc()); + result = result && (getDst() + == other.getDst()); + result = result && (getPosition() + == other.getPosition()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc(); + hash = (37 * hash) + DST_FIELD_NUMBER; + hash = (53 * hash) + getDst(); + hash = (37 * hash) + POSITION_FIELD_NUMBER; + hash = (53 * hash) + getPosition(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff.Add parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Add parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Add parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Add parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Add parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Add parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff.Add prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff.Add} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff.Add) + fast.Fast.Delta.Diff.AddOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Add_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Add_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Add.class, fast.Fast.Delta.Diff.Add.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.Add.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + src_ = 0; + + dst_ = 0; + + position_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_Add_descriptor; + } + + public fast.Fast.Delta.Diff.Add getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff.Add build() { + fast.Fast.Delta.Diff.Add result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff.Add buildPartial() { + fast.Fast.Delta.Diff.Add result = new fast.Fast.Delta.Diff.Add(this); + result.src_ = src_; + result.dst_ = dst_; + result.position_ = position_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff.Add) { + return mergeFrom((fast.Fast.Delta.Diff.Add)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff.Add other) { + if (other == fast.Fast.Delta.Diff.Add.getDefaultInstance()) return this; + if (other.getSrc() != 0) { + setSrc(other.getSrc()); + } + if (other.getDst() != 0) { + setDst(other.getDst()); + } + if (other.getPosition() != 0) { + setPosition(other.getPosition()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff.Add parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff.Add) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int src_ ; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + /** + * int32 src = 1; + */ + public Builder setSrc(int value) { + + src_ = value; + onChanged(); + return this; + } + /** + * int32 src = 1; + */ + public Builder clearSrc() { + + src_ = 0; + onChanged(); + return this; + } + + private int dst_ ; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + /** + * int32 dst = 2; + */ + public Builder setDst(int value) { + + dst_ = value; + onChanged(); + return this; + } + /** + * int32 dst = 2; + */ + public Builder clearDst() { + + dst_ = 0; + onChanged(); + return this; + } + + private int position_ ; + /** + * int32 position = 3; + */ + public int getPosition() { + return position_; + } + /** + * int32 position = 3; + */ + public Builder setPosition(int value) { + + position_ = value; + onChanged(); + return this; + } + /** + * int32 position = 3; + */ + public Builder clearPosition() { + + position_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff.Add) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff.Add) + private static final fast.Fast.Delta.Diff.Add DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff.Add(); + } + + public static fast.Fast.Delta.Diff.Add getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Add parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Add(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff.Add getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DelOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff.Del) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 src = 1; + */ + int getSrc(); + } + /** + * Protobuf type {@code fast.Delta.Diff.Del} + */ + public static final class Del extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff.Del) + DelOrBuilder { + // Use Del.newBuilder() to construct. + private Del(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Del() { + src_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Del( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + src_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Del_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Del_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Del.class, fast.Fast.Delta.Diff.Del.Builder.class); + } + + public static final int SRC_FIELD_NUMBER = 1; + private int src_; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (src_ != 0) { + output.writeInt32(1, src_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (src_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, src_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff.Del)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff.Del other = (fast.Fast.Delta.Diff.Del) obj; + + boolean result = true; + result = result && (getSrc() + == other.getSrc()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff.Del parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Del parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Del parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Del parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Del parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Del parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff.Del prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff.Del} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff.Del) + fast.Fast.Delta.Diff.DelOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Del_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Del_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Del.class, fast.Fast.Delta.Diff.Del.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.Del.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + src_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_Del_descriptor; + } + + public fast.Fast.Delta.Diff.Del getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff.Del build() { + fast.Fast.Delta.Diff.Del result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff.Del buildPartial() { + fast.Fast.Delta.Diff.Del result = new fast.Fast.Delta.Diff.Del(this); + result.src_ = src_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff.Del) { + return mergeFrom((fast.Fast.Delta.Diff.Del)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff.Del other) { + if (other == fast.Fast.Delta.Diff.Del.getDefaultInstance()) return this; + if (other.getSrc() != 0) { + setSrc(other.getSrc()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff.Del parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff.Del) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int src_ ; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + /** + * int32 src = 1; + */ + public Builder setSrc(int value) { + + src_ = value; + onChanged(); + return this; + } + /** + * int32 src = 1; + */ + public Builder clearSrc() { + + src_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff.Del) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff.Del) + private static final fast.Fast.Delta.Diff.Del DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff.Del(); + } + + public static fast.Fast.Delta.Diff.Del getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Del parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Del(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff.Del getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface MoveOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff.Move) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 src = 1; + */ + int getSrc(); + + /** + * int32 dst = 2; + */ + int getDst(); + + /** + * int32 position = 3; + */ + int getPosition(); + } + /** + * Protobuf type {@code fast.Delta.Diff.Move} + */ + public static final class Move extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff.Move) + MoveOrBuilder { + // Use Move.newBuilder() to construct. + private Move(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Move() { + src_ = 0; + dst_ = 0; + position_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Move( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + src_ = input.readInt32(); + break; + } + case 16: { + + dst_ = input.readInt32(); + break; + } + case 24: { + + position_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Move_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Move_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Move.class, fast.Fast.Delta.Diff.Move.Builder.class); + } + + public static final int SRC_FIELD_NUMBER = 1; + private int src_; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + + public static final int DST_FIELD_NUMBER = 2; + private int dst_; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + + public static final int POSITION_FIELD_NUMBER = 3; + private int position_; + /** + * int32 position = 3; + */ + public int getPosition() { + return position_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (src_ != 0) { + output.writeInt32(1, src_); + } + if (dst_ != 0) { + output.writeInt32(2, dst_); + } + if (position_ != 0) { + output.writeInt32(3, position_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (src_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, src_); + } + if (dst_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, dst_); + } + if (position_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, position_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff.Move)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff.Move other = (fast.Fast.Delta.Diff.Move) obj; + + boolean result = true; + result = result && (getSrc() + == other.getSrc()); + result = result && (getDst() + == other.getDst()); + result = result && (getPosition() + == other.getPosition()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc(); + hash = (37 * hash) + DST_FIELD_NUMBER; + hash = (53 * hash) + getDst(); + hash = (37 * hash) + POSITION_FIELD_NUMBER; + hash = (53 * hash) + getPosition(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff.Move parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Move parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Move parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Move parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Move parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Move parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff.Move prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff.Move} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff.Move) + fast.Fast.Delta.Diff.MoveOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Move_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Move_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Move.class, fast.Fast.Delta.Diff.Move.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.Move.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + src_ = 0; + + dst_ = 0; + + position_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_Move_descriptor; + } + + public fast.Fast.Delta.Diff.Move getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff.Move build() { + fast.Fast.Delta.Diff.Move result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff.Move buildPartial() { + fast.Fast.Delta.Diff.Move result = new fast.Fast.Delta.Diff.Move(this); + result.src_ = src_; + result.dst_ = dst_; + result.position_ = position_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff.Move) { + return mergeFrom((fast.Fast.Delta.Diff.Move)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff.Move other) { + if (other == fast.Fast.Delta.Diff.Move.getDefaultInstance()) return this; + if (other.getSrc() != 0) { + setSrc(other.getSrc()); + } + if (other.getDst() != 0) { + setDst(other.getDst()); + } + if (other.getPosition() != 0) { + setPosition(other.getPosition()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff.Move parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff.Move) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int src_ ; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + /** + * int32 src = 1; + */ + public Builder setSrc(int value) { + + src_ = value; + onChanged(); + return this; + } + /** + * int32 src = 1; + */ + public Builder clearSrc() { + + src_ = 0; + onChanged(); + return this; + } + + private int dst_ ; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + /** + * int32 dst = 2; + */ + public Builder setDst(int value) { + + dst_ = value; + onChanged(); + return this; + } + /** + * int32 dst = 2; + */ + public Builder clearDst() { + + dst_ = 0; + onChanged(); + return this; + } + + private int position_ ; + /** + * int32 position = 3; + */ + public int getPosition() { + return position_; + } + /** + * int32 position = 3; + */ + public Builder setPosition(int value) { + + position_ = value; + onChanged(); + return this; + } + /** + * int32 position = 3; + */ + public Builder clearPosition() { + + position_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff.Move) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff.Move) + private static final fast.Fast.Delta.Diff.Move DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff.Move(); + } + + public static fast.Fast.Delta.Diff.Move getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Move parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Move(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff.Move getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface UpdateOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Delta.Diff.Update) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 src = 1; + */ + int getSrc(); + + /** + * int32 dst = 2; + */ + int getDst(); + } + /** + * Protobuf type {@code fast.Delta.Diff.Update} + */ + public static final class Update extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Delta.Diff.Update) + UpdateOrBuilder { + // Use Update.newBuilder() to construct. + private Update(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Update() { + src_ = 0; + dst_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Update( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + src_ = input.readInt32(); + break; + } + case 16: { + + dst_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Update_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Update_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Update.class, fast.Fast.Delta.Diff.Update.Builder.class); + } + + public static final int SRC_FIELD_NUMBER = 1; + private int src_; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + + public static final int DST_FIELD_NUMBER = 2; + private int dst_; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (src_ != 0) { + output.writeInt32(1, src_); + } + if (dst_ != 0) { + output.writeInt32(2, dst_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (src_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, src_); + } + if (dst_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, dst_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff.Update)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff.Update other = (fast.Fast.Delta.Diff.Update) obj; + + boolean result = true; + result = result && (getSrc() + == other.getSrc()); + result = result && (getDst() + == other.getDst()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc(); + hash = (37 * hash) + DST_FIELD_NUMBER; + hash = (53 * hash) + getDst(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff.Update parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Update parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Update parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Update parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Update parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff.Update parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff.Update prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff.Update} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff.Update) + fast.Fast.Delta.Diff.UpdateOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_Update_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_Update_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.Update.class, fast.Fast.Delta.Diff.Update.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.Update.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + src_ = 0; + + dst_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_Update_descriptor; + } + + public fast.Fast.Delta.Diff.Update getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff.Update build() { + fast.Fast.Delta.Diff.Update result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff.Update buildPartial() { + fast.Fast.Delta.Diff.Update result = new fast.Fast.Delta.Diff.Update(this); + result.src_ = src_; + result.dst_ = dst_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff.Update) { + return mergeFrom((fast.Fast.Delta.Diff.Update)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff.Update other) { + if (other == fast.Fast.Delta.Diff.Update.getDefaultInstance()) return this; + if (other.getSrc() != 0) { + setSrc(other.getSrc()); + } + if (other.getDst() != 0) { + setDst(other.getDst()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff.Update parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff.Update) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int src_ ; + /** + * int32 src = 1; + */ + public int getSrc() { + return src_; + } + /** + * int32 src = 1; + */ + public Builder setSrc(int value) { + + src_ = value; + onChanged(); + return this; + } + /** + * int32 src = 1; + */ + public Builder clearSrc() { + + src_ = 0; + onChanged(); + return this; + } + + private int dst_ ; + /** + * int32 dst = 2; + */ + public int getDst() { + return dst_; + } + /** + * int32 dst = 2; + */ + public Builder setDst(int value) { + + dst_ = value; + onChanged(); + return this; + } + /** + * int32 dst = 2; + */ + public Builder clearDst() { + + dst_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff.Update) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff.Update) + private static final fast.Fast.Delta.Diff.Update DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff.Update(); + } + + public static fast.Fast.Delta.Diff.Update getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Update parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Update(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff.Update getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int deltaCase_ = 0; + private java.lang.Object delta_; + public enum DeltaCase + implements com.google.protobuf.Internal.EnumLite { + MATCH(2), + ADD(3), + DEL(4), + MOVE(5), + UPDATE(6), + DELTA_NOT_SET(0); + private final int value; + private DeltaCase(int value) { + this.value = value; + } + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static DeltaCase valueOf(int value) { + return forNumber(value); + } + + public static DeltaCase forNumber(int value) { + switch (value) { + case 2: return MATCH; + case 3: return ADD; + case 4: return DEL; + case 5: return MOVE; + case 6: return UPDATE; + case 0: return DELTA_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public DeltaCase + getDeltaCase() { + return DeltaCase.forNumber( + deltaCase_); + } + + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public fast.Fast.Delta.Diff.DeltaType getType() { + fast.Fast.Delta.Diff.DeltaType result = fast.Fast.Delta.Diff.DeltaType.valueOf(type_); + return result == null ? fast.Fast.Delta.Diff.DeltaType.UNRECOGNIZED : result; + } + + public static final int MATCH_FIELD_NUMBER = 2; + /** + * .fast.Delta.Diff.Match match = 2; + */ + public fast.Fast.Delta.Diff.Match getMatch() { + if (deltaCase_ == 2) { + return (fast.Fast.Delta.Diff.Match) delta_; + } + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public fast.Fast.Delta.Diff.MatchOrBuilder getMatchOrBuilder() { + if (deltaCase_ == 2) { + return (fast.Fast.Delta.Diff.Match) delta_; + } + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + + public static final int ADD_FIELD_NUMBER = 3; + /** + * .fast.Delta.Diff.Add add = 3; + */ + public fast.Fast.Delta.Diff.Add getAdd() { + if (deltaCase_ == 3) { + return (fast.Fast.Delta.Diff.Add) delta_; + } + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public fast.Fast.Delta.Diff.AddOrBuilder getAddOrBuilder() { + if (deltaCase_ == 3) { + return (fast.Fast.Delta.Diff.Add) delta_; + } + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + + public static final int DEL_FIELD_NUMBER = 4; + /** + * .fast.Delta.Diff.Del del = 4; + */ + public fast.Fast.Delta.Diff.Del getDel() { + if (deltaCase_ == 4) { + return (fast.Fast.Delta.Diff.Del) delta_; + } + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public fast.Fast.Delta.Diff.DelOrBuilder getDelOrBuilder() { + if (deltaCase_ == 4) { + return (fast.Fast.Delta.Diff.Del) delta_; + } + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + + public static final int MOVE_FIELD_NUMBER = 5; + /** + * .fast.Delta.Diff.Move move = 5; + */ + public fast.Fast.Delta.Diff.Move getMove() { + if (deltaCase_ == 5) { + return (fast.Fast.Delta.Diff.Move) delta_; + } + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public fast.Fast.Delta.Diff.MoveOrBuilder getMoveOrBuilder() { + if (deltaCase_ == 5) { + return (fast.Fast.Delta.Diff.Move) delta_; + } + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + + public static final int UPDATE_FIELD_NUMBER = 6; + /** + * .fast.Delta.Diff.Update update = 6; + */ + public fast.Fast.Delta.Diff.Update getUpdate() { + if (deltaCase_ == 6) { + return (fast.Fast.Delta.Diff.Update) delta_; + } + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public fast.Fast.Delta.Diff.UpdateOrBuilder getUpdateOrBuilder() { + if (deltaCase_ == 6) { + return (fast.Fast.Delta.Diff.Update) delta_; + } + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (type_ != fast.Fast.Delta.Diff.DeltaType.MATCH.getNumber()) { + output.writeEnum(1, type_); + } + if (deltaCase_ == 2) { + output.writeMessage(2, (fast.Fast.Delta.Diff.Match) delta_); + } + if (deltaCase_ == 3) { + output.writeMessage(3, (fast.Fast.Delta.Diff.Add) delta_); + } + if (deltaCase_ == 4) { + output.writeMessage(4, (fast.Fast.Delta.Diff.Del) delta_); + } + if (deltaCase_ == 5) { + output.writeMessage(5, (fast.Fast.Delta.Diff.Move) delta_); + } + if (deltaCase_ == 6) { + output.writeMessage(6, (fast.Fast.Delta.Diff.Update) delta_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (type_ != fast.Fast.Delta.Diff.DeltaType.MATCH.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (deltaCase_ == 2) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, (fast.Fast.Delta.Diff.Match) delta_); + } + if (deltaCase_ == 3) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, (fast.Fast.Delta.Diff.Add) delta_); + } + if (deltaCase_ == 4) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, (fast.Fast.Delta.Diff.Del) delta_); + } + if (deltaCase_ == 5) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, (fast.Fast.Delta.Diff.Move) delta_); + } + if (deltaCase_ == 6) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, (fast.Fast.Delta.Diff.Update) delta_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta.Diff)) { + return super.equals(obj); + } + fast.Fast.Delta.Diff other = (fast.Fast.Delta.Diff) obj; + + boolean result = true; + result = result && type_ == other.type_; + result = result && getDeltaCase().equals( + other.getDeltaCase()); + if (!result) return false; + switch (deltaCase_) { + case 2: + result = result && getMatch() + .equals(other.getMatch()); + break; + case 3: + result = result && getAdd() + .equals(other.getAdd()); + break; + case 4: + result = result && getDel() + .equals(other.getDel()); + break; + case 5: + result = result && getMove() + .equals(other.getMove()); + break; + case 6: + result = result && getUpdate() + .equals(other.getUpdate()); + break; + case 0: + default: + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + switch (deltaCase_) { + case 2: + hash = (37 * hash) + MATCH_FIELD_NUMBER; + hash = (53 * hash) + getMatch().hashCode(); + break; + case 3: + hash = (37 * hash) + ADD_FIELD_NUMBER; + hash = (53 * hash) + getAdd().hashCode(); + break; + case 4: + hash = (37 * hash) + DEL_FIELD_NUMBER; + hash = (53 * hash) + getDel().hashCode(); + break; + case 5: + hash = (37 * hash) + MOVE_FIELD_NUMBER; + hash = (53 * hash) + getMove().hashCode(); + break; + case 6: + hash = (37 * hash) + UPDATE_FIELD_NUMBER; + hash = (53 * hash) + getUpdate().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta.Diff parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta.Diff parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta.Diff parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta.Diff parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta.Diff parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta.Diff prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta.Diff} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta.Diff) + fast.Fast.Delta.DiffOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.Diff.class, fast.Fast.Delta.Diff.Builder.class); + } + + // Construct using fast.Fast.Delta.Diff.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + type_ = 0; + + deltaCase_ = 0; + delta_ = null; + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_Diff_descriptor; + } + + public fast.Fast.Delta.Diff getDefaultInstanceForType() { + return fast.Fast.Delta.Diff.getDefaultInstance(); + } + + public fast.Fast.Delta.Diff build() { + fast.Fast.Delta.Diff result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta.Diff buildPartial() { + fast.Fast.Delta.Diff result = new fast.Fast.Delta.Diff(this); + result.type_ = type_; + if (deltaCase_ == 2) { + if (matchBuilder_ == null) { + result.delta_ = delta_; + } else { + result.delta_ = matchBuilder_.build(); + } + } + if (deltaCase_ == 3) { + if (addBuilder_ == null) { + result.delta_ = delta_; + } else { + result.delta_ = addBuilder_.build(); + } + } + if (deltaCase_ == 4) { + if (delBuilder_ == null) { + result.delta_ = delta_; + } else { + result.delta_ = delBuilder_.build(); + } + } + if (deltaCase_ == 5) { + if (moveBuilder_ == null) { + result.delta_ = delta_; + } else { + result.delta_ = moveBuilder_.build(); + } + } + if (deltaCase_ == 6) { + if (updateBuilder_ == null) { + result.delta_ = delta_; + } else { + result.delta_ = updateBuilder_.build(); + } + } + result.deltaCase_ = deltaCase_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta.Diff) { + return mergeFrom((fast.Fast.Delta.Diff)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta.Diff other) { + if (other == fast.Fast.Delta.Diff.getDefaultInstance()) return this; + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + switch (other.getDeltaCase()) { + case MATCH: { + mergeMatch(other.getMatch()); + break; + } + case ADD: { + mergeAdd(other.getAdd()); + break; + } + case DEL: { + mergeDel(other.getDel()); + break; + } + case MOVE: { + mergeMove(other.getMove()); + break; + } + case UPDATE: { + mergeUpdate(other.getUpdate()); + break; + } + case DELTA_NOT_SET: { + break; + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta.Diff parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta.Diff) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int deltaCase_ = 0; + private java.lang.Object delta_; + public DeltaCase + getDeltaCase() { + return DeltaCase.forNumber( + deltaCase_); + } + + public Builder clearDelta() { + deltaCase_ = 0; + delta_ = null; + onChanged(); + return this; + } + + + private int type_ = 0; + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public fast.Fast.Delta.Diff.DeltaType getType() { + fast.Fast.Delta.Diff.DeltaType result = fast.Fast.Delta.Diff.DeltaType.valueOf(type_); + return result == null ? fast.Fast.Delta.Diff.DeltaType.UNRECOGNIZED : result; + } + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public Builder setType(fast.Fast.Delta.Diff.DeltaType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Delta.Diff.DeltaType type = 1; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Match, fast.Fast.Delta.Diff.Match.Builder, fast.Fast.Delta.Diff.MatchOrBuilder> matchBuilder_; + /** + * .fast.Delta.Diff.Match match = 2; + */ + public fast.Fast.Delta.Diff.Match getMatch() { + if (matchBuilder_ == null) { + if (deltaCase_ == 2) { + return (fast.Fast.Delta.Diff.Match) delta_; + } + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } else { + if (deltaCase_ == 2) { + return matchBuilder_.getMessage(); + } + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public Builder setMatch(fast.Fast.Delta.Diff.Match value) { + if (matchBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delta_ = value; + onChanged(); + } else { + matchBuilder_.setMessage(value); + } + deltaCase_ = 2; + return this; + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public Builder setMatch( + fast.Fast.Delta.Diff.Match.Builder builderForValue) { + if (matchBuilder_ == null) { + delta_ = builderForValue.build(); + onChanged(); + } else { + matchBuilder_.setMessage(builderForValue.build()); + } + deltaCase_ = 2; + return this; + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public Builder mergeMatch(fast.Fast.Delta.Diff.Match value) { + if (matchBuilder_ == null) { + if (deltaCase_ == 2 && + delta_ != fast.Fast.Delta.Diff.Match.getDefaultInstance()) { + delta_ = fast.Fast.Delta.Diff.Match.newBuilder((fast.Fast.Delta.Diff.Match) delta_) + .mergeFrom(value).buildPartial(); + } else { + delta_ = value; + } + onChanged(); + } else { + if (deltaCase_ == 2) { + matchBuilder_.mergeFrom(value); + } + matchBuilder_.setMessage(value); + } + deltaCase_ = 2; + return this; + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public Builder clearMatch() { + if (matchBuilder_ == null) { + if (deltaCase_ == 2) { + deltaCase_ = 0; + delta_ = null; + onChanged(); + } + } else { + if (deltaCase_ == 2) { + deltaCase_ = 0; + delta_ = null; + } + matchBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public fast.Fast.Delta.Diff.Match.Builder getMatchBuilder() { + return getMatchFieldBuilder().getBuilder(); + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + public fast.Fast.Delta.Diff.MatchOrBuilder getMatchOrBuilder() { + if ((deltaCase_ == 2) && (matchBuilder_ != null)) { + return matchBuilder_.getMessageOrBuilder(); + } else { + if (deltaCase_ == 2) { + return (fast.Fast.Delta.Diff.Match) delta_; + } + return fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Match match = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Match, fast.Fast.Delta.Diff.Match.Builder, fast.Fast.Delta.Diff.MatchOrBuilder> + getMatchFieldBuilder() { + if (matchBuilder_ == null) { + if (!(deltaCase_ == 2)) { + delta_ = fast.Fast.Delta.Diff.Match.getDefaultInstance(); + } + matchBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Match, fast.Fast.Delta.Diff.Match.Builder, fast.Fast.Delta.Diff.MatchOrBuilder>( + (fast.Fast.Delta.Diff.Match) delta_, + getParentForChildren(), + isClean()); + delta_ = null; + } + deltaCase_ = 2; + onChanged();; + return matchBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Add, fast.Fast.Delta.Diff.Add.Builder, fast.Fast.Delta.Diff.AddOrBuilder> addBuilder_; + /** + * .fast.Delta.Diff.Add add = 3; + */ + public fast.Fast.Delta.Diff.Add getAdd() { + if (addBuilder_ == null) { + if (deltaCase_ == 3) { + return (fast.Fast.Delta.Diff.Add) delta_; + } + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } else { + if (deltaCase_ == 3) { + return addBuilder_.getMessage(); + } + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public Builder setAdd(fast.Fast.Delta.Diff.Add value) { + if (addBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delta_ = value; + onChanged(); + } else { + addBuilder_.setMessage(value); + } + deltaCase_ = 3; + return this; + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public Builder setAdd( + fast.Fast.Delta.Diff.Add.Builder builderForValue) { + if (addBuilder_ == null) { + delta_ = builderForValue.build(); + onChanged(); + } else { + addBuilder_.setMessage(builderForValue.build()); + } + deltaCase_ = 3; + return this; + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public Builder mergeAdd(fast.Fast.Delta.Diff.Add value) { + if (addBuilder_ == null) { + if (deltaCase_ == 3 && + delta_ != fast.Fast.Delta.Diff.Add.getDefaultInstance()) { + delta_ = fast.Fast.Delta.Diff.Add.newBuilder((fast.Fast.Delta.Diff.Add) delta_) + .mergeFrom(value).buildPartial(); + } else { + delta_ = value; + } + onChanged(); + } else { + if (deltaCase_ == 3) { + addBuilder_.mergeFrom(value); + } + addBuilder_.setMessage(value); + } + deltaCase_ = 3; + return this; + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public Builder clearAdd() { + if (addBuilder_ == null) { + if (deltaCase_ == 3) { + deltaCase_ = 0; + delta_ = null; + onChanged(); + } + } else { + if (deltaCase_ == 3) { + deltaCase_ = 0; + delta_ = null; + } + addBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public fast.Fast.Delta.Diff.Add.Builder getAddBuilder() { + return getAddFieldBuilder().getBuilder(); + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + public fast.Fast.Delta.Diff.AddOrBuilder getAddOrBuilder() { + if ((deltaCase_ == 3) && (addBuilder_ != null)) { + return addBuilder_.getMessageOrBuilder(); + } else { + if (deltaCase_ == 3) { + return (fast.Fast.Delta.Diff.Add) delta_; + } + return fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Add add = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Add, fast.Fast.Delta.Diff.Add.Builder, fast.Fast.Delta.Diff.AddOrBuilder> + getAddFieldBuilder() { + if (addBuilder_ == null) { + if (!(deltaCase_ == 3)) { + delta_ = fast.Fast.Delta.Diff.Add.getDefaultInstance(); + } + addBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Add, fast.Fast.Delta.Diff.Add.Builder, fast.Fast.Delta.Diff.AddOrBuilder>( + (fast.Fast.Delta.Diff.Add) delta_, + getParentForChildren(), + isClean()); + delta_ = null; + } + deltaCase_ = 3; + onChanged();; + return addBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Del, fast.Fast.Delta.Diff.Del.Builder, fast.Fast.Delta.Diff.DelOrBuilder> delBuilder_; + /** + * .fast.Delta.Diff.Del del = 4; + */ + public fast.Fast.Delta.Diff.Del getDel() { + if (delBuilder_ == null) { + if (deltaCase_ == 4) { + return (fast.Fast.Delta.Diff.Del) delta_; + } + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } else { + if (deltaCase_ == 4) { + return delBuilder_.getMessage(); + } + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public Builder setDel(fast.Fast.Delta.Diff.Del value) { + if (delBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delta_ = value; + onChanged(); + } else { + delBuilder_.setMessage(value); + } + deltaCase_ = 4; + return this; + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public Builder setDel( + fast.Fast.Delta.Diff.Del.Builder builderForValue) { + if (delBuilder_ == null) { + delta_ = builderForValue.build(); + onChanged(); + } else { + delBuilder_.setMessage(builderForValue.build()); + } + deltaCase_ = 4; + return this; + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public Builder mergeDel(fast.Fast.Delta.Diff.Del value) { + if (delBuilder_ == null) { + if (deltaCase_ == 4 && + delta_ != fast.Fast.Delta.Diff.Del.getDefaultInstance()) { + delta_ = fast.Fast.Delta.Diff.Del.newBuilder((fast.Fast.Delta.Diff.Del) delta_) + .mergeFrom(value).buildPartial(); + } else { + delta_ = value; + } + onChanged(); + } else { + if (deltaCase_ == 4) { + delBuilder_.mergeFrom(value); + } + delBuilder_.setMessage(value); + } + deltaCase_ = 4; + return this; + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public Builder clearDel() { + if (delBuilder_ == null) { + if (deltaCase_ == 4) { + deltaCase_ = 0; + delta_ = null; + onChanged(); + } + } else { + if (deltaCase_ == 4) { + deltaCase_ = 0; + delta_ = null; + } + delBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public fast.Fast.Delta.Diff.Del.Builder getDelBuilder() { + return getDelFieldBuilder().getBuilder(); + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + public fast.Fast.Delta.Diff.DelOrBuilder getDelOrBuilder() { + if ((deltaCase_ == 4) && (delBuilder_ != null)) { + return delBuilder_.getMessageOrBuilder(); + } else { + if (deltaCase_ == 4) { + return (fast.Fast.Delta.Diff.Del) delta_; + } + return fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Del del = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Del, fast.Fast.Delta.Diff.Del.Builder, fast.Fast.Delta.Diff.DelOrBuilder> + getDelFieldBuilder() { + if (delBuilder_ == null) { + if (!(deltaCase_ == 4)) { + delta_ = fast.Fast.Delta.Diff.Del.getDefaultInstance(); + } + delBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Del, fast.Fast.Delta.Diff.Del.Builder, fast.Fast.Delta.Diff.DelOrBuilder>( + (fast.Fast.Delta.Diff.Del) delta_, + getParentForChildren(), + isClean()); + delta_ = null; + } + deltaCase_ = 4; + onChanged();; + return delBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Move, fast.Fast.Delta.Diff.Move.Builder, fast.Fast.Delta.Diff.MoveOrBuilder> moveBuilder_; + /** + * .fast.Delta.Diff.Move move = 5; + */ + public fast.Fast.Delta.Diff.Move getMove() { + if (moveBuilder_ == null) { + if (deltaCase_ == 5) { + return (fast.Fast.Delta.Diff.Move) delta_; + } + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } else { + if (deltaCase_ == 5) { + return moveBuilder_.getMessage(); + } + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public Builder setMove(fast.Fast.Delta.Diff.Move value) { + if (moveBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delta_ = value; + onChanged(); + } else { + moveBuilder_.setMessage(value); + } + deltaCase_ = 5; + return this; + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public Builder setMove( + fast.Fast.Delta.Diff.Move.Builder builderForValue) { + if (moveBuilder_ == null) { + delta_ = builderForValue.build(); + onChanged(); + } else { + moveBuilder_.setMessage(builderForValue.build()); + } + deltaCase_ = 5; + return this; + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public Builder mergeMove(fast.Fast.Delta.Diff.Move value) { + if (moveBuilder_ == null) { + if (deltaCase_ == 5 && + delta_ != fast.Fast.Delta.Diff.Move.getDefaultInstance()) { + delta_ = fast.Fast.Delta.Diff.Move.newBuilder((fast.Fast.Delta.Diff.Move) delta_) + .mergeFrom(value).buildPartial(); + } else { + delta_ = value; + } + onChanged(); + } else { + if (deltaCase_ == 5) { + moveBuilder_.mergeFrom(value); + } + moveBuilder_.setMessage(value); + } + deltaCase_ = 5; + return this; + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public Builder clearMove() { + if (moveBuilder_ == null) { + if (deltaCase_ == 5) { + deltaCase_ = 0; + delta_ = null; + onChanged(); + } + } else { + if (deltaCase_ == 5) { + deltaCase_ = 0; + delta_ = null; + } + moveBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public fast.Fast.Delta.Diff.Move.Builder getMoveBuilder() { + return getMoveFieldBuilder().getBuilder(); + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + public fast.Fast.Delta.Diff.MoveOrBuilder getMoveOrBuilder() { + if ((deltaCase_ == 5) && (moveBuilder_ != null)) { + return moveBuilder_.getMessageOrBuilder(); + } else { + if (deltaCase_ == 5) { + return (fast.Fast.Delta.Diff.Move) delta_; + } + return fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Move move = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Move, fast.Fast.Delta.Diff.Move.Builder, fast.Fast.Delta.Diff.MoveOrBuilder> + getMoveFieldBuilder() { + if (moveBuilder_ == null) { + if (!(deltaCase_ == 5)) { + delta_ = fast.Fast.Delta.Diff.Move.getDefaultInstance(); + } + moveBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Move, fast.Fast.Delta.Diff.Move.Builder, fast.Fast.Delta.Diff.MoveOrBuilder>( + (fast.Fast.Delta.Diff.Move) delta_, + getParentForChildren(), + isClean()); + delta_ = null; + } + deltaCase_ = 5; + onChanged();; + return moveBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Update, fast.Fast.Delta.Diff.Update.Builder, fast.Fast.Delta.Diff.UpdateOrBuilder> updateBuilder_; + /** + * .fast.Delta.Diff.Update update = 6; + */ + public fast.Fast.Delta.Diff.Update getUpdate() { + if (updateBuilder_ == null) { + if (deltaCase_ == 6) { + return (fast.Fast.Delta.Diff.Update) delta_; + } + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } else { + if (deltaCase_ == 6) { + return updateBuilder_.getMessage(); + } + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public Builder setUpdate(fast.Fast.Delta.Diff.Update value) { + if (updateBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delta_ = value; + onChanged(); + } else { + updateBuilder_.setMessage(value); + } + deltaCase_ = 6; + return this; + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public Builder setUpdate( + fast.Fast.Delta.Diff.Update.Builder builderForValue) { + if (updateBuilder_ == null) { + delta_ = builderForValue.build(); + onChanged(); + } else { + updateBuilder_.setMessage(builderForValue.build()); + } + deltaCase_ = 6; + return this; + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public Builder mergeUpdate(fast.Fast.Delta.Diff.Update value) { + if (updateBuilder_ == null) { + if (deltaCase_ == 6 && + delta_ != fast.Fast.Delta.Diff.Update.getDefaultInstance()) { + delta_ = fast.Fast.Delta.Diff.Update.newBuilder((fast.Fast.Delta.Diff.Update) delta_) + .mergeFrom(value).buildPartial(); + } else { + delta_ = value; + } + onChanged(); + } else { + if (deltaCase_ == 6) { + updateBuilder_.mergeFrom(value); + } + updateBuilder_.setMessage(value); + } + deltaCase_ = 6; + return this; + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public Builder clearUpdate() { + if (updateBuilder_ == null) { + if (deltaCase_ == 6) { + deltaCase_ = 0; + delta_ = null; + onChanged(); + } + } else { + if (deltaCase_ == 6) { + deltaCase_ = 0; + delta_ = null; + } + updateBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public fast.Fast.Delta.Diff.Update.Builder getUpdateBuilder() { + return getUpdateFieldBuilder().getBuilder(); + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + public fast.Fast.Delta.Diff.UpdateOrBuilder getUpdateOrBuilder() { + if ((deltaCase_ == 6) && (updateBuilder_ != null)) { + return updateBuilder_.getMessageOrBuilder(); + } else { + if (deltaCase_ == 6) { + return (fast.Fast.Delta.Diff.Update) delta_; + } + return fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + } + /** + * .fast.Delta.Diff.Update update = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Update, fast.Fast.Delta.Diff.Update.Builder, fast.Fast.Delta.Diff.UpdateOrBuilder> + getUpdateFieldBuilder() { + if (updateBuilder_ == null) { + if (!(deltaCase_ == 6)) { + delta_ = fast.Fast.Delta.Diff.Update.getDefaultInstance(); + } + updateBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta.Diff.Update, fast.Fast.Delta.Diff.Update.Builder, fast.Fast.Delta.Diff.UpdateOrBuilder>( + (fast.Fast.Delta.Diff.Update) delta_, + getParentForChildren(), + isClean()); + delta_ = null; + } + deltaCase_ = 6; + onChanged();; + return updateBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta.Diff) + } + + // @@protoc_insertion_point(class_scope:fast.Delta.Diff) + private static final fast.Fast.Delta.Diff DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta.Diff(); + } + + public static fast.Fast.Delta.Diff getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Diff parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Diff(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta.Diff getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int SRC_FIELD_NUMBER = 1; + private volatile java.lang.Object src_; + /** + * string src = 1; + */ + public java.lang.String getSrc() { + java.lang.Object ref = src_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + src_ = s; + return s; + } + } + /** + * string src = 1; + */ + public com.google.protobuf.ByteString + getSrcBytes() { + java.lang.Object ref = src_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + src_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int DST_FIELD_NUMBER = 2; + private volatile java.lang.Object dst_; + /** + * string dst = 2; + */ + public java.lang.String getDst() { + java.lang.Object ref = dst_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + dst_ = s; + return s; + } + } + /** + * string dst = 2; + */ + public com.google.protobuf.ByteString + getDstBytes() { + java.lang.Object ref = dst_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + dst_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int DIFF_FIELD_NUMBER = 3; + private java.util.List diff_; + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public java.util.List getDiffList() { + return diff_; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public java.util.List + getDiffOrBuilderList() { + return diff_; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public int getDiffCount() { + return diff_.size(); + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.Diff getDiff(int index) { + return diff_.get(index); + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.DiffOrBuilder getDiffOrBuilder( + int index) { + return diff_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getSrcBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, src_); + } + if (!getDstBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, dst_); + } + for (int i = 0; i < diff_.size(); i++) { + output.writeMessage(3, diff_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getSrcBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, src_); + } + if (!getDstBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, dst_); + } + for (int i = 0; i < diff_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, diff_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Delta)) { + return super.equals(obj); + } + fast.Fast.Delta other = (fast.Fast.Delta) obj; + + boolean result = true; + result = result && getSrc() + .equals(other.getSrc()); + result = result && getDst() + .equals(other.getDst()); + result = result && getDiffList() + .equals(other.getDiffList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SRC_FIELD_NUMBER; + hash = (53 * hash) + getSrc().hashCode(); + hash = (37 * hash) + DST_FIELD_NUMBER; + hash = (53 * hash) + getDst().hashCode(); + if (getDiffCount() > 0) { + hash = (37 * hash) + DIFF_FIELD_NUMBER; + hash = (53 * hash) + getDiffList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Delta parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Delta parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Delta parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Delta parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Delta parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Delta parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Delta prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Delta} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Delta) + fast.Fast.DeltaOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Delta_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Delta_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Delta.class, fast.Fast.Delta.Builder.class); + } + + // Construct using fast.Fast.Delta.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getDiffFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + src_ = ""; + + dst_ = ""; + + if (diffBuilder_ == null) { + diff_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + diffBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Delta_descriptor; + } + + public fast.Fast.Delta getDefaultInstanceForType() { + return fast.Fast.Delta.getDefaultInstance(); + } + + public fast.Fast.Delta build() { + fast.Fast.Delta result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Delta buildPartial() { + fast.Fast.Delta result = new fast.Fast.Delta(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.src_ = src_; + result.dst_ = dst_; + if (diffBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004)) { + diff_ = java.util.Collections.unmodifiableList(diff_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.diff_ = diff_; + } else { + result.diff_ = diffBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Delta) { + return mergeFrom((fast.Fast.Delta)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Delta other) { + if (other == fast.Fast.Delta.getDefaultInstance()) return this; + if (!other.getSrc().isEmpty()) { + src_ = other.src_; + onChanged(); + } + if (!other.getDst().isEmpty()) { + dst_ = other.dst_; + onChanged(); + } + if (diffBuilder_ == null) { + if (!other.diff_.isEmpty()) { + if (diff_.isEmpty()) { + diff_ = other.diff_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureDiffIsMutable(); + diff_.addAll(other.diff_); + } + onChanged(); + } + } else { + if (!other.diff_.isEmpty()) { + if (diffBuilder_.isEmpty()) { + diffBuilder_.dispose(); + diffBuilder_ = null; + diff_ = other.diff_; + bitField0_ = (bitField0_ & ~0x00000004); + diffBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getDiffFieldBuilder() : null; + } else { + diffBuilder_.addAllMessages(other.diff_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Delta parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Delta) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object src_ = ""; + /** + * string src = 1; + */ + public java.lang.String getSrc() { + java.lang.Object ref = src_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + src_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string src = 1; + */ + public com.google.protobuf.ByteString + getSrcBytes() { + java.lang.Object ref = src_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + src_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string src = 1; + */ + public Builder setSrc( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + src_ = value; + onChanged(); + return this; + } + /** + * string src = 1; + */ + public Builder clearSrc() { + + src_ = getDefaultInstance().getSrc(); + onChanged(); + return this; + } + /** + * string src = 1; + */ + public Builder setSrcBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + src_ = value; + onChanged(); + return this; + } + + private java.lang.Object dst_ = ""; + /** + * string dst = 2; + */ + public java.lang.String getDst() { + java.lang.Object ref = dst_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + dst_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string dst = 2; + */ + public com.google.protobuf.ByteString + getDstBytes() { + java.lang.Object ref = dst_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + dst_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string dst = 2; + */ + public Builder setDst( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + dst_ = value; + onChanged(); + return this; + } + /** + * string dst = 2; + */ + public Builder clearDst() { + + dst_ = getDefaultInstance().getDst(); + onChanged(); + return this; + } + /** + * string dst = 2; + */ + public Builder setDstBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + dst_ = value; + onChanged(); + return this; + } + + private java.util.List diff_ = + java.util.Collections.emptyList(); + private void ensureDiffIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + diff_ = new java.util.ArrayList(diff_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Delta.Diff, fast.Fast.Delta.Diff.Builder, fast.Fast.Delta.DiffOrBuilder> diffBuilder_; + + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public java.util.List getDiffList() { + if (diffBuilder_ == null) { + return java.util.Collections.unmodifiableList(diff_); + } else { + return diffBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public int getDiffCount() { + if (diffBuilder_ == null) { + return diff_.size(); + } else { + return diffBuilder_.getCount(); + } + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.Diff getDiff(int index) { + if (diffBuilder_ == null) { + return diff_.get(index); + } else { + return diffBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder setDiff( + int index, fast.Fast.Delta.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.set(index, value); + onChanged(); + } else { + diffBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder setDiff( + int index, fast.Fast.Delta.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.set(index, builderForValue.build()); + onChanged(); + } else { + diffBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder addDiff(fast.Fast.Delta.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.add(value); + onChanged(); + } else { + diffBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder addDiff( + int index, fast.Fast.Delta.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.add(index, value); + onChanged(); + } else { + diffBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder addDiff( + fast.Fast.Delta.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.add(builderForValue.build()); + onChanged(); + } else { + diffBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder addDiff( + int index, fast.Fast.Delta.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.add(index, builderForValue.build()); + onChanged(); + } else { + diffBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder addAllDiff( + java.lang.Iterable values) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, diff_); + onChanged(); + } else { + diffBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder clearDiff() { + if (diffBuilder_ == null) { + diff_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + diffBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public Builder removeDiff(int index) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.remove(index); + onChanged(); + } else { + diffBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.Diff.Builder getDiffBuilder( + int index) { + return getDiffFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.DiffOrBuilder getDiffOrBuilder( + int index) { + if (diffBuilder_ == null) { + return diff_.get(index); } else { + return diffBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public java.util.List + getDiffOrBuilderList() { + if (diffBuilder_ != null) { + return diffBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(diff_); + } + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.Diff.Builder addDiffBuilder() { + return getDiffFieldBuilder().addBuilder( + fast.Fast.Delta.Diff.getDefaultInstance()); + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public fast.Fast.Delta.Diff.Builder addDiffBuilder( + int index) { + return getDiffFieldBuilder().addBuilder( + index, fast.Fast.Delta.Diff.getDefaultInstance()); + } + /** + * repeated .fast.Delta.Diff diff = 3; + */ + public java.util.List + getDiffBuilderList() { + return getDiffFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Delta.Diff, fast.Fast.Delta.Diff.Builder, fast.Fast.Delta.DiffOrBuilder> + getDiffFieldBuilder() { + if (diffBuilder_ == null) { + diffBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Delta.Diff, fast.Fast.Delta.Diff.Builder, fast.Fast.Delta.DiffOrBuilder>( + diff_, + ((bitField0_ & 0x00000004) == 0x00000004), + getParentForChildren(), + isClean()); + diff_ = null; + } + return diffBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Delta) + } + + // @@protoc_insertion_point(class_scope:fast.Delta) + private static final fast.Fast.Delta DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Delta(); + } + + public static fast.Fast.Delta getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Delta parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Delta(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Delta getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface PairsOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Pairs) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + java.util.List + getPairList(); + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + fast.Fast.Pairs.Pair getPair(int index); + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + int getPairCount(); + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + java.util.List + getPairOrBuilderList(); + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + fast.Fast.Pairs.PairOrBuilder getPairOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Pairs} + */ + public static final class Pairs extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Pairs) + PairsOrBuilder { + // Use Pairs.newBuilder() to construct. + private Pairs(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Pairs() { + pair_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Pairs( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + pair_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + pair_.add( + input.readMessage(fast.Fast.Pairs.Pair.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + pair_ = java.util.Collections.unmodifiableList(pair_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.class, fast.Fast.Pairs.Builder.class); + } + + public interface PairOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Pairs.Pair) + com.google.protobuf.MessageOrBuilder { + + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + boolean hasLeft(); + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + fast.Fast.Pairs.Pair.Diff getLeft(); + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + fast.Fast.Pairs.Pair.DiffOrBuilder getLeftOrBuilder(); + + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + boolean hasRight(); + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + fast.Fast.Pairs.Pair.Diff getRight(); + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + fast.Fast.Pairs.Pair.DiffOrBuilder getRightOrBuilder(); + + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + int getTypeValue(); + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + fast.Fast.Pairs.Pair.CloneType getType(); + } + /** + * Protobuf type {@code fast.Pairs.Pair} + */ + public static final class Pair extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Pairs.Pair) + PairOrBuilder { + // Use Pair.newBuilder() to construct. + private Pair(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Pair() { + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Pair( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + fast.Fast.Pairs.Pair.Diff.Builder subBuilder = null; + if (left_ != null) { + subBuilder = left_.toBuilder(); + } + left_ = input.readMessage(fast.Fast.Pairs.Pair.Diff.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(left_); + left_ = subBuilder.buildPartial(); + } + + break; + } + case 18: { + fast.Fast.Pairs.Pair.Diff.Builder subBuilder = null; + if (right_ != null) { + subBuilder = right_.toBuilder(); + } + right_ = input.readMessage(fast.Fast.Pairs.Pair.Diff.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(right_); + right_ = subBuilder.buildPartial(); + } + + break; + } + case 24: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_Pair_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_Pair_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.Pair.class, fast.Fast.Pairs.Pair.Builder.class); + } + + /** + * Protobuf enum {@code fast.Pairs.Pair.CloneType} + */ + public enum CloneType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * MAYBE = 0; + */ + MAYBE(0), + /** + * YES = 1; + */ + YES(1), + /** + * NO = 2; + */ + NO(2), + UNRECOGNIZED(-1), + ; + + /** + * MAYBE = 0; + */ + public static final int MAYBE_VALUE = 0; + /** + * YES = 1; + */ + public static final int YES_VALUE = 1; + /** + * NO = 2; + */ + public static final int NO_VALUE = 2; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static CloneType valueOf(int value) { + return forNumber(value); + } + + public static CloneType forNumber(int value) { + switch (value) { + case 0: return MAYBE; + case 1: return YES; + case 2: return NO; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + CloneType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public CloneType findValueByNumber(int number) { + return CloneType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Pairs.Pair.getDescriptor().getEnumTypes().get(0); + } + + private static final CloneType[] VALUES = values(); + + public static CloneType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private CloneType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Pairs.Pair.CloneType) + } + + public interface DiffOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Pairs.Pair.Diff) + com.google.protobuf.MessageOrBuilder { + + /** + * string project = 1; + */ + java.lang.String getProject(); + /** + * string project = 1; + */ + com.google.protobuf.ByteString + getProjectBytes(); + + /** + * int32 left_line = 2; + */ + int getLeftLine(); + + /** + * int32 left_column = 3; + */ + int getLeftColumn(); + + /** + * int32 right_line = 4; + */ + int getRightLine(); + + /** + * int32 right_column = 5; + */ + int getRightColumn(); + + /** + * .fast.Element old_code = 6; + */ + boolean hasOldCode(); + /** + * .fast.Element old_code = 6; + */ + fast.Fast.Element getOldCode(); + /** + * .fast.Element old_code = 6; + */ + fast.Fast.ElementOrBuilder getOldCodeOrBuilder(); + + /** + * .fast.Element new_code = 7; + */ + boolean hasNewCode(); + /** + * .fast.Element new_code = 7; + */ + fast.Fast.Element getNewCode(); + /** + * .fast.Element new_code = 7; + */ + fast.Fast.ElementOrBuilder getNewCodeOrBuilder(); + + /** + * string hash = 8; + */ + java.lang.String getHash(); + /** + * string hash = 8; + */ + com.google.protobuf.ByteString + getHashBytes(); + + /** + * .fast.Slices slices = 9; + */ + boolean hasSlices(); + /** + * .fast.Slices slices = 9; + */ + fast.Fast.Slices getSlices(); + /** + * .fast.Slices slices = 9; + */ + fast.Fast.SlicesOrBuilder getSlicesOrBuilder(); + } + /** + * Protobuf type {@code fast.Pairs.Pair.Diff} + */ + public static final class Diff extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Pairs.Pair.Diff) + DiffOrBuilder { + // Use Diff.newBuilder() to construct. + private Diff(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Diff() { + project_ = ""; + leftLine_ = 0; + leftColumn_ = 0; + rightLine_ = 0; + rightColumn_ = 0; + hash_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Diff( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + project_ = s; + break; + } + case 16: { + + leftLine_ = input.readInt32(); + break; + } + case 24: { + + leftColumn_ = input.readInt32(); + break; + } + case 32: { + + rightLine_ = input.readInt32(); + break; + } + case 40: { + + rightColumn_ = input.readInt32(); + break; + } + case 50: { + fast.Fast.Element.Builder subBuilder = null; + if (oldCode_ != null) { + subBuilder = oldCode_.toBuilder(); + } + oldCode_ = input.readMessage(fast.Fast.Element.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(oldCode_); + oldCode_ = subBuilder.buildPartial(); + } + + break; + } + case 58: { + fast.Fast.Element.Builder subBuilder = null; + if (newCode_ != null) { + subBuilder = newCode_.toBuilder(); + } + newCode_ = input.readMessage(fast.Fast.Element.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(newCode_); + newCode_ = subBuilder.buildPartial(); + } + + break; + } + case 66: { + java.lang.String s = input.readStringRequireUtf8(); + + hash_ = s; + break; + } + case 74: { + fast.Fast.Slices.Builder subBuilder = null; + if (slices_ != null) { + subBuilder = slices_.toBuilder(); + } + slices_ = input.readMessage(fast.Fast.Slices.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(slices_); + slices_ = subBuilder.buildPartial(); + } + + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_Pair_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_Pair_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.Pair.Diff.class, fast.Fast.Pairs.Pair.Diff.Builder.class); + } + + public static final int PROJECT_FIELD_NUMBER = 1; + private volatile java.lang.Object project_; + /** + * string project = 1; + */ + public java.lang.String getProject() { + java.lang.Object ref = project_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + project_ = s; + return s; + } + } + /** + * string project = 1; + */ + public com.google.protobuf.ByteString + getProjectBytes() { + java.lang.Object ref = project_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + project_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int LEFT_LINE_FIELD_NUMBER = 2; + private int leftLine_; + /** + * int32 left_line = 2; + */ + public int getLeftLine() { + return leftLine_; + } + + public static final int LEFT_COLUMN_FIELD_NUMBER = 3; + private int leftColumn_; + /** + * int32 left_column = 3; + */ + public int getLeftColumn() { + return leftColumn_; + } + + public static final int RIGHT_LINE_FIELD_NUMBER = 4; + private int rightLine_; + /** + * int32 right_line = 4; + */ + public int getRightLine() { + return rightLine_; + } + + public static final int RIGHT_COLUMN_FIELD_NUMBER = 5; + private int rightColumn_; + /** + * int32 right_column = 5; + */ + public int getRightColumn() { + return rightColumn_; + } + + public static final int OLD_CODE_FIELD_NUMBER = 6; + private fast.Fast.Element oldCode_; + /** + * .fast.Element old_code = 6; + */ + public boolean hasOldCode() { + return oldCode_ != null; + } + /** + * .fast.Element old_code = 6; + */ + public fast.Fast.Element getOldCode() { + return oldCode_ == null ? fast.Fast.Element.getDefaultInstance() : oldCode_; + } + /** + * .fast.Element old_code = 6; + */ + public fast.Fast.ElementOrBuilder getOldCodeOrBuilder() { + return getOldCode(); + } + + public static final int NEW_CODE_FIELD_NUMBER = 7; + private fast.Fast.Element newCode_; + /** + * .fast.Element new_code = 7; + */ + public boolean hasNewCode() { + return newCode_ != null; + } + /** + * .fast.Element new_code = 7; + */ + public fast.Fast.Element getNewCode() { + return newCode_ == null ? fast.Fast.Element.getDefaultInstance() : newCode_; + } + /** + * .fast.Element new_code = 7; + */ + public fast.Fast.ElementOrBuilder getNewCodeOrBuilder() { + return getNewCode(); + } + + public static final int HASH_FIELD_NUMBER = 8; + private volatile java.lang.Object hash_; + /** + * string hash = 8; + */ + public java.lang.String getHash() { + java.lang.Object ref = hash_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + hash_ = s; + return s; + } + } + /** + * string hash = 8; + */ + public com.google.protobuf.ByteString + getHashBytes() { + java.lang.Object ref = hash_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + hash_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SLICES_FIELD_NUMBER = 9; + private fast.Fast.Slices slices_; + /** + * .fast.Slices slices = 9; + */ + public boolean hasSlices() { + return slices_ != null; + } + /** + * .fast.Slices slices = 9; + */ + public fast.Fast.Slices getSlices() { + return slices_ == null ? fast.Fast.Slices.getDefaultInstance() : slices_; + } + /** + * .fast.Slices slices = 9; + */ + public fast.Fast.SlicesOrBuilder getSlicesOrBuilder() { + return getSlices(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getProjectBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, project_); + } + if (leftLine_ != 0) { + output.writeInt32(2, leftLine_); + } + if (leftColumn_ != 0) { + output.writeInt32(3, leftColumn_); + } + if (rightLine_ != 0) { + output.writeInt32(4, rightLine_); + } + if (rightColumn_ != 0) { + output.writeInt32(5, rightColumn_); + } + if (oldCode_ != null) { + output.writeMessage(6, getOldCode()); + } + if (newCode_ != null) { + output.writeMessage(7, getNewCode()); + } + if (!getHashBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 8, hash_); + } + if (slices_ != null) { + output.writeMessage(9, getSlices()); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getProjectBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, project_); + } + if (leftLine_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, leftLine_); + } + if (leftColumn_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, leftColumn_); + } + if (rightLine_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, rightLine_); + } + if (rightColumn_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(5, rightColumn_); + } + if (oldCode_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getOldCode()); + } + if (newCode_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getNewCode()); + } + if (!getHashBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(8, hash_); + } + if (slices_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getSlices()); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Pairs.Pair.Diff)) { + return super.equals(obj); + } + fast.Fast.Pairs.Pair.Diff other = (fast.Fast.Pairs.Pair.Diff) obj; + + boolean result = true; + result = result && getProject() + .equals(other.getProject()); + result = result && (getLeftLine() + == other.getLeftLine()); + result = result && (getLeftColumn() + == other.getLeftColumn()); + result = result && (getRightLine() + == other.getRightLine()); + result = result && (getRightColumn() + == other.getRightColumn()); + result = result && (hasOldCode() == other.hasOldCode()); + if (hasOldCode()) { + result = result && getOldCode() + .equals(other.getOldCode()); + } + result = result && (hasNewCode() == other.hasNewCode()); + if (hasNewCode()) { + result = result && getNewCode() + .equals(other.getNewCode()); + } + result = result && getHash() + .equals(other.getHash()); + result = result && (hasSlices() == other.hasSlices()); + if (hasSlices()) { + result = result && getSlices() + .equals(other.getSlices()); + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + PROJECT_FIELD_NUMBER; + hash = (53 * hash) + getProject().hashCode(); + hash = (37 * hash) + LEFT_LINE_FIELD_NUMBER; + hash = (53 * hash) + getLeftLine(); + hash = (37 * hash) + LEFT_COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getLeftColumn(); + hash = (37 * hash) + RIGHT_LINE_FIELD_NUMBER; + hash = (53 * hash) + getRightLine(); + hash = (37 * hash) + RIGHT_COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getRightColumn(); + if (hasOldCode()) { + hash = (37 * hash) + OLD_CODE_FIELD_NUMBER; + hash = (53 * hash) + getOldCode().hashCode(); + } + if (hasNewCode()) { + hash = (37 * hash) + NEW_CODE_FIELD_NUMBER; + hash = (53 * hash) + getNewCode().hashCode(); + } + hash = (37 * hash) + HASH_FIELD_NUMBER; + hash = (53 * hash) + getHash().hashCode(); + if (hasSlices()) { + hash = (37 * hash) + SLICES_FIELD_NUMBER; + hash = (53 * hash) + getSlices().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Pairs.Pair.Diff parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs.Pair.Diff parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair.Diff parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair.Diff parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Pairs.Pair.Diff prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Pairs.Pair.Diff} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Pairs.Pair.Diff) + fast.Fast.Pairs.Pair.DiffOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_Pair_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_Pair_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.Pair.Diff.class, fast.Fast.Pairs.Pair.Diff.Builder.class); + } + + // Construct using fast.Fast.Pairs.Pair.Diff.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + project_ = ""; + + leftLine_ = 0; + + leftColumn_ = 0; + + rightLine_ = 0; + + rightColumn_ = 0; + + if (oldCodeBuilder_ == null) { + oldCode_ = null; + } else { + oldCode_ = null; + oldCodeBuilder_ = null; + } + if (newCodeBuilder_ == null) { + newCode_ = null; + } else { + newCode_ = null; + newCodeBuilder_ = null; + } + hash_ = ""; + + if (slicesBuilder_ == null) { + slices_ = null; + } else { + slices_ = null; + slicesBuilder_ = null; + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Pairs_Pair_Diff_descriptor; + } + + public fast.Fast.Pairs.Pair.Diff getDefaultInstanceForType() { + return fast.Fast.Pairs.Pair.Diff.getDefaultInstance(); + } + + public fast.Fast.Pairs.Pair.Diff build() { + fast.Fast.Pairs.Pair.Diff result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Pairs.Pair.Diff buildPartial() { + fast.Fast.Pairs.Pair.Diff result = new fast.Fast.Pairs.Pair.Diff(this); + result.project_ = project_; + result.leftLine_ = leftLine_; + result.leftColumn_ = leftColumn_; + result.rightLine_ = rightLine_; + result.rightColumn_ = rightColumn_; + if (oldCodeBuilder_ == null) { + result.oldCode_ = oldCode_; + } else { + result.oldCode_ = oldCodeBuilder_.build(); + } + if (newCodeBuilder_ == null) { + result.newCode_ = newCode_; + } else { + result.newCode_ = newCodeBuilder_.build(); + } + result.hash_ = hash_; + if (slicesBuilder_ == null) { + result.slices_ = slices_; + } else { + result.slices_ = slicesBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Pairs.Pair.Diff) { + return mergeFrom((fast.Fast.Pairs.Pair.Diff)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Pairs.Pair.Diff other) { + if (other == fast.Fast.Pairs.Pair.Diff.getDefaultInstance()) return this; + if (!other.getProject().isEmpty()) { + project_ = other.project_; + onChanged(); + } + if (other.getLeftLine() != 0) { + setLeftLine(other.getLeftLine()); + } + if (other.getLeftColumn() != 0) { + setLeftColumn(other.getLeftColumn()); + } + if (other.getRightLine() != 0) { + setRightLine(other.getRightLine()); + } + if (other.getRightColumn() != 0) { + setRightColumn(other.getRightColumn()); + } + if (other.hasOldCode()) { + mergeOldCode(other.getOldCode()); + } + if (other.hasNewCode()) { + mergeNewCode(other.getNewCode()); + } + if (!other.getHash().isEmpty()) { + hash_ = other.hash_; + onChanged(); + } + if (other.hasSlices()) { + mergeSlices(other.getSlices()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Pairs.Pair.Diff parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Pairs.Pair.Diff) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object project_ = ""; + /** + * string project = 1; + */ + public java.lang.String getProject() { + java.lang.Object ref = project_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + project_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string project = 1; + */ + public com.google.protobuf.ByteString + getProjectBytes() { + java.lang.Object ref = project_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + project_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string project = 1; + */ + public Builder setProject( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + project_ = value; + onChanged(); + return this; + } + /** + * string project = 1; + */ + public Builder clearProject() { + + project_ = getDefaultInstance().getProject(); + onChanged(); + return this; + } + /** + * string project = 1; + */ + public Builder setProjectBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + project_ = value; + onChanged(); + return this; + } + + private int leftLine_ ; + /** + * int32 left_line = 2; + */ + public int getLeftLine() { + return leftLine_; + } + /** + * int32 left_line = 2; + */ + public Builder setLeftLine(int value) { + + leftLine_ = value; + onChanged(); + return this; + } + /** + * int32 left_line = 2; + */ + public Builder clearLeftLine() { + + leftLine_ = 0; + onChanged(); + return this; + } + + private int leftColumn_ ; + /** + * int32 left_column = 3; + */ + public int getLeftColumn() { + return leftColumn_; + } + /** + * int32 left_column = 3; + */ + public Builder setLeftColumn(int value) { + + leftColumn_ = value; + onChanged(); + return this; + } + /** + * int32 left_column = 3; + */ + public Builder clearLeftColumn() { + + leftColumn_ = 0; + onChanged(); + return this; + } + + private int rightLine_ ; + /** + * int32 right_line = 4; + */ + public int getRightLine() { + return rightLine_; + } + /** + * int32 right_line = 4; + */ + public Builder setRightLine(int value) { + + rightLine_ = value; + onChanged(); + return this; + } + /** + * int32 right_line = 4; + */ + public Builder clearRightLine() { + + rightLine_ = 0; + onChanged(); + return this; + } + + private int rightColumn_ ; + /** + * int32 right_column = 5; + */ + public int getRightColumn() { + return rightColumn_; + } + /** + * int32 right_column = 5; + */ + public Builder setRightColumn(int value) { + + rightColumn_ = value; + onChanged(); + return this; + } + /** + * int32 right_column = 5; + */ + public Builder clearRightColumn() { + + rightColumn_ = 0; + onChanged(); + return this; + } + + private fast.Fast.Element oldCode_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> oldCodeBuilder_; + /** + * .fast.Element old_code = 6; + */ + public boolean hasOldCode() { + return oldCodeBuilder_ != null || oldCode_ != null; + } + /** + * .fast.Element old_code = 6; + */ + public fast.Fast.Element getOldCode() { + if (oldCodeBuilder_ == null) { + return oldCode_ == null ? fast.Fast.Element.getDefaultInstance() : oldCode_; + } else { + return oldCodeBuilder_.getMessage(); + } + } + /** + * .fast.Element old_code = 6; + */ + public Builder setOldCode(fast.Fast.Element value) { + if (oldCodeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + oldCode_ = value; + onChanged(); + } else { + oldCodeBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Element old_code = 6; + */ + public Builder setOldCode( + fast.Fast.Element.Builder builderForValue) { + if (oldCodeBuilder_ == null) { + oldCode_ = builderForValue.build(); + onChanged(); + } else { + oldCodeBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Element old_code = 6; + */ + public Builder mergeOldCode(fast.Fast.Element value) { + if (oldCodeBuilder_ == null) { + if (oldCode_ != null) { + oldCode_ = + fast.Fast.Element.newBuilder(oldCode_).mergeFrom(value).buildPartial(); + } else { + oldCode_ = value; + } + onChanged(); + } else { + oldCodeBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Element old_code = 6; + */ + public Builder clearOldCode() { + if (oldCodeBuilder_ == null) { + oldCode_ = null; + onChanged(); + } else { + oldCode_ = null; + oldCodeBuilder_ = null; + } + + return this; + } + /** + * .fast.Element old_code = 6; + */ + public fast.Fast.Element.Builder getOldCodeBuilder() { + + onChanged(); + return getOldCodeFieldBuilder().getBuilder(); + } + /** + * .fast.Element old_code = 6; + */ + public fast.Fast.ElementOrBuilder getOldCodeOrBuilder() { + if (oldCodeBuilder_ != null) { + return oldCodeBuilder_.getMessageOrBuilder(); + } else { + return oldCode_ == null ? + fast.Fast.Element.getDefaultInstance() : oldCode_; + } + } + /** + * .fast.Element old_code = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> + getOldCodeFieldBuilder() { + if (oldCodeBuilder_ == null) { + oldCodeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder>( + getOldCode(), + getParentForChildren(), + isClean()); + oldCode_ = null; + } + return oldCodeBuilder_; + } + + private fast.Fast.Element newCode_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> newCodeBuilder_; + /** + * .fast.Element new_code = 7; + */ + public boolean hasNewCode() { + return newCodeBuilder_ != null || newCode_ != null; + } + /** + * .fast.Element new_code = 7; + */ + public fast.Fast.Element getNewCode() { + if (newCodeBuilder_ == null) { + return newCode_ == null ? fast.Fast.Element.getDefaultInstance() : newCode_; + } else { + return newCodeBuilder_.getMessage(); + } + } + /** + * .fast.Element new_code = 7; + */ + public Builder setNewCode(fast.Fast.Element value) { + if (newCodeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + newCode_ = value; + onChanged(); + } else { + newCodeBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Element new_code = 7; + */ + public Builder setNewCode( + fast.Fast.Element.Builder builderForValue) { + if (newCodeBuilder_ == null) { + newCode_ = builderForValue.build(); + onChanged(); + } else { + newCodeBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Element new_code = 7; + */ + public Builder mergeNewCode(fast.Fast.Element value) { + if (newCodeBuilder_ == null) { + if (newCode_ != null) { + newCode_ = + fast.Fast.Element.newBuilder(newCode_).mergeFrom(value).buildPartial(); + } else { + newCode_ = value; + } + onChanged(); + } else { + newCodeBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Element new_code = 7; + */ + public Builder clearNewCode() { + if (newCodeBuilder_ == null) { + newCode_ = null; + onChanged(); + } else { + newCode_ = null; + newCodeBuilder_ = null; + } + + return this; + } + /** + * .fast.Element new_code = 7; + */ + public fast.Fast.Element.Builder getNewCodeBuilder() { + + onChanged(); + return getNewCodeFieldBuilder().getBuilder(); + } + /** + * .fast.Element new_code = 7; + */ + public fast.Fast.ElementOrBuilder getNewCodeOrBuilder() { + if (newCodeBuilder_ != null) { + return newCodeBuilder_.getMessageOrBuilder(); + } else { + return newCode_ == null ? + fast.Fast.Element.getDefaultInstance() : newCode_; + } + } + /** + * .fast.Element new_code = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> + getNewCodeFieldBuilder() { + if (newCodeBuilder_ == null) { + newCodeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder>( + getNewCode(), + getParentForChildren(), + isClean()); + newCode_ = null; + } + return newCodeBuilder_; + } + + private java.lang.Object hash_ = ""; + /** + * string hash = 8; + */ + public java.lang.String getHash() { + java.lang.Object ref = hash_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + hash_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string hash = 8; + */ + public com.google.protobuf.ByteString + getHashBytes() { + java.lang.Object ref = hash_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + hash_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string hash = 8; + */ + public Builder setHash( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + hash_ = value; + onChanged(); + return this; + } + /** + * string hash = 8; + */ + public Builder clearHash() { + + hash_ = getDefaultInstance().getHash(); + onChanged(); + return this; + } + /** + * string hash = 8; + */ + public Builder setHashBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + hash_ = value; + onChanged(); + return this; + } + + private fast.Fast.Slices slices_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> slicesBuilder_; + /** + * .fast.Slices slices = 9; + */ + public boolean hasSlices() { + return slicesBuilder_ != null || slices_ != null; + } + /** + * .fast.Slices slices = 9; + */ + public fast.Fast.Slices getSlices() { + if (slicesBuilder_ == null) { + return slices_ == null ? fast.Fast.Slices.getDefaultInstance() : slices_; + } else { + return slicesBuilder_.getMessage(); + } + } + /** + * .fast.Slices slices = 9; + */ + public Builder setSlices(fast.Fast.Slices value) { + if (slicesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + slices_ = value; + onChanged(); + } else { + slicesBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Slices slices = 9; + */ + public Builder setSlices( + fast.Fast.Slices.Builder builderForValue) { + if (slicesBuilder_ == null) { + slices_ = builderForValue.build(); + onChanged(); + } else { + slicesBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Slices slices = 9; + */ + public Builder mergeSlices(fast.Fast.Slices value) { + if (slicesBuilder_ == null) { + if (slices_ != null) { + slices_ = + fast.Fast.Slices.newBuilder(slices_).mergeFrom(value).buildPartial(); + } else { + slices_ = value; + } + onChanged(); + } else { + slicesBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Slices slices = 9; + */ + public Builder clearSlices() { + if (slicesBuilder_ == null) { + slices_ = null; + onChanged(); + } else { + slices_ = null; + slicesBuilder_ = null; + } + + return this; + } + /** + * .fast.Slices slices = 9; + */ + public fast.Fast.Slices.Builder getSlicesBuilder() { + + onChanged(); + return getSlicesFieldBuilder().getBuilder(); + } + /** + * .fast.Slices slices = 9; + */ + public fast.Fast.SlicesOrBuilder getSlicesOrBuilder() { + if (slicesBuilder_ != null) { + return slicesBuilder_.getMessageOrBuilder(); + } else { + return slices_ == null ? + fast.Fast.Slices.getDefaultInstance() : slices_; + } + } + /** + * .fast.Slices slices = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> + getSlicesFieldBuilder() { + if (slicesBuilder_ == null) { + slicesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder>( + getSlices(), + getParentForChildren(), + isClean()); + slices_ = null; + } + return slicesBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Pairs.Pair.Diff) + } + + // @@protoc_insertion_point(class_scope:fast.Pairs.Pair.Diff) + private static final fast.Fast.Pairs.Pair.Diff DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Pairs.Pair.Diff(); + } + + public static fast.Fast.Pairs.Pair.Diff getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Diff parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Diff(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Pairs.Pair.Diff getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int LEFT_FIELD_NUMBER = 1; + private fast.Fast.Pairs.Pair.Diff left_; + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public boolean hasLeft() { + return left_ != null; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public fast.Fast.Pairs.Pair.Diff getLeft() { + return left_ == null ? fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : left_; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public fast.Fast.Pairs.Pair.DiffOrBuilder getLeftOrBuilder() { + return getLeft(); + } + + public static final int RIGHT_FIELD_NUMBER = 2; + private fast.Fast.Pairs.Pair.Diff right_; + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public boolean hasRight() { + return right_ != null; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public fast.Fast.Pairs.Pair.Diff getRight() { + return right_ == null ? fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : right_; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public fast.Fast.Pairs.Pair.DiffOrBuilder getRightOrBuilder() { + return getRight(); + } + + public static final int TYPE_FIELD_NUMBER = 3; + private int type_; + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public fast.Fast.Pairs.Pair.CloneType getType() { + fast.Fast.Pairs.Pair.CloneType result = fast.Fast.Pairs.Pair.CloneType.valueOf(type_); + return result == null ? fast.Fast.Pairs.Pair.CloneType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (left_ != null) { + output.writeMessage(1, getLeft()); + } + if (right_ != null) { + output.writeMessage(2, getRight()); + } + if (type_ != fast.Fast.Pairs.Pair.CloneType.MAYBE.getNumber()) { + output.writeEnum(3, type_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (left_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getLeft()); + } + if (right_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getRight()); + } + if (type_ != fast.Fast.Pairs.Pair.CloneType.MAYBE.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, type_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Pairs.Pair)) { + return super.equals(obj); + } + fast.Fast.Pairs.Pair other = (fast.Fast.Pairs.Pair) obj; + + boolean result = true; + result = result && (hasLeft() == other.hasLeft()); + if (hasLeft()) { + result = result && getLeft() + .equals(other.getLeft()); + } + result = result && (hasRight() == other.hasRight()); + if (hasRight()) { + result = result && getRight() + .equals(other.getRight()); + } + result = result && type_ == other.type_; + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasLeft()) { + hash = (37 * hash) + LEFT_FIELD_NUMBER; + hash = (53 * hash) + getLeft().hashCode(); + } + if (hasRight()) { + hash = (37 * hash) + RIGHT_FIELD_NUMBER; + hash = (53 * hash) + getRight().hashCode(); + } + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Pairs.Pair parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs.Pair parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs.Pair parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs.Pair parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs.Pair parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs.Pair parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Pairs.Pair prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Pairs.Pair} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Pairs.Pair) + fast.Fast.Pairs.PairOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_Pair_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_Pair_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.Pair.class, fast.Fast.Pairs.Pair.Builder.class); + } + + // Construct using fast.Fast.Pairs.Pair.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + if (leftBuilder_ == null) { + left_ = null; + } else { + left_ = null; + leftBuilder_ = null; + } + if (rightBuilder_ == null) { + right_ = null; + } else { + right_ = null; + rightBuilder_ = null; + } + type_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Pairs_Pair_descriptor; + } + + public fast.Fast.Pairs.Pair getDefaultInstanceForType() { + return fast.Fast.Pairs.Pair.getDefaultInstance(); + } + + public fast.Fast.Pairs.Pair build() { + fast.Fast.Pairs.Pair result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Pairs.Pair buildPartial() { + fast.Fast.Pairs.Pair result = new fast.Fast.Pairs.Pair(this); + if (leftBuilder_ == null) { + result.left_ = left_; + } else { + result.left_ = leftBuilder_.build(); + } + if (rightBuilder_ == null) { + result.right_ = right_; + } else { + result.right_ = rightBuilder_.build(); + } + result.type_ = type_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Pairs.Pair) { + return mergeFrom((fast.Fast.Pairs.Pair)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Pairs.Pair other) { + if (other == fast.Fast.Pairs.Pair.getDefaultInstance()) return this; + if (other.hasLeft()) { + mergeLeft(other.getLeft()); + } + if (other.hasRight()) { + mergeRight(other.getRight()); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Pairs.Pair parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Pairs.Pair) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private fast.Fast.Pairs.Pair.Diff left_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder> leftBuilder_; + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public boolean hasLeft() { + return leftBuilder_ != null || left_ != null; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public fast.Fast.Pairs.Pair.Diff getLeft() { + if (leftBuilder_ == null) { + return left_ == null ? fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : left_; + } else { + return leftBuilder_.getMessage(); + } + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public Builder setLeft(fast.Fast.Pairs.Pair.Diff value) { + if (leftBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + left_ = value; + onChanged(); + } else { + leftBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public Builder setLeft( + fast.Fast.Pairs.Pair.Diff.Builder builderForValue) { + if (leftBuilder_ == null) { + left_ = builderForValue.build(); + onChanged(); + } else { + leftBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public Builder mergeLeft(fast.Fast.Pairs.Pair.Diff value) { + if (leftBuilder_ == null) { + if (left_ != null) { + left_ = + fast.Fast.Pairs.Pair.Diff.newBuilder(left_).mergeFrom(value).buildPartial(); + } else { + left_ = value; + } + onChanged(); + } else { + leftBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public Builder clearLeft() { + if (leftBuilder_ == null) { + left_ = null; + onChanged(); + } else { + left_ = null; + leftBuilder_ = null; + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public fast.Fast.Pairs.Pair.Diff.Builder getLeftBuilder() { + + onChanged(); + return getLeftFieldBuilder().getBuilder(); + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + public fast.Fast.Pairs.Pair.DiffOrBuilder getLeftOrBuilder() { + if (leftBuilder_ != null) { + return leftBuilder_.getMessageOrBuilder(); + } else { + return left_ == null ? + fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : left_; + } + } + /** + * .fast.Pairs.Pair.Diff left = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder> + getLeftFieldBuilder() { + if (leftBuilder_ == null) { + leftBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder>( + getLeft(), + getParentForChildren(), + isClean()); + left_ = null; + } + return leftBuilder_; + } + + private fast.Fast.Pairs.Pair.Diff right_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder> rightBuilder_; + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public boolean hasRight() { + return rightBuilder_ != null || right_ != null; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public fast.Fast.Pairs.Pair.Diff getRight() { + if (rightBuilder_ == null) { + return right_ == null ? fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : right_; + } else { + return rightBuilder_.getMessage(); + } + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public Builder setRight(fast.Fast.Pairs.Pair.Diff value) { + if (rightBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + right_ = value; + onChanged(); + } else { + rightBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public Builder setRight( + fast.Fast.Pairs.Pair.Diff.Builder builderForValue) { + if (rightBuilder_ == null) { + right_ = builderForValue.build(); + onChanged(); + } else { + rightBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public Builder mergeRight(fast.Fast.Pairs.Pair.Diff value) { + if (rightBuilder_ == null) { + if (right_ != null) { + right_ = + fast.Fast.Pairs.Pair.Diff.newBuilder(right_).mergeFrom(value).buildPartial(); + } else { + right_ = value; + } + onChanged(); + } else { + rightBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public Builder clearRight() { + if (rightBuilder_ == null) { + right_ = null; + onChanged(); + } else { + right_ = null; + rightBuilder_ = null; + } + + return this; + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public fast.Fast.Pairs.Pair.Diff.Builder getRightBuilder() { + + onChanged(); + return getRightFieldBuilder().getBuilder(); + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + public fast.Fast.Pairs.Pair.DiffOrBuilder getRightOrBuilder() { + if (rightBuilder_ != null) { + return rightBuilder_.getMessageOrBuilder(); + } else { + return right_ == null ? + fast.Fast.Pairs.Pair.Diff.getDefaultInstance() : right_; + } + } + /** + * .fast.Pairs.Pair.Diff right = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder> + getRightFieldBuilder() { + if (rightBuilder_ == null) { + rightBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs.Pair.Diff, fast.Fast.Pairs.Pair.Diff.Builder, fast.Fast.Pairs.Pair.DiffOrBuilder>( + getRight(), + getParentForChildren(), + isClean()); + right_ = null; + } + return rightBuilder_; + } + + private int type_ = 0; + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public fast.Fast.Pairs.Pair.CloneType getType() { + fast.Fast.Pairs.Pair.CloneType result = fast.Fast.Pairs.Pair.CloneType.valueOf(type_); + return result == null ? fast.Fast.Pairs.Pair.CloneType.UNRECOGNIZED : result; + } + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public Builder setType(fast.Fast.Pairs.Pair.CloneType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Pairs.Pair.CloneType type = 3; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Pairs.Pair) + } + + // @@protoc_insertion_point(class_scope:fast.Pairs.Pair) + private static final fast.Fast.Pairs.Pair DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Pairs.Pair(); + } + + public static fast.Fast.Pairs.Pair getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Pair parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Pair(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Pairs.Pair getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int PAIR_FIELD_NUMBER = 1; + private java.util.List pair_; + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public java.util.List getPairList() { + return pair_; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public java.util.List + getPairOrBuilderList() { + return pair_; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public int getPairCount() { + return pair_.size(); + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.Pair getPair(int index) { + return pair_.get(index); + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.PairOrBuilder getPairOrBuilder( + int index) { + return pair_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < pair_.size(); i++) { + output.writeMessage(1, pair_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < pair_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, pair_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Pairs)) { + return super.equals(obj); + } + fast.Fast.Pairs other = (fast.Fast.Pairs) obj; + + boolean result = true; + result = result && getPairList() + .equals(other.getPairList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getPairCount() > 0) { + hash = (37 * hash) + PAIR_FIELD_NUMBER; + hash = (53 * hash) + getPairList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Pairs parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Pairs parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Pairs parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Pairs parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Pairs parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Pairs parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Pairs prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Pairs} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Pairs) + fast.Fast.PairsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Pairs_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Pairs_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Pairs.class, fast.Fast.Pairs.Builder.class); + } + + // Construct using fast.Fast.Pairs.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPairFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (pairBuilder_ == null) { + pair_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + pairBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Pairs_descriptor; + } + + public fast.Fast.Pairs getDefaultInstanceForType() { + return fast.Fast.Pairs.getDefaultInstance(); + } + + public fast.Fast.Pairs build() { + fast.Fast.Pairs result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Pairs buildPartial() { + fast.Fast.Pairs result = new fast.Fast.Pairs(this); + int from_bitField0_ = bitField0_; + if (pairBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + pair_ = java.util.Collections.unmodifiableList(pair_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.pair_ = pair_; + } else { + result.pair_ = pairBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Pairs) { + return mergeFrom((fast.Fast.Pairs)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Pairs other) { + if (other == fast.Fast.Pairs.getDefaultInstance()) return this; + if (pairBuilder_ == null) { + if (!other.pair_.isEmpty()) { + if (pair_.isEmpty()) { + pair_ = other.pair_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensurePairIsMutable(); + pair_.addAll(other.pair_); + } + onChanged(); + } + } else { + if (!other.pair_.isEmpty()) { + if (pairBuilder_.isEmpty()) { + pairBuilder_.dispose(); + pairBuilder_ = null; + pair_ = other.pair_; + bitField0_ = (bitField0_ & ~0x00000001); + pairBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getPairFieldBuilder() : null; + } else { + pairBuilder_.addAllMessages(other.pair_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Pairs parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Pairs) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List pair_ = + java.util.Collections.emptyList(); + private void ensurePairIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + pair_ = new java.util.ArrayList(pair_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Pairs.Pair, fast.Fast.Pairs.Pair.Builder, fast.Fast.Pairs.PairOrBuilder> pairBuilder_; + + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public java.util.List getPairList() { + if (pairBuilder_ == null) { + return java.util.Collections.unmodifiableList(pair_); + } else { + return pairBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public int getPairCount() { + if (pairBuilder_ == null) { + return pair_.size(); + } else { + return pairBuilder_.getCount(); + } + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.Pair getPair(int index) { + if (pairBuilder_ == null) { + return pair_.get(index); + } else { + return pairBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder setPair( + int index, fast.Fast.Pairs.Pair value) { + if (pairBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePairIsMutable(); + pair_.set(index, value); + onChanged(); + } else { + pairBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder setPair( + int index, fast.Fast.Pairs.Pair.Builder builderForValue) { + if (pairBuilder_ == null) { + ensurePairIsMutable(); + pair_.set(index, builderForValue.build()); + onChanged(); + } else { + pairBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder addPair(fast.Fast.Pairs.Pair value) { + if (pairBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePairIsMutable(); + pair_.add(value); + onChanged(); + } else { + pairBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder addPair( + int index, fast.Fast.Pairs.Pair value) { + if (pairBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePairIsMutable(); + pair_.add(index, value); + onChanged(); + } else { + pairBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder addPair( + fast.Fast.Pairs.Pair.Builder builderForValue) { + if (pairBuilder_ == null) { + ensurePairIsMutable(); + pair_.add(builderForValue.build()); + onChanged(); + } else { + pairBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder addPair( + int index, fast.Fast.Pairs.Pair.Builder builderForValue) { + if (pairBuilder_ == null) { + ensurePairIsMutable(); + pair_.add(index, builderForValue.build()); + onChanged(); + } else { + pairBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder addAllPair( + java.lang.Iterable values) { + if (pairBuilder_ == null) { + ensurePairIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, pair_); + onChanged(); + } else { + pairBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder clearPair() { + if (pairBuilder_ == null) { + pair_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + pairBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public Builder removePair(int index) { + if (pairBuilder_ == null) { + ensurePairIsMutable(); + pair_.remove(index); + onChanged(); + } else { + pairBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.Pair.Builder getPairBuilder( + int index) { + return getPairFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.PairOrBuilder getPairOrBuilder( + int index) { + if (pairBuilder_ == null) { + return pair_.get(index); } else { + return pairBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public java.util.List + getPairOrBuilderList() { + if (pairBuilder_ != null) { + return pairBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(pair_); + } + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.Pair.Builder addPairBuilder() { + return getPairFieldBuilder().addBuilder( + fast.Fast.Pairs.Pair.getDefaultInstance()); + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public fast.Fast.Pairs.Pair.Builder addPairBuilder( + int index) { + return getPairFieldBuilder().addBuilder( + index, fast.Fast.Pairs.Pair.getDefaultInstance()); + } + /** + * repeated .fast.Pairs.Pair pair = 1; + */ + public java.util.List + getPairBuilderList() { + return getPairFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Pairs.Pair, fast.Fast.Pairs.Pair.Builder, fast.Fast.Pairs.PairOrBuilder> + getPairFieldBuilder() { + if (pairBuilder_ == null) { + pairBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Pairs.Pair, fast.Fast.Pairs.Pair.Builder, fast.Fast.Pairs.PairOrBuilder>( + pair_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + pair_ = null; + } + return pairBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Pairs) + } + + // @@protoc_insertion_point(class_scope:fast.Pairs) + private static final fast.Fast.Pairs DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Pairs(); + } + + public static fast.Fast.Pairs getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Pairs parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Pairs(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Pairs getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface LogOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Log.Commit commit = 1; + */ + java.util.List + getCommitList(); + /** + * repeated .fast.Log.Commit commit = 1; + */ + fast.Fast.Log.Commit getCommit(int index); + /** + * repeated .fast.Log.Commit commit = 1; + */ + int getCommitCount(); + /** + * repeated .fast.Log.Commit commit = 1; + */ + java.util.List + getCommitOrBuilderList(); + /** + * repeated .fast.Log.Commit commit = 1; + */ + fast.Fast.Log.CommitOrBuilder getCommitOrBuilder( + int index); + + /** + * repeated .fast.Log.Author author = 2; + */ + java.util.List + getAuthorList(); + /** + * repeated .fast.Log.Author author = 2; + */ + fast.Fast.Log.Author getAuthor(int index); + /** + * repeated .fast.Log.Author author = 2; + */ + int getAuthorCount(); + /** + * repeated .fast.Log.Author author = 2; + */ + java.util.List + getAuthorOrBuilderList(); + /** + * repeated .fast.Log.Author author = 2; + */ + fast.Fast.Log.AuthorOrBuilder getAuthorOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Log} + */ + public static final class Log extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log) + LogOrBuilder { + // Use Log.newBuilder() to construct. + private Log(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Log() { + commit_ = java.util.Collections.emptyList(); + author_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Log( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + commit_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + commit_.add( + input.readMessage(fast.Fast.Log.Commit.parser(), extensionRegistry)); + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + author_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + author_.add( + input.readMessage(fast.Fast.Log.Author.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + commit_ = java.util.Collections.unmodifiableList(commit_); + } + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + author_ = java.util.Collections.unmodifiableList(author_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.class, fast.Fast.Log.Builder.class); + } + + public interface CommitOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Commit) + com.google.protobuf.MessageOrBuilder { + + /** + * string id = 1; + */ + java.lang.String getId(); + /** + * string id = 1; + */ + com.google.protobuf.ByteString + getIdBytes(); + + /** + * bytes text = 2; + */ + com.google.protobuf.ByteString getText(); + + /** + * int32 author_id = 3; + */ + int getAuthorId(); + + /** + * string author_date = 4; + */ + java.lang.String getAuthorDate(); + /** + * string author_date = 4; + */ + com.google.protobuf.ByteString + getAuthorDateBytes(); + + /** + * .fast.Log.Commit.Committer committer = 5; + */ + fast.Fast.Log.Commit.Committer getCommitter(); + /** + * .fast.Log.Commit.Committer committer = 5; + */ + fast.Fast.Log.Commit.CommitterOrBuilder getCommitterOrBuilder(); + + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + java.util.List + getDiffList(); + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + fast.Fast.Log.Commit.Diff getDiff(int index); + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + int getDiffCount(); + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + java.util.List + getDiffOrBuilderList(); + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + fast.Fast.Log.Commit.DiffOrBuilder getDiffOrBuilder( + int index); + + /** + * .fast.Slices slice = 7; + */ + boolean hasSlice(); + /** + * .fast.Slices slice = 7; + */ + fast.Fast.Slices getSlice(); + /** + * .fast.Slices slice = 7; + */ + fast.Fast.SlicesOrBuilder getSliceOrBuilder(); + + public fast.Fast.Log.Commit.ExtraCase getExtraCase(); + } + /** + * Protobuf type {@code fast.Log.Commit} + */ + public static final class Commit extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Commit) + CommitOrBuilder { + // Use Commit.newBuilder() to construct. + private Commit(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Commit() { + id_ = ""; + text_ = com.google.protobuf.ByteString.EMPTY; + authorId_ = 0; + authorDate_ = ""; + diff_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Commit( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + id_ = s; + break; + } + case 18: { + + text_ = input.readBytes(); + break; + } + case 24: { + + authorId_ = input.readInt32(); + break; + } + case 34: { + java.lang.String s = input.readStringRequireUtf8(); + + authorDate_ = s; + break; + } + case 42: { + fast.Fast.Log.Commit.Committer.Builder subBuilder = null; + if (extraCase_ == 5) { + subBuilder = ((fast.Fast.Log.Commit.Committer) extra_).toBuilder(); + } + extra_ = + input.readMessage(fast.Fast.Log.Commit.Committer.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Log.Commit.Committer) extra_); + extra_ = subBuilder.buildPartial(); + } + extraCase_ = 5; + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + diff_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + diff_.add( + input.readMessage(fast.Fast.Log.Commit.Diff.parser(), extensionRegistry)); + break; + } + case 58: { + fast.Fast.Slices.Builder subBuilder = null; + if (slice_ != null) { + subBuilder = slice_.toBuilder(); + } + slice_ = input.readMessage(fast.Fast.Slices.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(slice_); + slice_ = subBuilder.buildPartial(); + } + + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + diff_ = java.util.Collections.unmodifiableList(diff_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.class, fast.Fast.Log.Commit.Builder.class); + } + + public interface CommitterOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Commit.Committer) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 committer_id = 1; + */ + int getCommitterId(); + + /** + * string commit_date = 2; + */ + java.lang.String getCommitDate(); + /** + * string commit_date = 2; + */ + com.google.protobuf.ByteString + getCommitDateBytes(); + } + /** + * Protobuf type {@code fast.Log.Commit.Committer} + */ + public static final class Committer extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Commit.Committer) + CommitterOrBuilder { + // Use Committer.newBuilder() to construct. + private Committer(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Committer() { + committerId_ = 0; + commitDate_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Committer( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + committerId_ = input.readInt32(); + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + commitDate_ = s; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Committer_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Committer_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Committer.class, fast.Fast.Log.Commit.Committer.Builder.class); + } + + public static final int COMMITTER_ID_FIELD_NUMBER = 1; + private int committerId_; + /** + * int32 committer_id = 1; + */ + public int getCommitterId() { + return committerId_; + } + + public static final int COMMIT_DATE_FIELD_NUMBER = 2; + private volatile java.lang.Object commitDate_; + /** + * string commit_date = 2; + */ + public java.lang.String getCommitDate() { + java.lang.Object ref = commitDate_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + commitDate_ = s; + return s; + } + } + /** + * string commit_date = 2; + */ + public com.google.protobuf.ByteString + getCommitDateBytes() { + java.lang.Object ref = commitDate_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + commitDate_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (committerId_ != 0) { + output.writeInt32(1, committerId_); + } + if (!getCommitDateBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, commitDate_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (committerId_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, committerId_); + } + if (!getCommitDateBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, commitDate_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Commit.Committer)) { + return super.equals(obj); + } + fast.Fast.Log.Commit.Committer other = (fast.Fast.Log.Commit.Committer) obj; + + boolean result = true; + result = result && (getCommitterId() + == other.getCommitterId()); + result = result && getCommitDate() + .equals(other.getCommitDate()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + COMMITTER_ID_FIELD_NUMBER; + hash = (53 * hash) + getCommitterId(); + hash = (37 * hash) + COMMIT_DATE_FIELD_NUMBER; + hash = (53 * hash) + getCommitDate().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Commit.Committer parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Committer parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Committer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Committer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Committer parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Committer parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Commit.Committer prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Commit.Committer} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Commit.Committer) + fast.Fast.Log.Commit.CommitterOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Committer_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Committer_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Committer.class, fast.Fast.Log.Commit.Committer.Builder.class); + } + + // Construct using fast.Fast.Log.Commit.Committer.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + committerId_ = 0; + + commitDate_ = ""; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Commit_Committer_descriptor; + } + + public fast.Fast.Log.Commit.Committer getDefaultInstanceForType() { + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + + public fast.Fast.Log.Commit.Committer build() { + fast.Fast.Log.Commit.Committer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Commit.Committer buildPartial() { + fast.Fast.Log.Commit.Committer result = new fast.Fast.Log.Commit.Committer(this); + result.committerId_ = committerId_; + result.commitDate_ = commitDate_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Commit.Committer) { + return mergeFrom((fast.Fast.Log.Commit.Committer)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Commit.Committer other) { + if (other == fast.Fast.Log.Commit.Committer.getDefaultInstance()) return this; + if (other.getCommitterId() != 0) { + setCommitterId(other.getCommitterId()); + } + if (!other.getCommitDate().isEmpty()) { + commitDate_ = other.commitDate_; + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Commit.Committer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Commit.Committer) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int committerId_ ; + /** + * int32 committer_id = 1; + */ + public int getCommitterId() { + return committerId_; + } + /** + * int32 committer_id = 1; + */ + public Builder setCommitterId(int value) { + + committerId_ = value; + onChanged(); + return this; + } + /** + * int32 committer_id = 1; + */ + public Builder clearCommitterId() { + + committerId_ = 0; + onChanged(); + return this; + } + + private java.lang.Object commitDate_ = ""; + /** + * string commit_date = 2; + */ + public java.lang.String getCommitDate() { + java.lang.Object ref = commitDate_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + commitDate_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string commit_date = 2; + */ + public com.google.protobuf.ByteString + getCommitDateBytes() { + java.lang.Object ref = commitDate_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + commitDate_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string commit_date = 2; + */ + public Builder setCommitDate( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + commitDate_ = value; + onChanged(); + return this; + } + /** + * string commit_date = 2; + */ + public Builder clearCommitDate() { + + commitDate_ = getDefaultInstance().getCommitDate(); + onChanged(); + return this; + } + /** + * string commit_date = 2; + */ + public Builder setCommitDateBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + commitDate_ = value; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Commit.Committer) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Commit.Committer) + private static final fast.Fast.Log.Commit.Committer DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Commit.Committer(); + } + + public static fast.Fast.Log.Commit.Committer getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Committer parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Committer(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Commit.Committer getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DiffOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Commit.Diff) + com.google.protobuf.MessageOrBuilder { + + /** + * string a = 1; + */ + java.lang.String getA(); + /** + * string a = 1; + */ + com.google.protobuf.ByteString + getABytes(); + + /** + * string b = 2; + */ + java.lang.String getB(); + /** + * string b = 2; + */ + com.google.protobuf.ByteString + getBBytes(); + + /** + * bool is_new = 3; + */ + boolean getIsNew(); + + /** + * string is_code = 4; + */ + java.lang.String getIsCode(); + /** + * string is_code = 4; + */ + com.google.protobuf.ByteString + getIsCodeBytes(); + + /** + * string index_from = 5; + */ + java.lang.String getIndexFrom(); + /** + * string index_from = 5; + */ + com.google.protobuf.ByteString + getIndexFromBytes(); + + /** + * string index_to = 6; + */ + java.lang.String getIndexTo(); + /** + * string index_to = 6; + */ + com.google.protobuf.ByteString + getIndexToBytes(); + + /** + * string mode = 7; + */ + java.lang.String getMode(); + /** + * string mode = 7; + */ + com.google.protobuf.ByteString + getModeBytes(); + + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + java.util.List + getHunkList(); + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + fast.Fast.Log.Commit.Diff.Hunk getHunk(int index); + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + int getHunkCount(); + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + java.util.List + getHunkOrBuilderList(); + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + fast.Fast.Log.Commit.Diff.HunkOrBuilder getHunkOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Log.Commit.Diff} + */ + public static final class Diff extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Commit.Diff) + DiffOrBuilder { + // Use Diff.newBuilder() to construct. + private Diff(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Diff() { + a_ = ""; + b_ = ""; + isNew_ = false; + isCode_ = ""; + indexFrom_ = ""; + indexTo_ = ""; + mode_ = ""; + hunk_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Diff( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + a_ = s; + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + b_ = s; + break; + } + case 24: { + + isNew_ = input.readBool(); + break; + } + case 34: { + java.lang.String s = input.readStringRequireUtf8(); + + isCode_ = s; + break; + } + case 42: { + java.lang.String s = input.readStringRequireUtf8(); + + indexFrom_ = s; + break; + } + case 50: { + java.lang.String s = input.readStringRequireUtf8(); + + indexTo_ = s; + break; + } + case 58: { + java.lang.String s = input.readStringRequireUtf8(); + + mode_ = s; + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + hunk_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + hunk_.add( + input.readMessage(fast.Fast.Log.Commit.Diff.Hunk.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + hunk_ = java.util.Collections.unmodifiableList(hunk_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.class, fast.Fast.Log.Commit.Diff.Builder.class); + } + + public interface HunkOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Commit.Diff.Hunk) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 from_lineno = 1; + */ + int getFromLineno(); + + /** + * int32 from_column = 2; + */ + int getFromColumn(); + + /** + * int32 to_lineno = 3; + */ + int getToLineno(); + + /** + * int32 to_column = 4; + */ + int getToColumn(); + + /** + * string context = 5; + */ + java.lang.String getContext(); + /** + * string context = 5; + */ + com.google.protobuf.ByteString + getContextBytes(); + + /** + * repeated .fast.Element element = 6; + */ + java.util.List + getElementList(); + /** + * repeated .fast.Element element = 6; + */ + fast.Fast.Element getElement(int index); + /** + * repeated .fast.Element element = 6; + */ + int getElementCount(); + /** + * repeated .fast.Element element = 6; + */ + java.util.List + getElementOrBuilderList(); + /** + * repeated .fast.Element element = 6; + */ + fast.Fast.ElementOrBuilder getElementOrBuilder( + int index); + + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + java.util.List + getModList(); + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + fast.Fast.Log.Commit.Diff.Hunk.ModLine getMod(int index); + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + int getModCount(); + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + java.util.List + getModOrBuilderList(); + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder getModOrBuilder( + int index); + + /** + * .fast.Slices slice = 8; + */ + boolean hasSlice(); + /** + * .fast.Slices slice = 8; + */ + fast.Fast.Slices getSlice(); + /** + * .fast.Slices slice = 8; + */ + fast.Fast.SlicesOrBuilder getSliceOrBuilder(); + } + /** + * Protobuf type {@code fast.Log.Commit.Diff.Hunk} + */ + public static final class Hunk extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Commit.Diff.Hunk) + HunkOrBuilder { + // Use Hunk.newBuilder() to construct. + private Hunk(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Hunk() { + fromLineno_ = 0; + fromColumn_ = 0; + toLineno_ = 0; + toColumn_ = 0; + context_ = ""; + element_ = java.util.Collections.emptyList(); + mod_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Hunk( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + fromLineno_ = input.readInt32(); + break; + } + case 16: { + + fromColumn_ = input.readInt32(); + break; + } + case 24: { + + toLineno_ = input.readInt32(); + break; + } + case 32: { + + toColumn_ = input.readInt32(); + break; + } + case 42: { + java.lang.String s = input.readStringRequireUtf8(); + + context_ = s; + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + element_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + element_.add( + input.readMessage(fast.Fast.Element.parser(), extensionRegistry)); + break; + } + case 58: { + if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + mod_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000040; + } + mod_.add( + input.readMessage(fast.Fast.Log.Commit.Diff.Hunk.ModLine.parser(), extensionRegistry)); + break; + } + case 66: { + fast.Fast.Slices.Builder subBuilder = null; + if (slice_ != null) { + subBuilder = slice_.toBuilder(); + } + slice_ = input.readMessage(fast.Fast.Slices.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(slice_); + slice_ = subBuilder.buildPartial(); + } + + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + element_ = java.util.Collections.unmodifiableList(element_); + } + if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + mod_ = java.util.Collections.unmodifiableList(mod_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.Hunk.class, fast.Fast.Log.Commit.Diff.Hunk.Builder.class); + } + + public interface ModLineOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Commit.Diff.Hunk.ModLine) + com.google.protobuf.MessageOrBuilder { + + /** + * bytes line = 1; + */ + com.google.protobuf.ByteString getLine(); + + /** + * bool is_add = 2; + */ + boolean getIsAdd(); + + /** + * bool is_del = 3; + */ + boolean getIsDel(); + } + /** + * Protobuf type {@code fast.Log.Commit.Diff.Hunk.ModLine} + */ + public static final class ModLine extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Commit.Diff.Hunk.ModLine) + ModLineOrBuilder { + // Use ModLine.newBuilder() to construct. + private ModLine(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ModLine() { + line_ = com.google.protobuf.ByteString.EMPTY; + isAdd_ = false; + isDel_ = false; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private ModLine( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + + line_ = input.readBytes(); + break; + } + case 16: { + + isAdd_ = input.readBool(); + break; + } + case 24: { + + isDel_ = input.readBool(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_ModLine_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.Hunk.ModLine.class, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder.class); + } + + public static final int LINE_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString line_; + /** + * bytes line = 1; + */ + public com.google.protobuf.ByteString getLine() { + return line_; + } + + public static final int IS_ADD_FIELD_NUMBER = 2; + private boolean isAdd_; + /** + * bool is_add = 2; + */ + public boolean getIsAdd() { + return isAdd_; + } + + public static final int IS_DEL_FIELD_NUMBER = 3; + private boolean isDel_; + /** + * bool is_del = 3; + */ + public boolean getIsDel() { + return isDel_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!line_.isEmpty()) { + output.writeBytes(1, line_); + } + if (isAdd_ != false) { + output.writeBool(2, isAdd_); + } + if (isDel_ != false) { + output.writeBool(3, isDel_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!line_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, line_); + } + if (isAdd_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(2, isAdd_); + } + if (isDel_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, isDel_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Commit.Diff.Hunk.ModLine)) { + return super.equals(obj); + } + fast.Fast.Log.Commit.Diff.Hunk.ModLine other = (fast.Fast.Log.Commit.Diff.Hunk.ModLine) obj; + + boolean result = true; + result = result && getLine() + .equals(other.getLine()); + result = result && (getIsAdd() + == other.getIsAdd()); + result = result && (getIsDel() + == other.getIsDel()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + LINE_FIELD_NUMBER; + hash = (53 * hash) + getLine().hashCode(); + hash = (37 * hash) + IS_ADD_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsAdd()); + hash = (37 * hash) + IS_DEL_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsDel()); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Commit.Diff.Hunk.ModLine prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Commit.Diff.Hunk.ModLine} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Commit.Diff.Hunk.ModLine) + fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_ModLine_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.Hunk.ModLine.class, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder.class); + } + + // Construct using fast.Fast.Log.Commit.Diff.Hunk.ModLine.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + line_ = com.google.protobuf.ByteString.EMPTY; + + isAdd_ = false; + + isDel_ = false; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor; + } + + public fast.Fast.Log.Commit.Diff.Hunk.ModLine getDefaultInstanceForType() { + return fast.Fast.Log.Commit.Diff.Hunk.ModLine.getDefaultInstance(); + } + + public fast.Fast.Log.Commit.Diff.Hunk.ModLine build() { + fast.Fast.Log.Commit.Diff.Hunk.ModLine result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Commit.Diff.Hunk.ModLine buildPartial() { + fast.Fast.Log.Commit.Diff.Hunk.ModLine result = new fast.Fast.Log.Commit.Diff.Hunk.ModLine(this); + result.line_ = line_; + result.isAdd_ = isAdd_; + result.isDel_ = isDel_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Commit.Diff.Hunk.ModLine) { + return mergeFrom((fast.Fast.Log.Commit.Diff.Hunk.ModLine)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Commit.Diff.Hunk.ModLine other) { + if (other == fast.Fast.Log.Commit.Diff.Hunk.ModLine.getDefaultInstance()) return this; + if (other.getLine() != com.google.protobuf.ByteString.EMPTY) { + setLine(other.getLine()); + } + if (other.getIsAdd() != false) { + setIsAdd(other.getIsAdd()); + } + if (other.getIsDel() != false) { + setIsDel(other.getIsDel()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Commit.Diff.Hunk.ModLine parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Commit.Diff.Hunk.ModLine) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private com.google.protobuf.ByteString line_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes line = 1; + */ + public com.google.protobuf.ByteString getLine() { + return line_; + } + /** + * bytes line = 1; + */ + public Builder setLine(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + line_ = value; + onChanged(); + return this; + } + /** + * bytes line = 1; + */ + public Builder clearLine() { + + line_ = getDefaultInstance().getLine(); + onChanged(); + return this; + } + + private boolean isAdd_ ; + /** + * bool is_add = 2; + */ + public boolean getIsAdd() { + return isAdd_; + } + /** + * bool is_add = 2; + */ + public Builder setIsAdd(boolean value) { + + isAdd_ = value; + onChanged(); + return this; + } + /** + * bool is_add = 2; + */ + public Builder clearIsAdd() { + + isAdd_ = false; + onChanged(); + return this; + } + + private boolean isDel_ ; + /** + * bool is_del = 3; + */ + public boolean getIsDel() { + return isDel_; + } + /** + * bool is_del = 3; + */ + public Builder setIsDel(boolean value) { + + isDel_ = value; + onChanged(); + return this; + } + /** + * bool is_del = 3; + */ + public Builder clearIsDel() { + + isDel_ = false; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Commit.Diff.Hunk.ModLine) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Commit.Diff.Hunk.ModLine) + private static final fast.Fast.Log.Commit.Diff.Hunk.ModLine DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Commit.Diff.Hunk.ModLine(); + } + + public static fast.Fast.Log.Commit.Diff.Hunk.ModLine getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public ModLine parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ModLine(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Commit.Diff.Hunk.ModLine getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int FROM_LINENO_FIELD_NUMBER = 1; + private int fromLineno_; + /** + * int32 from_lineno = 1; + */ + public int getFromLineno() { + return fromLineno_; + } + + public static final int FROM_COLUMN_FIELD_NUMBER = 2; + private int fromColumn_; + /** + * int32 from_column = 2; + */ + public int getFromColumn() { + return fromColumn_; + } + + public static final int TO_LINENO_FIELD_NUMBER = 3; + private int toLineno_; + /** + * int32 to_lineno = 3; + */ + public int getToLineno() { + return toLineno_; + } + + public static final int TO_COLUMN_FIELD_NUMBER = 4; + private int toColumn_; + /** + * int32 to_column = 4; + */ + public int getToColumn() { + return toColumn_; + } + + public static final int CONTEXT_FIELD_NUMBER = 5; + private volatile java.lang.Object context_; + /** + * string context = 5; + */ + public java.lang.String getContext() { + java.lang.Object ref = context_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + context_ = s; + return s; + } + } + /** + * string context = 5; + */ + public com.google.protobuf.ByteString + getContextBytes() { + java.lang.Object ref = context_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + context_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int ELEMENT_FIELD_NUMBER = 6; + private java.util.List element_; + /** + * repeated .fast.Element element = 6; + */ + public java.util.List getElementList() { + return element_; + } + /** + * repeated .fast.Element element = 6; + */ + public java.util.List + getElementOrBuilderList() { + return element_; + } + /** + * repeated .fast.Element element = 6; + */ + public int getElementCount() { + return element_.size(); + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.Element getElement(int index) { + return element_.get(index); + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.ElementOrBuilder getElementOrBuilder( + int index) { + return element_.get(index); + } + + public static final int MOD_FIELD_NUMBER = 7; + private java.util.List mod_; + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public java.util.List getModList() { + return mod_; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public java.util.List + getModOrBuilderList() { + return mod_; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public int getModCount() { + return mod_.size(); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLine getMod(int index) { + return mod_.get(index); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder getModOrBuilder( + int index) { + return mod_.get(index); + } + + public static final int SLICE_FIELD_NUMBER = 8; + private fast.Fast.Slices slice_; + /** + * .fast.Slices slice = 8; + */ + public boolean hasSlice() { + return slice_ != null; + } + /** + * .fast.Slices slice = 8; + */ + public fast.Fast.Slices getSlice() { + return slice_ == null ? fast.Fast.Slices.getDefaultInstance() : slice_; + } + /** + * .fast.Slices slice = 8; + */ + public fast.Fast.SlicesOrBuilder getSliceOrBuilder() { + return getSlice(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (fromLineno_ != 0) { + output.writeInt32(1, fromLineno_); + } + if (fromColumn_ != 0) { + output.writeInt32(2, fromColumn_); + } + if (toLineno_ != 0) { + output.writeInt32(3, toLineno_); + } + if (toColumn_ != 0) { + output.writeInt32(4, toColumn_); + } + if (!getContextBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 5, context_); + } + for (int i = 0; i < element_.size(); i++) { + output.writeMessage(6, element_.get(i)); + } + for (int i = 0; i < mod_.size(); i++) { + output.writeMessage(7, mod_.get(i)); + } + if (slice_ != null) { + output.writeMessage(8, getSlice()); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (fromLineno_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, fromLineno_); + } + if (fromColumn_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, fromColumn_); + } + if (toLineno_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, toLineno_); + } + if (toColumn_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, toColumn_); + } + if (!getContextBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, context_); + } + for (int i = 0; i < element_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, element_.get(i)); + } + for (int i = 0; i < mod_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, mod_.get(i)); + } + if (slice_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, getSlice()); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Commit.Diff.Hunk)) { + return super.equals(obj); + } + fast.Fast.Log.Commit.Diff.Hunk other = (fast.Fast.Log.Commit.Diff.Hunk) obj; + + boolean result = true; + result = result && (getFromLineno() + == other.getFromLineno()); + result = result && (getFromColumn() + == other.getFromColumn()); + result = result && (getToLineno() + == other.getToLineno()); + result = result && (getToColumn() + == other.getToColumn()); + result = result && getContext() + .equals(other.getContext()); + result = result && getElementList() + .equals(other.getElementList()); + result = result && getModList() + .equals(other.getModList()); + result = result && (hasSlice() == other.hasSlice()); + if (hasSlice()) { + result = result && getSlice() + .equals(other.getSlice()); + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + FROM_LINENO_FIELD_NUMBER; + hash = (53 * hash) + getFromLineno(); + hash = (37 * hash) + FROM_COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getFromColumn(); + hash = (37 * hash) + TO_LINENO_FIELD_NUMBER; + hash = (53 * hash) + getToLineno(); + hash = (37 * hash) + TO_COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getToColumn(); + hash = (37 * hash) + CONTEXT_FIELD_NUMBER; + hash = (53 * hash) + getContext().hashCode(); + if (getElementCount() > 0) { + hash = (37 * hash) + ELEMENT_FIELD_NUMBER; + hash = (53 * hash) + getElementList().hashCode(); + } + if (getModCount() > 0) { + hash = (37 * hash) + MOD_FIELD_NUMBER; + hash = (53 * hash) + getModList().hashCode(); + } + if (hasSlice()) { + hash = (37 * hash) + SLICE_FIELD_NUMBER; + hash = (53 * hash) + getSlice().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff.Hunk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Commit.Diff.Hunk prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Commit.Diff.Hunk} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Commit.Diff.Hunk) + fast.Fast.Log.Commit.Diff.HunkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.Hunk.class, fast.Fast.Log.Commit.Diff.Hunk.Builder.class); + } + + // Construct using fast.Fast.Log.Commit.Diff.Hunk.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getElementFieldBuilder(); + getModFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + fromLineno_ = 0; + + fromColumn_ = 0; + + toLineno_ = 0; + + toColumn_ = 0; + + context_ = ""; + + if (elementBuilder_ == null) { + element_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + } else { + elementBuilder_.clear(); + } + if (modBuilder_ == null) { + mod_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + } else { + modBuilder_.clear(); + } + if (sliceBuilder_ == null) { + slice_ = null; + } else { + slice_ = null; + sliceBuilder_ = null; + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_Hunk_descriptor; + } + + public fast.Fast.Log.Commit.Diff.Hunk getDefaultInstanceForType() { + return fast.Fast.Log.Commit.Diff.Hunk.getDefaultInstance(); + } + + public fast.Fast.Log.Commit.Diff.Hunk build() { + fast.Fast.Log.Commit.Diff.Hunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Commit.Diff.Hunk buildPartial() { + fast.Fast.Log.Commit.Diff.Hunk result = new fast.Fast.Log.Commit.Diff.Hunk(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.fromLineno_ = fromLineno_; + result.fromColumn_ = fromColumn_; + result.toLineno_ = toLineno_; + result.toColumn_ = toColumn_; + result.context_ = context_; + if (elementBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020)) { + element_ = java.util.Collections.unmodifiableList(element_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.element_ = element_; + } else { + result.element_ = elementBuilder_.build(); + } + if (modBuilder_ == null) { + if (((bitField0_ & 0x00000040) == 0x00000040)) { + mod_ = java.util.Collections.unmodifiableList(mod_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.mod_ = mod_; + } else { + result.mod_ = modBuilder_.build(); + } + if (sliceBuilder_ == null) { + result.slice_ = slice_; + } else { + result.slice_ = sliceBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Commit.Diff.Hunk) { + return mergeFrom((fast.Fast.Log.Commit.Diff.Hunk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Commit.Diff.Hunk other) { + if (other == fast.Fast.Log.Commit.Diff.Hunk.getDefaultInstance()) return this; + if (other.getFromLineno() != 0) { + setFromLineno(other.getFromLineno()); + } + if (other.getFromColumn() != 0) { + setFromColumn(other.getFromColumn()); + } + if (other.getToLineno() != 0) { + setToLineno(other.getToLineno()); + } + if (other.getToColumn() != 0) { + setToColumn(other.getToColumn()); + } + if (!other.getContext().isEmpty()) { + context_ = other.context_; + onChanged(); + } + if (elementBuilder_ == null) { + if (!other.element_.isEmpty()) { + if (element_.isEmpty()) { + element_ = other.element_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureElementIsMutable(); + element_.addAll(other.element_); + } + onChanged(); + } + } else { + if (!other.element_.isEmpty()) { + if (elementBuilder_.isEmpty()) { + elementBuilder_.dispose(); + elementBuilder_ = null; + element_ = other.element_; + bitField0_ = (bitField0_ & ~0x00000020); + elementBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getElementFieldBuilder() : null; + } else { + elementBuilder_.addAllMessages(other.element_); + } + } + } + if (modBuilder_ == null) { + if (!other.mod_.isEmpty()) { + if (mod_.isEmpty()) { + mod_ = other.mod_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureModIsMutable(); + mod_.addAll(other.mod_); + } + onChanged(); + } + } else { + if (!other.mod_.isEmpty()) { + if (modBuilder_.isEmpty()) { + modBuilder_.dispose(); + modBuilder_ = null; + mod_ = other.mod_; + bitField0_ = (bitField0_ & ~0x00000040); + modBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getModFieldBuilder() : null; + } else { + modBuilder_.addAllMessages(other.mod_); + } + } + } + if (other.hasSlice()) { + mergeSlice(other.getSlice()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Commit.Diff.Hunk parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Commit.Diff.Hunk) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int fromLineno_ ; + /** + * int32 from_lineno = 1; + */ + public int getFromLineno() { + return fromLineno_; + } + /** + * int32 from_lineno = 1; + */ + public Builder setFromLineno(int value) { + + fromLineno_ = value; + onChanged(); + return this; + } + /** + * int32 from_lineno = 1; + */ + public Builder clearFromLineno() { + + fromLineno_ = 0; + onChanged(); + return this; + } + + private int fromColumn_ ; + /** + * int32 from_column = 2; + */ + public int getFromColumn() { + return fromColumn_; + } + /** + * int32 from_column = 2; + */ + public Builder setFromColumn(int value) { + + fromColumn_ = value; + onChanged(); + return this; + } + /** + * int32 from_column = 2; + */ + public Builder clearFromColumn() { + + fromColumn_ = 0; + onChanged(); + return this; + } + + private int toLineno_ ; + /** + * int32 to_lineno = 3; + */ + public int getToLineno() { + return toLineno_; + } + /** + * int32 to_lineno = 3; + */ + public Builder setToLineno(int value) { + + toLineno_ = value; + onChanged(); + return this; + } + /** + * int32 to_lineno = 3; + */ + public Builder clearToLineno() { + + toLineno_ = 0; + onChanged(); + return this; + } + + private int toColumn_ ; + /** + * int32 to_column = 4; + */ + public int getToColumn() { + return toColumn_; + } + /** + * int32 to_column = 4; + */ + public Builder setToColumn(int value) { + + toColumn_ = value; + onChanged(); + return this; + } + /** + * int32 to_column = 4; + */ + public Builder clearToColumn() { + + toColumn_ = 0; + onChanged(); + return this; + } + + private java.lang.Object context_ = ""; + /** + * string context = 5; + */ + public java.lang.String getContext() { + java.lang.Object ref = context_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + context_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string context = 5; + */ + public com.google.protobuf.ByteString + getContextBytes() { + java.lang.Object ref = context_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + context_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string context = 5; + */ + public Builder setContext( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + context_ = value; + onChanged(); + return this; + } + /** + * string context = 5; + */ + public Builder clearContext() { + + context_ = getDefaultInstance().getContext(); + onChanged(); + return this; + } + /** + * string context = 5; + */ + public Builder setContextBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + context_ = value; + onChanged(); + return this; + } + + private java.util.List element_ = + java.util.Collections.emptyList(); + private void ensureElementIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + element_ = new java.util.ArrayList(element_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> elementBuilder_; + + /** + * repeated .fast.Element element = 6; + */ + public java.util.List getElementList() { + if (elementBuilder_ == null) { + return java.util.Collections.unmodifiableList(element_); + } else { + return elementBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Element element = 6; + */ + public int getElementCount() { + if (elementBuilder_ == null) { + return element_.size(); + } else { + return elementBuilder_.getCount(); + } + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.Element getElement(int index) { + if (elementBuilder_ == null) { + return element_.get(index); + } else { + return elementBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Element element = 6; + */ + public Builder setElement( + int index, fast.Fast.Element value) { + if (elementBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.set(index, value); + onChanged(); + } else { + elementBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder setElement( + int index, fast.Fast.Element.Builder builderForValue) { + if (elementBuilder_ == null) { + ensureElementIsMutable(); + element_.set(index, builderForValue.build()); + onChanged(); + } else { + elementBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder addElement(fast.Fast.Element value) { + if (elementBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(value); + onChanged(); + } else { + elementBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder addElement( + int index, fast.Fast.Element value) { + if (elementBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(index, value); + onChanged(); + } else { + elementBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder addElement( + fast.Fast.Element.Builder builderForValue) { + if (elementBuilder_ == null) { + ensureElementIsMutable(); + element_.add(builderForValue.build()); + onChanged(); + } else { + elementBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder addElement( + int index, fast.Fast.Element.Builder builderForValue) { + if (elementBuilder_ == null) { + ensureElementIsMutable(); + element_.add(index, builderForValue.build()); + onChanged(); + } else { + elementBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder addAllElement( + java.lang.Iterable values) { + if (elementBuilder_ == null) { + ensureElementIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, element_); + onChanged(); + } else { + elementBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder clearElement() { + if (elementBuilder_ == null) { + element_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + elementBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public Builder removeElement(int index) { + if (elementBuilder_ == null) { + ensureElementIsMutable(); + element_.remove(index); + onChanged(); + } else { + elementBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.Element.Builder getElementBuilder( + int index) { + return getElementFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.ElementOrBuilder getElementOrBuilder( + int index) { + if (elementBuilder_ == null) { + return element_.get(index); } else { + return elementBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Element element = 6; + */ + public java.util.List + getElementOrBuilderList() { + if (elementBuilder_ != null) { + return elementBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(element_); + } + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.Element.Builder addElementBuilder() { + return getElementFieldBuilder().addBuilder( + fast.Fast.Element.getDefaultInstance()); + } + /** + * repeated .fast.Element element = 6; + */ + public fast.Fast.Element.Builder addElementBuilder( + int index) { + return getElementFieldBuilder().addBuilder( + index, fast.Fast.Element.getDefaultInstance()); + } + /** + * repeated .fast.Element element = 6; + */ + public java.util.List + getElementBuilderList() { + return getElementFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> + getElementFieldBuilder() { + if (elementBuilder_ == null) { + elementBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder>( + element_, + ((bitField0_ & 0x00000020) == 0x00000020), + getParentForChildren(), + isClean()); + element_ = null; + } + return elementBuilder_; + } + + private java.util.List mod_ = + java.util.Collections.emptyList(); + private void ensureModIsMutable() { + if (!((bitField0_ & 0x00000040) == 0x00000040)) { + mod_ = new java.util.ArrayList(mod_); + bitField0_ |= 0x00000040; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk.ModLine, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder, fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder> modBuilder_; + + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public java.util.List getModList() { + if (modBuilder_ == null) { + return java.util.Collections.unmodifiableList(mod_); + } else { + return modBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public int getModCount() { + if (modBuilder_ == null) { + return mod_.size(); + } else { + return modBuilder_.getCount(); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLine getMod(int index) { + if (modBuilder_ == null) { + return mod_.get(index); + } else { + return modBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder setMod( + int index, fast.Fast.Log.Commit.Diff.Hunk.ModLine value) { + if (modBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureModIsMutable(); + mod_.set(index, value); + onChanged(); + } else { + modBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder setMod( + int index, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder builderForValue) { + if (modBuilder_ == null) { + ensureModIsMutable(); + mod_.set(index, builderForValue.build()); + onChanged(); + } else { + modBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder addMod(fast.Fast.Log.Commit.Diff.Hunk.ModLine value) { + if (modBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureModIsMutable(); + mod_.add(value); + onChanged(); + } else { + modBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder addMod( + int index, fast.Fast.Log.Commit.Diff.Hunk.ModLine value) { + if (modBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureModIsMutable(); + mod_.add(index, value); + onChanged(); + } else { + modBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder addMod( + fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder builderForValue) { + if (modBuilder_ == null) { + ensureModIsMutable(); + mod_.add(builderForValue.build()); + onChanged(); + } else { + modBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder addMod( + int index, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder builderForValue) { + if (modBuilder_ == null) { + ensureModIsMutable(); + mod_.add(index, builderForValue.build()); + onChanged(); + } else { + modBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder addAllMod( + java.lang.Iterable values) { + if (modBuilder_ == null) { + ensureModIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, mod_); + onChanged(); + } else { + modBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder clearMod() { + if (modBuilder_ == null) { + mod_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + } else { + modBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public Builder removeMod(int index) { + if (modBuilder_ == null) { + ensureModIsMutable(); + mod_.remove(index); + onChanged(); + } else { + modBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder getModBuilder( + int index) { + return getModFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder getModOrBuilder( + int index) { + if (modBuilder_ == null) { + return mod_.get(index); } else { + return modBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public java.util.List + getModOrBuilderList() { + if (modBuilder_ != null) { + return modBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(mod_); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder addModBuilder() { + return getModFieldBuilder().addBuilder( + fast.Fast.Log.Commit.Diff.Hunk.ModLine.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder addModBuilder( + int index) { + return getModFieldBuilder().addBuilder( + index, fast.Fast.Log.Commit.Diff.Hunk.ModLine.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk.ModLine mod = 7; + */ + public java.util.List + getModBuilderList() { + return getModFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk.ModLine, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder, fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder> + getModFieldBuilder() { + if (modBuilder_ == null) { + modBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk.ModLine, fast.Fast.Log.Commit.Diff.Hunk.ModLine.Builder, fast.Fast.Log.Commit.Diff.Hunk.ModLineOrBuilder>( + mod_, + ((bitField0_ & 0x00000040) == 0x00000040), + getParentForChildren(), + isClean()); + mod_ = null; + } + return modBuilder_; + } + + private fast.Fast.Slices slice_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> sliceBuilder_; + /** + * .fast.Slices slice = 8; + */ + public boolean hasSlice() { + return sliceBuilder_ != null || slice_ != null; + } + /** + * .fast.Slices slice = 8; + */ + public fast.Fast.Slices getSlice() { + if (sliceBuilder_ == null) { + return slice_ == null ? fast.Fast.Slices.getDefaultInstance() : slice_; + } else { + return sliceBuilder_.getMessage(); + } + } + /** + * .fast.Slices slice = 8; + */ + public Builder setSlice(fast.Fast.Slices value) { + if (sliceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + slice_ = value; + onChanged(); + } else { + sliceBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Slices slice = 8; + */ + public Builder setSlice( + fast.Fast.Slices.Builder builderForValue) { + if (sliceBuilder_ == null) { + slice_ = builderForValue.build(); + onChanged(); + } else { + sliceBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Slices slice = 8; + */ + public Builder mergeSlice(fast.Fast.Slices value) { + if (sliceBuilder_ == null) { + if (slice_ != null) { + slice_ = + fast.Fast.Slices.newBuilder(slice_).mergeFrom(value).buildPartial(); + } else { + slice_ = value; + } + onChanged(); + } else { + sliceBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Slices slice = 8; + */ + public Builder clearSlice() { + if (sliceBuilder_ == null) { + slice_ = null; + onChanged(); + } else { + slice_ = null; + sliceBuilder_ = null; + } + + return this; + } + /** + * .fast.Slices slice = 8; + */ + public fast.Fast.Slices.Builder getSliceBuilder() { + + onChanged(); + return getSliceFieldBuilder().getBuilder(); + } + /** + * .fast.Slices slice = 8; + */ + public fast.Fast.SlicesOrBuilder getSliceOrBuilder() { + if (sliceBuilder_ != null) { + return sliceBuilder_.getMessageOrBuilder(); + } else { + return slice_ == null ? + fast.Fast.Slices.getDefaultInstance() : slice_; + } + } + /** + * .fast.Slices slice = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> + getSliceFieldBuilder() { + if (sliceBuilder_ == null) { + sliceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder>( + getSlice(), + getParentForChildren(), + isClean()); + slice_ = null; + } + return sliceBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Commit.Diff.Hunk) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Commit.Diff.Hunk) + private static final fast.Fast.Log.Commit.Diff.Hunk DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Commit.Diff.Hunk(); + } + + public static fast.Fast.Log.Commit.Diff.Hunk getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Hunk parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Hunk(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Commit.Diff.Hunk getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int A_FIELD_NUMBER = 1; + private volatile java.lang.Object a_; + /** + * string a = 1; + */ + public java.lang.String getA() { + java.lang.Object ref = a_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + a_ = s; + return s; + } + } + /** + * string a = 1; + */ + public com.google.protobuf.ByteString + getABytes() { + java.lang.Object ref = a_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + a_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int B_FIELD_NUMBER = 2; + private volatile java.lang.Object b_; + /** + * string b = 2; + */ + public java.lang.String getB() { + java.lang.Object ref = b_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + b_ = s; + return s; + } + } + /** + * string b = 2; + */ + public com.google.protobuf.ByteString + getBBytes() { + java.lang.Object ref = b_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + b_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int IS_NEW_FIELD_NUMBER = 3; + private boolean isNew_; + /** + * bool is_new = 3; + */ + public boolean getIsNew() { + return isNew_; + } + + public static final int IS_CODE_FIELD_NUMBER = 4; + private volatile java.lang.Object isCode_; + /** + * string is_code = 4; + */ + public java.lang.String getIsCode() { + java.lang.Object ref = isCode_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + isCode_ = s; + return s; + } + } + /** + * string is_code = 4; + */ + public com.google.protobuf.ByteString + getIsCodeBytes() { + java.lang.Object ref = isCode_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + isCode_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INDEX_FROM_FIELD_NUMBER = 5; + private volatile java.lang.Object indexFrom_; + /** + * string index_from = 5; + */ + public java.lang.String getIndexFrom() { + java.lang.Object ref = indexFrom_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexFrom_ = s; + return s; + } + } + /** + * string index_from = 5; + */ + public com.google.protobuf.ByteString + getIndexFromBytes() { + java.lang.Object ref = indexFrom_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexFrom_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INDEX_TO_FIELD_NUMBER = 6; + private volatile java.lang.Object indexTo_; + /** + * string index_to = 6; + */ + public java.lang.String getIndexTo() { + java.lang.Object ref = indexTo_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexTo_ = s; + return s; + } + } + /** + * string index_to = 6; + */ + public com.google.protobuf.ByteString + getIndexToBytes() { + java.lang.Object ref = indexTo_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexTo_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int MODE_FIELD_NUMBER = 7; + private volatile java.lang.Object mode_; + /** + * string mode = 7; + */ + public java.lang.String getMode() { + java.lang.Object ref = mode_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + mode_ = s; + return s; + } + } + /** + * string mode = 7; + */ + public com.google.protobuf.ByteString + getModeBytes() { + java.lang.Object ref = mode_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + mode_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int HUNK_FIELD_NUMBER = 8; + private java.util.List hunk_; + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public java.util.List getHunkList() { + return hunk_; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public java.util.List + getHunkOrBuilderList() { + return hunk_; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public int getHunkCount() { + return hunk_.size(); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.Hunk getHunk(int index) { + return hunk_.get(index); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.HunkOrBuilder getHunkOrBuilder( + int index) { + return hunk_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getABytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, a_); + } + if (!getBBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, b_); + } + if (isNew_ != false) { + output.writeBool(3, isNew_); + } + if (!getIsCodeBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, isCode_); + } + if (!getIndexFromBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 5, indexFrom_); + } + if (!getIndexToBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, indexTo_); + } + if (!getModeBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 7, mode_); + } + for (int i = 0; i < hunk_.size(); i++) { + output.writeMessage(8, hunk_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getABytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, a_); + } + if (!getBBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, b_); + } + if (isNew_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, isNew_); + } + if (!getIsCodeBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, isCode_); + } + if (!getIndexFromBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, indexFrom_); + } + if (!getIndexToBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, indexTo_); + } + if (!getModeBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(7, mode_); + } + for (int i = 0; i < hunk_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, hunk_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Commit.Diff)) { + return super.equals(obj); + } + fast.Fast.Log.Commit.Diff other = (fast.Fast.Log.Commit.Diff) obj; + + boolean result = true; + result = result && getA() + .equals(other.getA()); + result = result && getB() + .equals(other.getB()); + result = result && (getIsNew() + == other.getIsNew()); + result = result && getIsCode() + .equals(other.getIsCode()); + result = result && getIndexFrom() + .equals(other.getIndexFrom()); + result = result && getIndexTo() + .equals(other.getIndexTo()); + result = result && getMode() + .equals(other.getMode()); + result = result && getHunkList() + .equals(other.getHunkList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + getA().hashCode(); + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getB().hashCode(); + hash = (37 * hash) + IS_NEW_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsNew()); + hash = (37 * hash) + IS_CODE_FIELD_NUMBER; + hash = (53 * hash) + getIsCode().hashCode(); + hash = (37 * hash) + INDEX_FROM_FIELD_NUMBER; + hash = (53 * hash) + getIndexFrom().hashCode(); + hash = (37 * hash) + INDEX_TO_FIELD_NUMBER; + hash = (53 * hash) + getIndexTo().hashCode(); + hash = (37 * hash) + MODE_FIELD_NUMBER; + hash = (53 * hash) + getMode().hashCode(); + if (getHunkCount() > 0) { + hash = (37 * hash) + HUNK_FIELD_NUMBER; + hash = (53 * hash) + getHunkList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Commit.Diff parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit.Diff parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Commit.Diff prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Commit.Diff} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Commit.Diff) + fast.Fast.Log.Commit.DiffOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.Diff.class, fast.Fast.Log.Commit.Diff.Builder.class); + } + + // Construct using fast.Fast.Log.Commit.Diff.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getHunkFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + a_ = ""; + + b_ = ""; + + isNew_ = false; + + isCode_ = ""; + + indexFrom_ = ""; + + indexTo_ = ""; + + mode_ = ""; + + if (hunkBuilder_ == null) { + hunk_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + } else { + hunkBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Commit_Diff_descriptor; + } + + public fast.Fast.Log.Commit.Diff getDefaultInstanceForType() { + return fast.Fast.Log.Commit.Diff.getDefaultInstance(); + } + + public fast.Fast.Log.Commit.Diff build() { + fast.Fast.Log.Commit.Diff result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Commit.Diff buildPartial() { + fast.Fast.Log.Commit.Diff result = new fast.Fast.Log.Commit.Diff(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.a_ = a_; + result.b_ = b_; + result.isNew_ = isNew_; + result.isCode_ = isCode_; + result.indexFrom_ = indexFrom_; + result.indexTo_ = indexTo_; + result.mode_ = mode_; + if (hunkBuilder_ == null) { + if (((bitField0_ & 0x00000080) == 0x00000080)) { + hunk_ = java.util.Collections.unmodifiableList(hunk_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.hunk_ = hunk_; + } else { + result.hunk_ = hunkBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Commit.Diff) { + return mergeFrom((fast.Fast.Log.Commit.Diff)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Commit.Diff other) { + if (other == fast.Fast.Log.Commit.Diff.getDefaultInstance()) return this; + if (!other.getA().isEmpty()) { + a_ = other.a_; + onChanged(); + } + if (!other.getB().isEmpty()) { + b_ = other.b_; + onChanged(); + } + if (other.getIsNew() != false) { + setIsNew(other.getIsNew()); + } + if (!other.getIsCode().isEmpty()) { + isCode_ = other.isCode_; + onChanged(); + } + if (!other.getIndexFrom().isEmpty()) { + indexFrom_ = other.indexFrom_; + onChanged(); + } + if (!other.getIndexTo().isEmpty()) { + indexTo_ = other.indexTo_; + onChanged(); + } + if (!other.getMode().isEmpty()) { + mode_ = other.mode_; + onChanged(); + } + if (hunkBuilder_ == null) { + if (!other.hunk_.isEmpty()) { + if (hunk_.isEmpty()) { + hunk_ = other.hunk_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureHunkIsMutable(); + hunk_.addAll(other.hunk_); + } + onChanged(); + } + } else { + if (!other.hunk_.isEmpty()) { + if (hunkBuilder_.isEmpty()) { + hunkBuilder_.dispose(); + hunkBuilder_ = null; + hunk_ = other.hunk_; + bitField0_ = (bitField0_ & ~0x00000080); + hunkBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getHunkFieldBuilder() : null; + } else { + hunkBuilder_.addAllMessages(other.hunk_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Commit.Diff parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Commit.Diff) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object a_ = ""; + /** + * string a = 1; + */ + public java.lang.String getA() { + java.lang.Object ref = a_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + a_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string a = 1; + */ + public com.google.protobuf.ByteString + getABytes() { + java.lang.Object ref = a_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + a_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string a = 1; + */ + public Builder setA( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + a_ = value; + onChanged(); + return this; + } + /** + * string a = 1; + */ + public Builder clearA() { + + a_ = getDefaultInstance().getA(); + onChanged(); + return this; + } + /** + * string a = 1; + */ + public Builder setABytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + a_ = value; + onChanged(); + return this; + } + + private java.lang.Object b_ = ""; + /** + * string b = 2; + */ + public java.lang.String getB() { + java.lang.Object ref = b_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + b_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string b = 2; + */ + public com.google.protobuf.ByteString + getBBytes() { + java.lang.Object ref = b_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + b_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string b = 2; + */ + public Builder setB( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + b_ = value; + onChanged(); + return this; + } + /** + * string b = 2; + */ + public Builder clearB() { + + b_ = getDefaultInstance().getB(); + onChanged(); + return this; + } + /** + * string b = 2; + */ + public Builder setBBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + b_ = value; + onChanged(); + return this; + } + + private boolean isNew_ ; + /** + * bool is_new = 3; + */ + public boolean getIsNew() { + return isNew_; + } + /** + * bool is_new = 3; + */ + public Builder setIsNew(boolean value) { + + isNew_ = value; + onChanged(); + return this; + } + /** + * bool is_new = 3; + */ + public Builder clearIsNew() { + + isNew_ = false; + onChanged(); + return this; + } + + private java.lang.Object isCode_ = ""; + /** + * string is_code = 4; + */ + public java.lang.String getIsCode() { + java.lang.Object ref = isCode_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + isCode_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string is_code = 4; + */ + public com.google.protobuf.ByteString + getIsCodeBytes() { + java.lang.Object ref = isCode_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + isCode_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string is_code = 4; + */ + public Builder setIsCode( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + isCode_ = value; + onChanged(); + return this; + } + /** + * string is_code = 4; + */ + public Builder clearIsCode() { + + isCode_ = getDefaultInstance().getIsCode(); + onChanged(); + return this; + } + /** + * string is_code = 4; + */ + public Builder setIsCodeBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + isCode_ = value; + onChanged(); + return this; + } + + private java.lang.Object indexFrom_ = ""; + /** + * string index_from = 5; + */ + public java.lang.String getIndexFrom() { + java.lang.Object ref = indexFrom_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexFrom_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_from = 5; + */ + public com.google.protobuf.ByteString + getIndexFromBytes() { + java.lang.Object ref = indexFrom_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexFrom_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_from = 5; + */ + public Builder setIndexFrom( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + indexFrom_ = value; + onChanged(); + return this; + } + /** + * string index_from = 5; + */ + public Builder clearIndexFrom() { + + indexFrom_ = getDefaultInstance().getIndexFrom(); + onChanged(); + return this; + } + /** + * string index_from = 5; + */ + public Builder setIndexFromBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + indexFrom_ = value; + onChanged(); + return this; + } + + private java.lang.Object indexTo_ = ""; + /** + * string index_to = 6; + */ + public java.lang.String getIndexTo() { + java.lang.Object ref = indexTo_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexTo_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_to = 6; + */ + public com.google.protobuf.ByteString + getIndexToBytes() { + java.lang.Object ref = indexTo_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexTo_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_to = 6; + */ + public Builder setIndexTo( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + indexTo_ = value; + onChanged(); + return this; + } + /** + * string index_to = 6; + */ + public Builder clearIndexTo() { + + indexTo_ = getDefaultInstance().getIndexTo(); + onChanged(); + return this; + } + /** + * string index_to = 6; + */ + public Builder setIndexToBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + indexTo_ = value; + onChanged(); + return this; + } + + private java.lang.Object mode_ = ""; + /** + * string mode = 7; + */ + public java.lang.String getMode() { + java.lang.Object ref = mode_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + mode_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string mode = 7; + */ + public com.google.protobuf.ByteString + getModeBytes() { + java.lang.Object ref = mode_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + mode_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string mode = 7; + */ + public Builder setMode( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + mode_ = value; + onChanged(); + return this; + } + /** + * string mode = 7; + */ + public Builder clearMode() { + + mode_ = getDefaultInstance().getMode(); + onChanged(); + return this; + } + /** + * string mode = 7; + */ + public Builder setModeBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + mode_ = value; + onChanged(); + return this; + } + + private java.util.List hunk_ = + java.util.Collections.emptyList(); + private void ensureHunkIsMutable() { + if (!((bitField0_ & 0x00000080) == 0x00000080)) { + hunk_ = new java.util.ArrayList(hunk_); + bitField0_ |= 0x00000080; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk, fast.Fast.Log.Commit.Diff.Hunk.Builder, fast.Fast.Log.Commit.Diff.HunkOrBuilder> hunkBuilder_; + + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public java.util.List getHunkList() { + if (hunkBuilder_ == null) { + return java.util.Collections.unmodifiableList(hunk_); + } else { + return hunkBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public int getHunkCount() { + if (hunkBuilder_ == null) { + return hunk_.size(); + } else { + return hunkBuilder_.getCount(); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.Hunk getHunk(int index) { + if (hunkBuilder_ == null) { + return hunk_.get(index); + } else { + return hunkBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder setHunk( + int index, fast.Fast.Log.Commit.Diff.Hunk value) { + if (hunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureHunkIsMutable(); + hunk_.set(index, value); + onChanged(); + } else { + hunkBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder setHunk( + int index, fast.Fast.Log.Commit.Diff.Hunk.Builder builderForValue) { + if (hunkBuilder_ == null) { + ensureHunkIsMutable(); + hunk_.set(index, builderForValue.build()); + onChanged(); + } else { + hunkBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder addHunk(fast.Fast.Log.Commit.Diff.Hunk value) { + if (hunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureHunkIsMutable(); + hunk_.add(value); + onChanged(); + } else { + hunkBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder addHunk( + int index, fast.Fast.Log.Commit.Diff.Hunk value) { + if (hunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureHunkIsMutable(); + hunk_.add(index, value); + onChanged(); + } else { + hunkBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder addHunk( + fast.Fast.Log.Commit.Diff.Hunk.Builder builderForValue) { + if (hunkBuilder_ == null) { + ensureHunkIsMutable(); + hunk_.add(builderForValue.build()); + onChanged(); + } else { + hunkBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder addHunk( + int index, fast.Fast.Log.Commit.Diff.Hunk.Builder builderForValue) { + if (hunkBuilder_ == null) { + ensureHunkIsMutable(); + hunk_.add(index, builderForValue.build()); + onChanged(); + } else { + hunkBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder addAllHunk( + java.lang.Iterable values) { + if (hunkBuilder_ == null) { + ensureHunkIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, hunk_); + onChanged(); + } else { + hunkBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder clearHunk() { + if (hunkBuilder_ == null) { + hunk_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + onChanged(); + } else { + hunkBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public Builder removeHunk(int index) { + if (hunkBuilder_ == null) { + ensureHunkIsMutable(); + hunk_.remove(index); + onChanged(); + } else { + hunkBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.Hunk.Builder getHunkBuilder( + int index) { + return getHunkFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.HunkOrBuilder getHunkOrBuilder( + int index) { + if (hunkBuilder_ == null) { + return hunk_.get(index); } else { + return hunkBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public java.util.List + getHunkOrBuilderList() { + if (hunkBuilder_ != null) { + return hunkBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(hunk_); + } + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.Hunk.Builder addHunkBuilder() { + return getHunkFieldBuilder().addBuilder( + fast.Fast.Log.Commit.Diff.Hunk.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public fast.Fast.Log.Commit.Diff.Hunk.Builder addHunkBuilder( + int index) { + return getHunkFieldBuilder().addBuilder( + index, fast.Fast.Log.Commit.Diff.Hunk.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff.Hunk hunk = 8; + */ + public java.util.List + getHunkBuilderList() { + return getHunkFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk, fast.Fast.Log.Commit.Diff.Hunk.Builder, fast.Fast.Log.Commit.Diff.HunkOrBuilder> + getHunkFieldBuilder() { + if (hunkBuilder_ == null) { + hunkBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff.Hunk, fast.Fast.Log.Commit.Diff.Hunk.Builder, fast.Fast.Log.Commit.Diff.HunkOrBuilder>( + hunk_, + ((bitField0_ & 0x00000080) == 0x00000080), + getParentForChildren(), + isClean()); + hunk_ = null; + } + return hunkBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Commit.Diff) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Commit.Diff) + private static final fast.Fast.Log.Commit.Diff DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Commit.Diff(); + } + + public static fast.Fast.Log.Commit.Diff getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Diff parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Diff(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Commit.Diff getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + private int extraCase_ = 0; + private java.lang.Object extra_; + public enum ExtraCase + implements com.google.protobuf.Internal.EnumLite { + COMMITTER(5), + EXTRA_NOT_SET(0); + private final int value; + private ExtraCase(int value) { + this.value = value; + } + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ExtraCase valueOf(int value) { + return forNumber(value); + } + + public static ExtraCase forNumber(int value) { + switch (value) { + case 5: return COMMITTER; + case 0: return EXTRA_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public ExtraCase + getExtraCase() { + return ExtraCase.forNumber( + extraCase_); + } + + public static final int ID_FIELD_NUMBER = 1; + private volatile java.lang.Object id_; + /** + * string id = 1; + */ + public java.lang.String getId() { + java.lang.Object ref = id_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + id_ = s; + return s; + } + } + /** + * string id = 1; + */ + public com.google.protobuf.ByteString + getIdBytes() { + java.lang.Object ref = id_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + id_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TEXT_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString text_; + /** + * bytes text = 2; + */ + public com.google.protobuf.ByteString getText() { + return text_; + } + + public static final int AUTHOR_ID_FIELD_NUMBER = 3; + private int authorId_; + /** + * int32 author_id = 3; + */ + public int getAuthorId() { + return authorId_; + } + + public static final int AUTHOR_DATE_FIELD_NUMBER = 4; + private volatile java.lang.Object authorDate_; + /** + * string author_date = 4; + */ + public java.lang.String getAuthorDate() { + java.lang.Object ref = authorDate_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + authorDate_ = s; + return s; + } + } + /** + * string author_date = 4; + */ + public com.google.protobuf.ByteString + getAuthorDateBytes() { + java.lang.Object ref = authorDate_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + authorDate_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int COMMITTER_FIELD_NUMBER = 5; + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public fast.Fast.Log.Commit.Committer getCommitter() { + if (extraCase_ == 5) { + return (fast.Fast.Log.Commit.Committer) extra_; + } + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public fast.Fast.Log.Commit.CommitterOrBuilder getCommitterOrBuilder() { + if (extraCase_ == 5) { + return (fast.Fast.Log.Commit.Committer) extra_; + } + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + + public static final int DIFF_FIELD_NUMBER = 6; + private java.util.List diff_; + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public java.util.List getDiffList() { + return diff_; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public java.util.List + getDiffOrBuilderList() { + return diff_; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public int getDiffCount() { + return diff_.size(); + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.Diff getDiff(int index) { + return diff_.get(index); + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.DiffOrBuilder getDiffOrBuilder( + int index) { + return diff_.get(index); + } + + public static final int SLICE_FIELD_NUMBER = 7; + private fast.Fast.Slices slice_; + /** + * .fast.Slices slice = 7; + */ + public boolean hasSlice() { + return slice_ != null; + } + /** + * .fast.Slices slice = 7; + */ + public fast.Fast.Slices getSlice() { + return slice_ == null ? fast.Fast.Slices.getDefaultInstance() : slice_; + } + /** + * .fast.Slices slice = 7; + */ + public fast.Fast.SlicesOrBuilder getSliceOrBuilder() { + return getSlice(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getIdBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, id_); + } + if (!text_.isEmpty()) { + output.writeBytes(2, text_); + } + if (authorId_ != 0) { + output.writeInt32(3, authorId_); + } + if (!getAuthorDateBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, authorDate_); + } + if (extraCase_ == 5) { + output.writeMessage(5, (fast.Fast.Log.Commit.Committer) extra_); + } + for (int i = 0; i < diff_.size(); i++) { + output.writeMessage(6, diff_.get(i)); + } + if (slice_ != null) { + output.writeMessage(7, getSlice()); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getIdBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, id_); + } + if (!text_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, text_); + } + if (authorId_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, authorId_); + } + if (!getAuthorDateBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, authorDate_); + } + if (extraCase_ == 5) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, (fast.Fast.Log.Commit.Committer) extra_); + } + for (int i = 0; i < diff_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, diff_.get(i)); + } + if (slice_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getSlice()); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Commit)) { + return super.equals(obj); + } + fast.Fast.Log.Commit other = (fast.Fast.Log.Commit) obj; + + boolean result = true; + result = result && getId() + .equals(other.getId()); + result = result && getText() + .equals(other.getText()); + result = result && (getAuthorId() + == other.getAuthorId()); + result = result && getAuthorDate() + .equals(other.getAuthorDate()); + result = result && getDiffList() + .equals(other.getDiffList()); + result = result && (hasSlice() == other.hasSlice()); + if (hasSlice()) { + result = result && getSlice() + .equals(other.getSlice()); + } + result = result && getExtraCase().equals( + other.getExtraCase()); + if (!result) return false; + switch (extraCase_) { + case 5: + result = result && getCommitter() + .equals(other.getCommitter()); + break; + case 0: + default: + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + ID_FIELD_NUMBER; + hash = (53 * hash) + getId().hashCode(); + hash = (37 * hash) + TEXT_FIELD_NUMBER; + hash = (53 * hash) + getText().hashCode(); + hash = (37 * hash) + AUTHOR_ID_FIELD_NUMBER; + hash = (53 * hash) + getAuthorId(); + hash = (37 * hash) + AUTHOR_DATE_FIELD_NUMBER; + hash = (53 * hash) + getAuthorDate().hashCode(); + if (getDiffCount() > 0) { + hash = (37 * hash) + DIFF_FIELD_NUMBER; + hash = (53 * hash) + getDiffList().hashCode(); + } + if (hasSlice()) { + hash = (37 * hash) + SLICE_FIELD_NUMBER; + hash = (53 * hash) + getSlice().hashCode(); + } + switch (extraCase_) { + case 5: + hash = (37 * hash) + COMMITTER_FIELD_NUMBER; + hash = (53 * hash) + getCommitter().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Commit parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Commit parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Commit parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Commit parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Commit parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Commit prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Commit} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Commit) + fast.Fast.Log.CommitOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Commit_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Commit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Commit.class, fast.Fast.Log.Commit.Builder.class); + } + + // Construct using fast.Fast.Log.Commit.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getDiffFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + id_ = ""; + + text_ = com.google.protobuf.ByteString.EMPTY; + + authorId_ = 0; + + authorDate_ = ""; + + if (diffBuilder_ == null) { + diff_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + } else { + diffBuilder_.clear(); + } + if (sliceBuilder_ == null) { + slice_ = null; + } else { + slice_ = null; + sliceBuilder_ = null; + } + extraCase_ = 0; + extra_ = null; + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Commit_descriptor; + } + + public fast.Fast.Log.Commit getDefaultInstanceForType() { + return fast.Fast.Log.Commit.getDefaultInstance(); + } + + public fast.Fast.Log.Commit build() { + fast.Fast.Log.Commit result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Commit buildPartial() { + fast.Fast.Log.Commit result = new fast.Fast.Log.Commit(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.id_ = id_; + result.text_ = text_; + result.authorId_ = authorId_; + result.authorDate_ = authorDate_; + if (extraCase_ == 5) { + if (committerBuilder_ == null) { + result.extra_ = extra_; + } else { + result.extra_ = committerBuilder_.build(); + } + } + if (diffBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020)) { + diff_ = java.util.Collections.unmodifiableList(diff_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.diff_ = diff_; + } else { + result.diff_ = diffBuilder_.build(); + } + if (sliceBuilder_ == null) { + result.slice_ = slice_; + } else { + result.slice_ = sliceBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + result.extraCase_ = extraCase_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Commit) { + return mergeFrom((fast.Fast.Log.Commit)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Commit other) { + if (other == fast.Fast.Log.Commit.getDefaultInstance()) return this; + if (!other.getId().isEmpty()) { + id_ = other.id_; + onChanged(); + } + if (other.getText() != com.google.protobuf.ByteString.EMPTY) { + setText(other.getText()); + } + if (other.getAuthorId() != 0) { + setAuthorId(other.getAuthorId()); + } + if (!other.getAuthorDate().isEmpty()) { + authorDate_ = other.authorDate_; + onChanged(); + } + if (diffBuilder_ == null) { + if (!other.diff_.isEmpty()) { + if (diff_.isEmpty()) { + diff_ = other.diff_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureDiffIsMutable(); + diff_.addAll(other.diff_); + } + onChanged(); + } + } else { + if (!other.diff_.isEmpty()) { + if (diffBuilder_.isEmpty()) { + diffBuilder_.dispose(); + diffBuilder_ = null; + diff_ = other.diff_; + bitField0_ = (bitField0_ & ~0x00000020); + diffBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getDiffFieldBuilder() : null; + } else { + diffBuilder_.addAllMessages(other.diff_); + } + } + } + if (other.hasSlice()) { + mergeSlice(other.getSlice()); + } + switch (other.getExtraCase()) { + case COMMITTER: { + mergeCommitter(other.getCommitter()); + break; + } + case EXTRA_NOT_SET: { + break; + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Commit parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Commit) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int extraCase_ = 0; + private java.lang.Object extra_; + public ExtraCase + getExtraCase() { + return ExtraCase.forNumber( + extraCase_); + } + + public Builder clearExtra() { + extraCase_ = 0; + extra_ = null; + onChanged(); + return this; + } + + private int bitField0_; + + private java.lang.Object id_ = ""; + /** + * string id = 1; + */ + public java.lang.String getId() { + java.lang.Object ref = id_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + id_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string id = 1; + */ + public com.google.protobuf.ByteString + getIdBytes() { + java.lang.Object ref = id_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + id_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string id = 1; + */ + public Builder setId( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + id_ = value; + onChanged(); + return this; + } + /** + * string id = 1; + */ + public Builder clearId() { + + id_ = getDefaultInstance().getId(); + onChanged(); + return this; + } + /** + * string id = 1; + */ + public Builder setIdBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + id_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString text_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes text = 2; + */ + public com.google.protobuf.ByteString getText() { + return text_; + } + /** + * bytes text = 2; + */ + public Builder setText(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + text_ = value; + onChanged(); + return this; + } + /** + * bytes text = 2; + */ + public Builder clearText() { + + text_ = getDefaultInstance().getText(); + onChanged(); + return this; + } + + private int authorId_ ; + /** + * int32 author_id = 3; + */ + public int getAuthorId() { + return authorId_; + } + /** + * int32 author_id = 3; + */ + public Builder setAuthorId(int value) { + + authorId_ = value; + onChanged(); + return this; + } + /** + * int32 author_id = 3; + */ + public Builder clearAuthorId() { + + authorId_ = 0; + onChanged(); + return this; + } + + private java.lang.Object authorDate_ = ""; + /** + * string author_date = 4; + */ + public java.lang.String getAuthorDate() { + java.lang.Object ref = authorDate_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + authorDate_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string author_date = 4; + */ + public com.google.protobuf.ByteString + getAuthorDateBytes() { + java.lang.Object ref = authorDate_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + authorDate_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string author_date = 4; + */ + public Builder setAuthorDate( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + authorDate_ = value; + onChanged(); + return this; + } + /** + * string author_date = 4; + */ + public Builder clearAuthorDate() { + + authorDate_ = getDefaultInstance().getAuthorDate(); + onChanged(); + return this; + } + /** + * string author_date = 4; + */ + public Builder setAuthorDateBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + authorDate_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log.Commit.Committer, fast.Fast.Log.Commit.Committer.Builder, fast.Fast.Log.Commit.CommitterOrBuilder> committerBuilder_; + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public fast.Fast.Log.Commit.Committer getCommitter() { + if (committerBuilder_ == null) { + if (extraCase_ == 5) { + return (fast.Fast.Log.Commit.Committer) extra_; + } + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } else { + if (extraCase_ == 5) { + return committerBuilder_.getMessage(); + } + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public Builder setCommitter(fast.Fast.Log.Commit.Committer value) { + if (committerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + extra_ = value; + onChanged(); + } else { + committerBuilder_.setMessage(value); + } + extraCase_ = 5; + return this; + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public Builder setCommitter( + fast.Fast.Log.Commit.Committer.Builder builderForValue) { + if (committerBuilder_ == null) { + extra_ = builderForValue.build(); + onChanged(); + } else { + committerBuilder_.setMessage(builderForValue.build()); + } + extraCase_ = 5; + return this; + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public Builder mergeCommitter(fast.Fast.Log.Commit.Committer value) { + if (committerBuilder_ == null) { + if (extraCase_ == 5 && + extra_ != fast.Fast.Log.Commit.Committer.getDefaultInstance()) { + extra_ = fast.Fast.Log.Commit.Committer.newBuilder((fast.Fast.Log.Commit.Committer) extra_) + .mergeFrom(value).buildPartial(); + } else { + extra_ = value; + } + onChanged(); + } else { + if (extraCase_ == 5) { + committerBuilder_.mergeFrom(value); + } + committerBuilder_.setMessage(value); + } + extraCase_ = 5; + return this; + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public Builder clearCommitter() { + if (committerBuilder_ == null) { + if (extraCase_ == 5) { + extraCase_ = 0; + extra_ = null; + onChanged(); + } + } else { + if (extraCase_ == 5) { + extraCase_ = 0; + extra_ = null; + } + committerBuilder_.clear(); + } + return this; + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public fast.Fast.Log.Commit.Committer.Builder getCommitterBuilder() { + return getCommitterFieldBuilder().getBuilder(); + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + public fast.Fast.Log.Commit.CommitterOrBuilder getCommitterOrBuilder() { + if ((extraCase_ == 5) && (committerBuilder_ != null)) { + return committerBuilder_.getMessageOrBuilder(); + } else { + if (extraCase_ == 5) { + return (fast.Fast.Log.Commit.Committer) extra_; + } + return fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + } + /** + * .fast.Log.Commit.Committer committer = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log.Commit.Committer, fast.Fast.Log.Commit.Committer.Builder, fast.Fast.Log.Commit.CommitterOrBuilder> + getCommitterFieldBuilder() { + if (committerBuilder_ == null) { + if (!(extraCase_ == 5)) { + extra_ = fast.Fast.Log.Commit.Committer.getDefaultInstance(); + } + committerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log.Commit.Committer, fast.Fast.Log.Commit.Committer.Builder, fast.Fast.Log.Commit.CommitterOrBuilder>( + (fast.Fast.Log.Commit.Committer) extra_, + getParentForChildren(), + isClean()); + extra_ = null; + } + extraCase_ = 5; + onChanged();; + return committerBuilder_; + } + + private java.util.List diff_ = + java.util.Collections.emptyList(); + private void ensureDiffIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + diff_ = new java.util.ArrayList(diff_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff, fast.Fast.Log.Commit.Diff.Builder, fast.Fast.Log.Commit.DiffOrBuilder> diffBuilder_; + + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public java.util.List getDiffList() { + if (diffBuilder_ == null) { + return java.util.Collections.unmodifiableList(diff_); + } else { + return diffBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public int getDiffCount() { + if (diffBuilder_ == null) { + return diff_.size(); + } else { + return diffBuilder_.getCount(); + } + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.Diff getDiff(int index) { + if (diffBuilder_ == null) { + return diff_.get(index); + } else { + return diffBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder setDiff( + int index, fast.Fast.Log.Commit.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.set(index, value); + onChanged(); + } else { + diffBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder setDiff( + int index, fast.Fast.Log.Commit.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.set(index, builderForValue.build()); + onChanged(); + } else { + diffBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder addDiff(fast.Fast.Log.Commit.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.add(value); + onChanged(); + } else { + diffBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder addDiff( + int index, fast.Fast.Log.Commit.Diff value) { + if (diffBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDiffIsMutable(); + diff_.add(index, value); + onChanged(); + } else { + diffBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder addDiff( + fast.Fast.Log.Commit.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.add(builderForValue.build()); + onChanged(); + } else { + diffBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder addDiff( + int index, fast.Fast.Log.Commit.Diff.Builder builderForValue) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.add(index, builderForValue.build()); + onChanged(); + } else { + diffBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder addAllDiff( + java.lang.Iterable values) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, diff_); + onChanged(); + } else { + diffBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder clearDiff() { + if (diffBuilder_ == null) { + diff_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + diffBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public Builder removeDiff(int index) { + if (diffBuilder_ == null) { + ensureDiffIsMutable(); + diff_.remove(index); + onChanged(); + } else { + diffBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.Diff.Builder getDiffBuilder( + int index) { + return getDiffFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.DiffOrBuilder getDiffOrBuilder( + int index) { + if (diffBuilder_ == null) { + return diff_.get(index); } else { + return diffBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public java.util.List + getDiffOrBuilderList() { + if (diffBuilder_ != null) { + return diffBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(diff_); + } + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.Diff.Builder addDiffBuilder() { + return getDiffFieldBuilder().addBuilder( + fast.Fast.Log.Commit.Diff.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public fast.Fast.Log.Commit.Diff.Builder addDiffBuilder( + int index) { + return getDiffFieldBuilder().addBuilder( + index, fast.Fast.Log.Commit.Diff.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit.Diff diff = 6; + */ + public java.util.List + getDiffBuilderList() { + return getDiffFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff, fast.Fast.Log.Commit.Diff.Builder, fast.Fast.Log.Commit.DiffOrBuilder> + getDiffFieldBuilder() { + if (diffBuilder_ == null) { + diffBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit.Diff, fast.Fast.Log.Commit.Diff.Builder, fast.Fast.Log.Commit.DiffOrBuilder>( + diff_, + ((bitField0_ & 0x00000020) == 0x00000020), + getParentForChildren(), + isClean()); + diff_ = null; + } + return diffBuilder_; + } + + private fast.Fast.Slices slice_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> sliceBuilder_; + /** + * .fast.Slices slice = 7; + */ + public boolean hasSlice() { + return sliceBuilder_ != null || slice_ != null; + } + /** + * .fast.Slices slice = 7; + */ + public fast.Fast.Slices getSlice() { + if (sliceBuilder_ == null) { + return slice_ == null ? fast.Fast.Slices.getDefaultInstance() : slice_; + } else { + return sliceBuilder_.getMessage(); + } + } + /** + * .fast.Slices slice = 7; + */ + public Builder setSlice(fast.Fast.Slices value) { + if (sliceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + slice_ = value; + onChanged(); + } else { + sliceBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Slices slice = 7; + */ + public Builder setSlice( + fast.Fast.Slices.Builder builderForValue) { + if (sliceBuilder_ == null) { + slice_ = builderForValue.build(); + onChanged(); + } else { + sliceBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Slices slice = 7; + */ + public Builder mergeSlice(fast.Fast.Slices value) { + if (sliceBuilder_ == null) { + if (slice_ != null) { + slice_ = + fast.Fast.Slices.newBuilder(slice_).mergeFrom(value).buildPartial(); + } else { + slice_ = value; + } + onChanged(); + } else { + sliceBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Slices slice = 7; + */ + public Builder clearSlice() { + if (sliceBuilder_ == null) { + slice_ = null; + onChanged(); + } else { + slice_ = null; + sliceBuilder_ = null; + } + + return this; + } + /** + * .fast.Slices slice = 7; + */ + public fast.Fast.Slices.Builder getSliceBuilder() { + + onChanged(); + return getSliceFieldBuilder().getBuilder(); + } + /** + * .fast.Slices slice = 7; + */ + public fast.Fast.SlicesOrBuilder getSliceOrBuilder() { + if (sliceBuilder_ != null) { + return sliceBuilder_.getMessageOrBuilder(); + } else { + return slice_ == null ? + fast.Fast.Slices.getDefaultInstance() : slice_; + } + } + /** + * .fast.Slices slice = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> + getSliceFieldBuilder() { + if (sliceBuilder_ == null) { + sliceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder>( + getSlice(), + getParentForChildren(), + isClean()); + slice_ = null; + } + return sliceBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Commit) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Commit) + private static final fast.Fast.Log.Commit DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Commit(); + } + + public static fast.Fast.Log.Commit getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Commit parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Commit(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Commit getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface AuthorOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Log.Author) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 id = 1; + */ + int getId(); + + /** + * string name = 2; + */ + java.lang.String getName(); + /** + * string name = 2; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * string email = 3; + */ + java.lang.String getEmail(); + /** + * string email = 3; + */ + com.google.protobuf.ByteString + getEmailBytes(); + } + /** + * Protobuf type {@code fast.Log.Author} + */ + public static final class Author extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Log.Author) + AuthorOrBuilder { + // Use Author.newBuilder() to construct. + private Author(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Author() { + id_ = 0; + name_ = ""; + email_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Author( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + id_ = input.readInt32(); + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 26: { + java.lang.String s = input.readStringRequireUtf8(); + + email_ = s; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Author_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Author_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Author.class, fast.Fast.Log.Author.Builder.class); + } + + public static final int ID_FIELD_NUMBER = 1; + private int id_; + /** + * int32 id = 1; + */ + public int getId() { + return id_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private volatile java.lang.Object name_; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int EMAIL_FIELD_NUMBER = 3; + private volatile java.lang.Object email_; + /** + * string email = 3; + */ + public java.lang.String getEmail() { + java.lang.Object ref = email_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + email_ = s; + return s; + } + } + /** + * string email = 3; + */ + public com.google.protobuf.ByteString + getEmailBytes() { + java.lang.Object ref = email_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + email_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (id_ != 0) { + output.writeInt32(1, id_); + } + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, name_); + } + if (!getEmailBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, email_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (id_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, id_); + } + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, name_); + } + if (!getEmailBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, email_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log.Author)) { + return super.equals(obj); + } + fast.Fast.Log.Author other = (fast.Fast.Log.Author) obj; + + boolean result = true; + result = result && (getId() + == other.getId()); + result = result && getName() + .equals(other.getName()); + result = result && getEmail() + .equals(other.getEmail()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + ID_FIELD_NUMBER; + hash = (53 * hash) + getId(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + EMAIL_FIELD_NUMBER; + hash = (53 * hash) + getEmail().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log.Author parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Author parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Author parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Author parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Author parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log.Author parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log.Author parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Author parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Author parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log.Author parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log.Author parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log.Author parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log.Author prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log.Author} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log.Author) + fast.Fast.Log.AuthorOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_Author_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_Author_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.Author.class, fast.Fast.Log.Author.Builder.class); + } + + // Construct using fast.Fast.Log.Author.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + id_ = 0; + + name_ = ""; + + email_ = ""; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_Author_descriptor; + } + + public fast.Fast.Log.Author getDefaultInstanceForType() { + return fast.Fast.Log.Author.getDefaultInstance(); + } + + public fast.Fast.Log.Author build() { + fast.Fast.Log.Author result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log.Author buildPartial() { + fast.Fast.Log.Author result = new fast.Fast.Log.Author(this); + result.id_ = id_; + result.name_ = name_; + result.email_ = email_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log.Author) { + return mergeFrom((fast.Fast.Log.Author)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log.Author other) { + if (other == fast.Fast.Log.Author.getDefaultInstance()) return this; + if (other.getId() != 0) { + setId(other.getId()); + } + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (!other.getEmail().isEmpty()) { + email_ = other.email_; + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log.Author parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log.Author) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int id_ ; + /** + * int32 id = 1; + */ + public int getId() { + return id_; + } + /** + * int32 id = 1; + */ + public Builder setId(int value) { + + id_ = value; + onChanged(); + return this; + } + /** + * int32 id = 1; + */ + public Builder clearId() { + + id_ = 0; + onChanged(); + return this; + } + + private java.lang.Object name_ = ""; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private java.lang.Object email_ = ""; + /** + * string email = 3; + */ + public java.lang.String getEmail() { + java.lang.Object ref = email_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + email_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string email = 3; + */ + public com.google.protobuf.ByteString + getEmailBytes() { + java.lang.Object ref = email_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + email_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string email = 3; + */ + public Builder setEmail( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + email_ = value; + onChanged(); + return this; + } + /** + * string email = 3; + */ + public Builder clearEmail() { + + email_ = getDefaultInstance().getEmail(); + onChanged(); + return this; + } + /** + * string email = 3; + */ + public Builder setEmailBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + email_ = value; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log.Author) + } + + // @@protoc_insertion_point(class_scope:fast.Log.Author) + private static final fast.Fast.Log.Author DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log.Author(); + } + + public static fast.Fast.Log.Author getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Author parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Author(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log.Author getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int COMMIT_FIELD_NUMBER = 1; + private java.util.List commit_; + /** + * repeated .fast.Log.Commit commit = 1; + */ + public java.util.List getCommitList() { + return commit_; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public java.util.List + getCommitOrBuilderList() { + return commit_; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public int getCommitCount() { + return commit_.size(); + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.Commit getCommit(int index) { + return commit_.get(index); + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.CommitOrBuilder getCommitOrBuilder( + int index) { + return commit_.get(index); + } + + public static final int AUTHOR_FIELD_NUMBER = 2; + private java.util.List author_; + /** + * repeated .fast.Log.Author author = 2; + */ + public java.util.List getAuthorList() { + return author_; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public java.util.List + getAuthorOrBuilderList() { + return author_; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public int getAuthorCount() { + return author_.size(); + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.Author getAuthor(int index) { + return author_.get(index); + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.AuthorOrBuilder getAuthorOrBuilder( + int index) { + return author_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < commit_.size(); i++) { + output.writeMessage(1, commit_.get(i)); + } + for (int i = 0; i < author_.size(); i++) { + output.writeMessage(2, author_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < commit_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, commit_.get(i)); + } + for (int i = 0; i < author_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, author_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Log)) { + return super.equals(obj); + } + fast.Fast.Log other = (fast.Fast.Log) obj; + + boolean result = true; + result = result && getCommitList() + .equals(other.getCommitList()); + result = result && getAuthorList() + .equals(other.getAuthorList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getCommitCount() > 0) { + hash = (37 * hash) + COMMIT_FIELD_NUMBER; + hash = (53 * hash) + getCommitList().hashCode(); + } + if (getAuthorCount() > 0) { + hash = (37 * hash) + AUTHOR_FIELD_NUMBER; + hash = (53 * hash) + getAuthorList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Log parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Log parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Log parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Log parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Log parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Log parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Log prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Log} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Log) + fast.Fast.LogOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Log_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Log_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Log.class, fast.Fast.Log.Builder.class); + } + + // Construct using fast.Fast.Log.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCommitFieldBuilder(); + getAuthorFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (commitBuilder_ == null) { + commit_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + commitBuilder_.clear(); + } + if (authorBuilder_ == null) { + author_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + authorBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Log_descriptor; + } + + public fast.Fast.Log getDefaultInstanceForType() { + return fast.Fast.Log.getDefaultInstance(); + } + + public fast.Fast.Log build() { + fast.Fast.Log result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Log buildPartial() { + fast.Fast.Log result = new fast.Fast.Log(this); + int from_bitField0_ = bitField0_; + if (commitBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + commit_ = java.util.Collections.unmodifiableList(commit_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.commit_ = commit_; + } else { + result.commit_ = commitBuilder_.build(); + } + if (authorBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002)) { + author_ = java.util.Collections.unmodifiableList(author_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.author_ = author_; + } else { + result.author_ = authorBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Log) { + return mergeFrom((fast.Fast.Log)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Log other) { + if (other == fast.Fast.Log.getDefaultInstance()) return this; + if (commitBuilder_ == null) { + if (!other.commit_.isEmpty()) { + if (commit_.isEmpty()) { + commit_ = other.commit_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureCommitIsMutable(); + commit_.addAll(other.commit_); + } + onChanged(); + } + } else { + if (!other.commit_.isEmpty()) { + if (commitBuilder_.isEmpty()) { + commitBuilder_.dispose(); + commitBuilder_ = null; + commit_ = other.commit_; + bitField0_ = (bitField0_ & ~0x00000001); + commitBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getCommitFieldBuilder() : null; + } else { + commitBuilder_.addAllMessages(other.commit_); + } + } + } + if (authorBuilder_ == null) { + if (!other.author_.isEmpty()) { + if (author_.isEmpty()) { + author_ = other.author_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureAuthorIsMutable(); + author_.addAll(other.author_); + } + onChanged(); + } + } else { + if (!other.author_.isEmpty()) { + if (authorBuilder_.isEmpty()) { + authorBuilder_.dispose(); + authorBuilder_ = null; + author_ = other.author_; + bitField0_ = (bitField0_ & ~0x00000002); + authorBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getAuthorFieldBuilder() : null; + } else { + authorBuilder_.addAllMessages(other.author_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Log parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Log) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List commit_ = + java.util.Collections.emptyList(); + private void ensureCommitIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + commit_ = new java.util.ArrayList(commit_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit, fast.Fast.Log.Commit.Builder, fast.Fast.Log.CommitOrBuilder> commitBuilder_; + + /** + * repeated .fast.Log.Commit commit = 1; + */ + public java.util.List getCommitList() { + if (commitBuilder_ == null) { + return java.util.Collections.unmodifiableList(commit_); + } else { + return commitBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public int getCommitCount() { + if (commitBuilder_ == null) { + return commit_.size(); + } else { + return commitBuilder_.getCount(); + } + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.Commit getCommit(int index) { + if (commitBuilder_ == null) { + return commit_.get(index); + } else { + return commitBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder setCommit( + int index, fast.Fast.Log.Commit value) { + if (commitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCommitIsMutable(); + commit_.set(index, value); + onChanged(); + } else { + commitBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder setCommit( + int index, fast.Fast.Log.Commit.Builder builderForValue) { + if (commitBuilder_ == null) { + ensureCommitIsMutable(); + commit_.set(index, builderForValue.build()); + onChanged(); + } else { + commitBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder addCommit(fast.Fast.Log.Commit value) { + if (commitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCommitIsMutable(); + commit_.add(value); + onChanged(); + } else { + commitBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder addCommit( + int index, fast.Fast.Log.Commit value) { + if (commitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCommitIsMutable(); + commit_.add(index, value); + onChanged(); + } else { + commitBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder addCommit( + fast.Fast.Log.Commit.Builder builderForValue) { + if (commitBuilder_ == null) { + ensureCommitIsMutable(); + commit_.add(builderForValue.build()); + onChanged(); + } else { + commitBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder addCommit( + int index, fast.Fast.Log.Commit.Builder builderForValue) { + if (commitBuilder_ == null) { + ensureCommitIsMutable(); + commit_.add(index, builderForValue.build()); + onChanged(); + } else { + commitBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder addAllCommit( + java.lang.Iterable values) { + if (commitBuilder_ == null) { + ensureCommitIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, commit_); + onChanged(); + } else { + commitBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder clearCommit() { + if (commitBuilder_ == null) { + commit_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + commitBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public Builder removeCommit(int index) { + if (commitBuilder_ == null) { + ensureCommitIsMutable(); + commit_.remove(index); + onChanged(); + } else { + commitBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.Commit.Builder getCommitBuilder( + int index) { + return getCommitFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.CommitOrBuilder getCommitOrBuilder( + int index) { + if (commitBuilder_ == null) { + return commit_.get(index); } else { + return commitBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public java.util.List + getCommitOrBuilderList() { + if (commitBuilder_ != null) { + return commitBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(commit_); + } + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.Commit.Builder addCommitBuilder() { + return getCommitFieldBuilder().addBuilder( + fast.Fast.Log.Commit.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public fast.Fast.Log.Commit.Builder addCommitBuilder( + int index) { + return getCommitFieldBuilder().addBuilder( + index, fast.Fast.Log.Commit.getDefaultInstance()); + } + /** + * repeated .fast.Log.Commit commit = 1; + */ + public java.util.List + getCommitBuilderList() { + return getCommitFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit, fast.Fast.Log.Commit.Builder, fast.Fast.Log.CommitOrBuilder> + getCommitFieldBuilder() { + if (commitBuilder_ == null) { + commitBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Commit, fast.Fast.Log.Commit.Builder, fast.Fast.Log.CommitOrBuilder>( + commit_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + commit_ = null; + } + return commitBuilder_; + } + + private java.util.List author_ = + java.util.Collections.emptyList(); + private void ensureAuthorIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + author_ = new java.util.ArrayList(author_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Author, fast.Fast.Log.Author.Builder, fast.Fast.Log.AuthorOrBuilder> authorBuilder_; + + /** + * repeated .fast.Log.Author author = 2; + */ + public java.util.List getAuthorList() { + if (authorBuilder_ == null) { + return java.util.Collections.unmodifiableList(author_); + } else { + return authorBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Log.Author author = 2; + */ + public int getAuthorCount() { + if (authorBuilder_ == null) { + return author_.size(); + } else { + return authorBuilder_.getCount(); + } + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.Author getAuthor(int index) { + if (authorBuilder_ == null) { + return author_.get(index); + } else { + return authorBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder setAuthor( + int index, fast.Fast.Log.Author value) { + if (authorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureAuthorIsMutable(); + author_.set(index, value); + onChanged(); + } else { + authorBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder setAuthor( + int index, fast.Fast.Log.Author.Builder builderForValue) { + if (authorBuilder_ == null) { + ensureAuthorIsMutable(); + author_.set(index, builderForValue.build()); + onChanged(); + } else { + authorBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder addAuthor(fast.Fast.Log.Author value) { + if (authorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureAuthorIsMutable(); + author_.add(value); + onChanged(); + } else { + authorBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder addAuthor( + int index, fast.Fast.Log.Author value) { + if (authorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureAuthorIsMutable(); + author_.add(index, value); + onChanged(); + } else { + authorBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder addAuthor( + fast.Fast.Log.Author.Builder builderForValue) { + if (authorBuilder_ == null) { + ensureAuthorIsMutable(); + author_.add(builderForValue.build()); + onChanged(); + } else { + authorBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder addAuthor( + int index, fast.Fast.Log.Author.Builder builderForValue) { + if (authorBuilder_ == null) { + ensureAuthorIsMutable(); + author_.add(index, builderForValue.build()); + onChanged(); + } else { + authorBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder addAllAuthor( + java.lang.Iterable values) { + if (authorBuilder_ == null) { + ensureAuthorIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, author_); + onChanged(); + } else { + authorBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder clearAuthor() { + if (authorBuilder_ == null) { + author_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + authorBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public Builder removeAuthor(int index) { + if (authorBuilder_ == null) { + ensureAuthorIsMutable(); + author_.remove(index); + onChanged(); + } else { + authorBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.Author.Builder getAuthorBuilder( + int index) { + return getAuthorFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.AuthorOrBuilder getAuthorOrBuilder( + int index) { + if (authorBuilder_ == null) { + return author_.get(index); } else { + return authorBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Log.Author author = 2; + */ + public java.util.List + getAuthorOrBuilderList() { + if (authorBuilder_ != null) { + return authorBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(author_); + } + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.Author.Builder addAuthorBuilder() { + return getAuthorFieldBuilder().addBuilder( + fast.Fast.Log.Author.getDefaultInstance()); + } + /** + * repeated .fast.Log.Author author = 2; + */ + public fast.Fast.Log.Author.Builder addAuthorBuilder( + int index) { + return getAuthorFieldBuilder().addBuilder( + index, fast.Fast.Log.Author.getDefaultInstance()); + } + /** + * repeated .fast.Log.Author author = 2; + */ + public java.util.List + getAuthorBuilderList() { + return getAuthorFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Author, fast.Fast.Log.Author.Builder, fast.Fast.Log.AuthorOrBuilder> + getAuthorFieldBuilder() { + if (authorBuilder_ == null) { + authorBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Log.Author, fast.Fast.Log.Author.Builder, fast.Fast.Log.AuthorOrBuilder>( + author_, + ((bitField0_ & 0x00000002) == 0x00000002), + getParentForChildren(), + isClean()); + author_ = null; + } + return authorBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Log) + } + + // @@protoc_insertion_point(class_scope:fast.Log) + private static final fast.Fast.Log DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Log(); + } + + public static fast.Fast.Log getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Log parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Log(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Log getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SlicesOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Slices.Slice slice = 1; + */ + java.util.List + getSliceList(); + /** + * repeated .fast.Slices.Slice slice = 1; + */ + fast.Fast.Slices.Slice getSlice(int index); + /** + * repeated .fast.Slices.Slice slice = 1; + */ + int getSliceCount(); + /** + * repeated .fast.Slices.Slice slice = 1; + */ + java.util.List + getSliceOrBuilderList(); + /** + * repeated .fast.Slices.Slice slice = 1; + */ + fast.Fast.Slices.SliceOrBuilder getSliceOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Slices} + */ + public static final class Slices extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices) + SlicesOrBuilder { + // Use Slices.newBuilder() to construct. + private Slices(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Slices() { + slice_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Slices( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + slice_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + slice_.add( + input.readMessage(fast.Fast.Slices.Slice.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + slice_ = java.util.Collections.unmodifiableList(slice_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.class, fast.Fast.Slices.Builder.class); + } + + public interface SliceOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + java.util.List + getFileList(); + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + fast.Fast.Slices.Slice.SourceFile getFile(int index); + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + int getFileCount(); + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + java.util.List + getFileOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + fast.Fast.Slices.Slice.SourceFileOrBuilder getFileOrBuilder( + int index); + + /** + * string hash = 2; + */ + java.lang.String getHash(); + /** + * string hash = 2; + */ + com.google.protobuf.ByteString + getHashBytes(); + } + /** + * Protobuf type {@code fast.Slices.Slice} + */ + public static final class Slice extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice) + SliceOrBuilder { + // Use Slice.newBuilder() to construct. + private Slice(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Slice() { + file_ = java.util.Collections.emptyList(); + hash_ = ""; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Slice( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + file_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + file_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.parser(), extensionRegistry)); + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + hash_ = s; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + file_ = java.util.Collections.unmodifiableList(file_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.class, fast.Fast.Slices.Slice.Builder.class); + } + + /** + * Protobuf enum {@code fast.Slices.Slice.ChangeType} + */ + public enum ChangeType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * UNCHANGED = 0; + */ + UNCHANGED(0), + /** + * ADD = 1; + */ + ADD(1), + /** + * DEL = 2; + */ + DEL(2), + UNRECOGNIZED(-1), + ; + + /** + * UNCHANGED = 0; + */ + public static final int UNCHANGED_VALUE = 0; + /** + * ADD = 1; + */ + public static final int ADD_VALUE = 1; + /** + * DEL = 2; + */ + public static final int DEL_VALUE = 2; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ChangeType valueOf(int value) { + return forNumber(value); + } + + public static ChangeType forNumber(int value) { + switch (value) { + case 0: return UNCHANGED; + case 1: return ADD; + case 2: return DEL; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ChangeType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ChangeType findValueByNumber(int number) { + return ChangeType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return fast.Fast.Slices.Slice.getDescriptor().getEnumTypes().get(0); + } + + private static final ChangeType[] VALUES = values(); + + public static ChangeType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ChangeType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:fast.Slices.Slice.ChangeType) + } + + public interface SourceFileOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice.SourceFile) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + java.util.List + getFunctionList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + fast.Fast.Slices.Slice.SourceFile.Function getFunction(int index); + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + int getFunctionCount(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + java.util.List + getFunctionOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder getFunctionOrBuilder( + int index); + + /** + * string name = 2; + */ + java.lang.String getName(); + /** + * string name = 2; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + int getTypeValue(); + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + fast.Fast.Slices.Slice.ChangeType getType(); + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile} + */ + public static final class SourceFile extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice.SourceFile) + SourceFileOrBuilder { + // Use SourceFile.newBuilder() to construct. + private SourceFile(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SourceFile() { + function_ = java.util.Collections.emptyList(); + name_ = ""; + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private SourceFile( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + function_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + function_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.parser(), extensionRegistry)); + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 24: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + function_ = java.util.Collections.unmodifiableList(function_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.class, fast.Fast.Slices.Slice.SourceFile.Builder.class); + } + + public interface FunctionOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice.SourceFile.Function) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + java.util.List + getVariableList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable getVariable(int index); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + int getVariableCount(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + java.util.List + getVariableOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder getVariableOrBuilder( + int index); + + /** + * string name = 2; + */ + java.lang.String getName(); + /** + * string name = 2; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + int getTypeValue(); + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + fast.Fast.Slices.Slice.ChangeType getType(); + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function} + */ + public static final class Function extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice.SourceFile.Function) + FunctionOrBuilder { + // Use Function.newBuilder() to construct. + private Function(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Function() { + variable_ = java.util.Collections.emptyList(); + name_ = ""; + type_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Function( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + variable_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + variable_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.Variable.parser(), extensionRegistry)); + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 24: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + variable_ = java.util.Collections.unmodifiableList(variable_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.class, fast.Fast.Slices.Slice.SourceFile.Function.Builder.class); + } + + public interface VariableOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice.SourceFile.Function.Variable) + com.google.protobuf.MessageOrBuilder { + + /** + * string name = 1; + */ + java.lang.String getName(); + /** + * string name = 1; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + boolean hasPos(); + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getPos(); + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getPosOrBuilder(); + + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + int getTypeValue(); + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + fast.Fast.Slices.Slice.ChangeType getType(); + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + java.util.List + getDefnList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefn(int index); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + int getDefnCount(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + java.util.List + getDefnOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getDefnOrBuilder( + int index); + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + java.util.List + getUseList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getUse(int index); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + int getUseCount(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + java.util.List + getUseOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getUseOrBuilder( + int index); + + /** + * repeated string dvar = 6; + */ + java.util.List + getDvarList(); + /** + * repeated string dvar = 6; + */ + int getDvarCount(); + /** + * repeated string dvar = 6; + */ + java.lang.String getDvar(int index); + /** + * repeated string dvar = 6; + */ + com.google.protobuf.ByteString + getDvarBytes(int index); + + /** + * repeated string alias = 7; + */ + java.util.List + getAliasList(); + /** + * repeated string alias = 7; + */ + int getAliasCount(); + /** + * repeated string alias = 7; + */ + java.lang.String getAlias(int index); + /** + * repeated string alias = 7; + */ + com.google.protobuf.ByteString + getAliasBytes(int index); + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + java.util.List + getCfuncList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getCfunc(int index); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + int getCfuncCount(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + java.util.List + getCfuncOrBuilderList(); + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder getCfuncOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable} + */ + public static final class Variable extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice.SourceFile.Function.Variable) + VariableOrBuilder { + // Use Variable.newBuilder() to construct. + private Variable(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Variable() { + name_ = ""; + type_ = 0; + defn_ = java.util.Collections.emptyList(); + use_ = java.util.Collections.emptyList(); + dvar_ = com.google.protobuf.LazyStringArrayList.EMPTY; + alias_ = com.google.protobuf.LazyStringArrayList.EMPTY; + cfunc_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Variable( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 18: { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder subBuilder = null; + if (pos_ != null) { + subBuilder = pos_.toBuilder(); + } + pos_ = input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(pos_); + pos_ = subBuilder.buildPartial(); + } + + break; + } + case 24: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + defn_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + defn_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.parser(), extensionRegistry)); + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + use_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + use_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.parser(), extensionRegistry)); + break; + } + case 50: { + java.lang.String s = input.readStringRequireUtf8(); + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + dvar_ = new com.google.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000020; + } + dvar_.add(s); + break; + } + case 58: { + java.lang.String s = input.readStringRequireUtf8(); + if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + alias_ = new com.google.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000040; + } + alias_.add(s); + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + cfunc_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + cfunc_.add( + input.readMessage(fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + defn_ = java.util.Collections.unmodifiableList(defn_); + } + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + use_ = java.util.Collections.unmodifiableList(use_); + } + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + dvar_ = dvar_.getUnmodifiableView(); + } + if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + alias_ = alias_.getUnmodifiableView(); + } + if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + cfunc_ = java.util.Collections.unmodifiableList(cfunc_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder.class); + } + + public interface PositionOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice.SourceFile.Function.Variable.Position) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 lineno = 1; + */ + int getLineno(); + + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + int getTypeValue(); + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + fast.Fast.Slices.Slice.ChangeType getType(); + + /** + * int32 delta_lineno = 5; + */ + int getDeltaLineno(); + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable.Position} + */ + public static final class Position extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice.SourceFile.Function.Variable.Position) + PositionOrBuilder { + // Use Position.newBuilder() to construct. + private Position(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Position() { + lineno_ = 0; + type_ = 0; + deltaLineno_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Position( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 8: { + + lineno_ = input.readInt32(); + break; + } + case 16: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + case 40: { + + deltaLineno_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder.class); + } + + public static final int LINENO_FIELD_NUMBER = 1; + private int lineno_; + /** + * int32 lineno = 1; + */ + public int getLineno() { + return lineno_; + } + + public static final int TYPE_FIELD_NUMBER = 2; + private int type_; + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + + public static final int DELTA_LINENO_FIELD_NUMBER = 5; + private int deltaLineno_; + /** + * int32 delta_lineno = 5; + */ + public int getDeltaLineno() { + return deltaLineno_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (lineno_ != 0) { + output.writeInt32(1, lineno_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + output.writeEnum(2, type_); + } + if (deltaLineno_ != 0) { + output.writeInt32(5, deltaLineno_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (lineno_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, lineno_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, type_); + } + if (deltaLineno_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(5, deltaLineno_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position other = (fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position) obj; + + boolean result = true; + result = result && (getLineno() + == other.getLineno()); + result = result && type_ == other.type_; + result = result && (getDeltaLineno() + == other.getDeltaLineno()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + LINENO_FIELD_NUMBER; + hash = (53 * hash) + getLineno(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (37 * hash) + DELTA_LINENO_FIELD_NUMBER; + hash = (53 * hash) + getDeltaLineno(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable.Position} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice.SourceFile.Function.Variable.Position) + fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + lineno_ = 0; + + type_ = 0; + + deltaLineno_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position build() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position buildPartial() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position result = new fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position(this); + result.lineno_ = lineno_; + result.type_ = type_; + result.deltaLineno_ = deltaLineno_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position) { + return mergeFrom((fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position other) { + if (other == fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance()) return this; + if (other.getLineno() != 0) { + setLineno(other.getLineno()); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + if (other.getDeltaLineno() != 0) { + setDeltaLineno(other.getDeltaLineno()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int lineno_ ; + /** + * int32 lineno = 1; + */ + public int getLineno() { + return lineno_; + } + /** + * int32 lineno = 1; + */ + public Builder setLineno(int value) { + + lineno_ = value; + onChanged(); + return this; + } + /** + * int32 lineno = 1; + */ + public Builder clearLineno() { + + lineno_ = 0; + onChanged(); + return this; + } + + private int type_ = 0; + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public Builder setType(fast.Fast.Slices.Slice.ChangeType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 2; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + + private int deltaLineno_ ; + /** + * int32 delta_lineno = 5; + */ + public int getDeltaLineno() { + return deltaLineno_; + } + /** + * int32 delta_lineno = 5; + */ + public Builder setDeltaLineno(int value) { + + deltaLineno_ = value; + onChanged(); + return this; + } + /** + * int32 delta_lineno = 5; + */ + public Builder clearDeltaLineno() { + + deltaLineno_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice.SourceFile.Function.Variable.Position) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice.SourceFile.Function.Variable.Position) + private static final fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position(); + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Position parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Position(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FunctionDeclOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) + com.google.protobuf.MessageOrBuilder { + + /** + * string name = 1; + */ + java.lang.String getName(); + /** + * string name = 1; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * int32 lineno = 2; + */ + int getLineno(); + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl} + */ + public static final class FunctionDecl extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) + FunctionDeclOrBuilder { + // Use FunctionDecl.newBuilder() to construct. + private FunctionDecl(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FunctionDecl() { + name_ = ""; + lineno_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private FunctionDecl( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 16: { + + lineno_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder.class); + } + + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int LINENO_FIELD_NUMBER = 2; + private int lineno_; + /** + * int32 lineno = 2; + */ + public int getLineno() { + return lineno_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (lineno_ != 0) { + output.writeInt32(2, lineno_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (lineno_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, lineno_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl other = (fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) obj; + + boolean result = true; + result = result && getName() + .equals(other.getName()); + result = result && (getLineno() + == other.getLineno()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + LINENO_FIELD_NUMBER; + hash = (53 * hash) + getLineno(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + name_ = ""; + + lineno_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl build() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl buildPartial() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl result = new fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl(this); + result.name_ = name_; + result.lineno_ = lineno_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) { + return mergeFrom((fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl other) { + if (other == fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (other.getLineno() != 0) { + setLineno(other.getLineno()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object name_ = ""; + /** + * string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string name = 1; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string name = 1; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private int lineno_ ; + /** + * int32 lineno = 2; + */ + public int getLineno() { + return lineno_; + } + /** + * int32 lineno = 2; + */ + public Builder setLineno(int value) { + + lineno_ = value; + onChanged(); + return this; + } + /** + * int32 lineno = 2; + */ + public Builder clearLineno() { + + lineno_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl) + private static final fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl(); + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public FunctionDecl parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FunctionDecl(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int POS_FIELD_NUMBER = 2; + private fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position pos_; + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public boolean hasPos() { + return pos_ != null; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getPos() { + return pos_ == null ? fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance() : pos_; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getPosOrBuilder() { + return getPos(); + } + + public static final int TYPE_FIELD_NUMBER = 3; + private int type_; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + + public static final int DEFN_FIELD_NUMBER = 4; + private java.util.List defn_; + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public java.util.List getDefnList() { + return defn_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public java.util.List + getDefnOrBuilderList() { + return defn_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public int getDefnCount() { + return defn_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefn(int index) { + return defn_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getDefnOrBuilder( + int index) { + return defn_.get(index); + } + + public static final int USE_FIELD_NUMBER = 5; + private java.util.List use_; + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public java.util.List getUseList() { + return use_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public java.util.List + getUseOrBuilderList() { + return use_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public int getUseCount() { + return use_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getUse(int index) { + return use_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getUseOrBuilder( + int index) { + return use_.get(index); + } + + public static final int DVAR_FIELD_NUMBER = 6; + private com.google.protobuf.LazyStringList dvar_; + /** + * repeated string dvar = 6; + */ + public com.google.protobuf.ProtocolStringList + getDvarList() { + return dvar_; + } + /** + * repeated string dvar = 6; + */ + public int getDvarCount() { + return dvar_.size(); + } + /** + * repeated string dvar = 6; + */ + public java.lang.String getDvar(int index) { + return dvar_.get(index); + } + /** + * repeated string dvar = 6; + */ + public com.google.protobuf.ByteString + getDvarBytes(int index) { + return dvar_.getByteString(index); + } + + public static final int ALIAS_FIELD_NUMBER = 7; + private com.google.protobuf.LazyStringList alias_; + /** + * repeated string alias = 7; + */ + public com.google.protobuf.ProtocolStringList + getAliasList() { + return alias_; + } + /** + * repeated string alias = 7; + */ + public int getAliasCount() { + return alias_.size(); + } + /** + * repeated string alias = 7; + */ + public java.lang.String getAlias(int index) { + return alias_.get(index); + } + /** + * repeated string alias = 7; + */ + public com.google.protobuf.ByteString + getAliasBytes(int index) { + return alias_.getByteString(index); + } + + public static final int CFUNC_FIELD_NUMBER = 8; + private java.util.List cfunc_; + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public java.util.List getCfuncList() { + return cfunc_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public java.util.List + getCfuncOrBuilderList() { + return cfunc_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public int getCfuncCount() { + return cfunc_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getCfunc(int index) { + return cfunc_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder getCfuncOrBuilder( + int index) { + return cfunc_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (pos_ != null) { + output.writeMessage(2, getPos()); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + output.writeEnum(3, type_); + } + for (int i = 0; i < defn_.size(); i++) { + output.writeMessage(4, defn_.get(i)); + } + for (int i = 0; i < use_.size(); i++) { + output.writeMessage(5, use_.get(i)); + } + for (int i = 0; i < dvar_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, dvar_.getRaw(i)); + } + for (int i = 0; i < alias_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 7, alias_.getRaw(i)); + } + for (int i = 0; i < cfunc_.size(); i++) { + output.writeMessage(8, cfunc_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (pos_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getPos()); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, type_); + } + for (int i = 0; i < defn_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, defn_.get(i)); + } + for (int i = 0; i < use_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, use_.get(i)); + } + { + int dataSize = 0; + for (int i = 0; i < dvar_.size(); i++) { + dataSize += computeStringSizeNoTag(dvar_.getRaw(i)); + } + size += dataSize; + size += 1 * getDvarList().size(); + } + { + int dataSize = 0; + for (int i = 0; i < alias_.size(); i++) { + dataSize += computeStringSizeNoTag(alias_.getRaw(i)); + } + size += dataSize; + size += 1 * getAliasList().size(); + } + for (int i = 0; i < cfunc_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, cfunc_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice.SourceFile.Function.Variable other = (fast.Fast.Slices.Slice.SourceFile.Function.Variable) obj; + + boolean result = true; + result = result && getName() + .equals(other.getName()); + result = result && (hasPos() == other.hasPos()); + if (hasPos()) { + result = result && getPos() + .equals(other.getPos()); + } + result = result && type_ == other.type_; + result = result && getDefnList() + .equals(other.getDefnList()); + result = result && getUseList() + .equals(other.getUseList()); + result = result && getDvarList() + .equals(other.getDvarList()); + result = result && getAliasList() + .equals(other.getAliasList()); + result = result && getCfuncList() + .equals(other.getCfuncList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + if (hasPos()) { + hash = (37 * hash) + POS_FIELD_NUMBER; + hash = (53 * hash) + getPos().hashCode(); + } + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + if (getDefnCount() > 0) { + hash = (37 * hash) + DEFN_FIELD_NUMBER; + hash = (53 * hash) + getDefnList().hashCode(); + } + if (getUseCount() > 0) { + hash = (37 * hash) + USE_FIELD_NUMBER; + hash = (53 * hash) + getUseList().hashCode(); + } + if (getDvarCount() > 0) { + hash = (37 * hash) + DVAR_FIELD_NUMBER; + hash = (53 * hash) + getDvarList().hashCode(); + } + if (getAliasCount() > 0) { + hash = (37 * hash) + ALIAS_FIELD_NUMBER; + hash = (53 * hash) + getAliasList().hashCode(); + } + if (getCfuncCount() > 0) { + hash = (37 * hash) + CFUNC_FIELD_NUMBER; + hash = (53 * hash) + getCfuncList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice.SourceFile.Function.Variable prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function.Variable} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice.SourceFile.Function.Variable) + fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.class, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.SourceFile.Function.Variable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getDefnFieldBuilder(); + getUseFieldBuilder(); + getCfuncFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + name_ = ""; + + if (posBuilder_ == null) { + pos_ = null; + } else { + pos_ = null; + posBuilder_ = null; + } + type_ = 0; + + if (defnBuilder_ == null) { + defn_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + defnBuilder_.clear(); + } + if (useBuilder_ == null) { + use_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + } else { + useBuilder_.clear(); + } + dvar_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + alias_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000040); + if (cfuncBuilder_ == null) { + cfunc_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + } else { + cfuncBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.SourceFile.Function.Variable.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable build() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable buildPartial() { + fast.Fast.Slices.Slice.SourceFile.Function.Variable result = new fast.Fast.Slices.Slice.SourceFile.Function.Variable(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.name_ = name_; + if (posBuilder_ == null) { + result.pos_ = pos_; + } else { + result.pos_ = posBuilder_.build(); + } + result.type_ = type_; + if (defnBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008)) { + defn_ = java.util.Collections.unmodifiableList(defn_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.defn_ = defn_; + } else { + result.defn_ = defnBuilder_.build(); + } + if (useBuilder_ == null) { + if (((bitField0_ & 0x00000010) == 0x00000010)) { + use_ = java.util.Collections.unmodifiableList(use_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.use_ = use_; + } else { + result.use_ = useBuilder_.build(); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + dvar_ = dvar_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.dvar_ = dvar_; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + alias_ = alias_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.alias_ = alias_; + if (cfuncBuilder_ == null) { + if (((bitField0_ & 0x00000080) == 0x00000080)) { + cfunc_ = java.util.Collections.unmodifiableList(cfunc_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.cfunc_ = cfunc_; + } else { + result.cfunc_ = cfuncBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice.SourceFile.Function.Variable) { + return mergeFrom((fast.Fast.Slices.Slice.SourceFile.Function.Variable)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice.SourceFile.Function.Variable other) { + if (other == fast.Fast.Slices.Slice.SourceFile.Function.Variable.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (other.hasPos()) { + mergePos(other.getPos()); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + if (defnBuilder_ == null) { + if (!other.defn_.isEmpty()) { + if (defn_.isEmpty()) { + defn_ = other.defn_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureDefnIsMutable(); + defn_.addAll(other.defn_); + } + onChanged(); + } + } else { + if (!other.defn_.isEmpty()) { + if (defnBuilder_.isEmpty()) { + defnBuilder_.dispose(); + defnBuilder_ = null; + defn_ = other.defn_; + bitField0_ = (bitField0_ & ~0x00000008); + defnBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getDefnFieldBuilder() : null; + } else { + defnBuilder_.addAllMessages(other.defn_); + } + } + } + if (useBuilder_ == null) { + if (!other.use_.isEmpty()) { + if (use_.isEmpty()) { + use_ = other.use_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureUseIsMutable(); + use_.addAll(other.use_); + } + onChanged(); + } + } else { + if (!other.use_.isEmpty()) { + if (useBuilder_.isEmpty()) { + useBuilder_.dispose(); + useBuilder_ = null; + use_ = other.use_; + bitField0_ = (bitField0_ & ~0x00000010); + useBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getUseFieldBuilder() : null; + } else { + useBuilder_.addAllMessages(other.use_); + } + } + } + if (!other.dvar_.isEmpty()) { + if (dvar_.isEmpty()) { + dvar_ = other.dvar_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureDvarIsMutable(); + dvar_.addAll(other.dvar_); + } + onChanged(); + } + if (!other.alias_.isEmpty()) { + if (alias_.isEmpty()) { + alias_ = other.alias_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureAliasIsMutable(); + alias_.addAll(other.alias_); + } + onChanged(); + } + if (cfuncBuilder_ == null) { + if (!other.cfunc_.isEmpty()) { + if (cfunc_.isEmpty()) { + cfunc_ = other.cfunc_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureCfuncIsMutable(); + cfunc_.addAll(other.cfunc_); + } + onChanged(); + } + } else { + if (!other.cfunc_.isEmpty()) { + if (cfuncBuilder_.isEmpty()) { + cfuncBuilder_.dispose(); + cfuncBuilder_ = null; + cfunc_ = other.cfunc_; + bitField0_ = (bitField0_ & ~0x00000080); + cfuncBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getCfuncFieldBuilder() : null; + } else { + cfuncBuilder_.addAllMessages(other.cfunc_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice.SourceFile.Function.Variable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice.SourceFile.Function.Variable) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string name = 1; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string name = 1; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position pos_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> posBuilder_; + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public boolean hasPos() { + return posBuilder_ != null || pos_ != null; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getPos() { + if (posBuilder_ == null) { + return pos_ == null ? fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance() : pos_; + } else { + return posBuilder_.getMessage(); + } + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public Builder setPos(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (posBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + pos_ = value; + onChanged(); + } else { + posBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public Builder setPos( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (posBuilder_ == null) { + pos_ = builderForValue.build(); + onChanged(); + } else { + posBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public Builder mergePos(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (posBuilder_ == null) { + if (pos_ != null) { + pos_ = + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.newBuilder(pos_).mergeFrom(value).buildPartial(); + } else { + pos_ = value; + } + onChanged(); + } else { + posBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public Builder clearPos() { + if (posBuilder_ == null) { + pos_ = null; + onChanged(); + } else { + pos_ = null; + posBuilder_ = null; + } + + return this; + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder getPosBuilder() { + + onChanged(); + return getPosFieldBuilder().getBuilder(); + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getPosOrBuilder() { + if (posBuilder_ != null) { + return posBuilder_.getMessageOrBuilder(); + } else { + return pos_ == null ? + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance() : pos_; + } + } + /** + * .fast.Slices.Slice.SourceFile.Function.Variable.Position pos = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> + getPosFieldBuilder() { + if (posBuilder_ == null) { + posBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder>( + getPos(), + getParentForChildren(), + isClean()); + pos_ = null; + } + return posBuilder_; + } + + private int type_ = 0; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setType(fast.Fast.Slices.Slice.ChangeType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + + private java.util.List defn_ = + java.util.Collections.emptyList(); + private void ensureDefnIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + defn_ = new java.util.ArrayList(defn_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> defnBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public java.util.List getDefnList() { + if (defnBuilder_ == null) { + return java.util.Collections.unmodifiableList(defn_); + } else { + return defnBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public int getDefnCount() { + if (defnBuilder_ == null) { + return defn_.size(); + } else { + return defnBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getDefn(int index) { + if (defnBuilder_ == null) { + return defn_.get(index); + } else { + return defnBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder setDefn( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (defnBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDefnIsMutable(); + defn_.set(index, value); + onChanged(); + } else { + defnBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder setDefn( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (defnBuilder_ == null) { + ensureDefnIsMutable(); + defn_.set(index, builderForValue.build()); + onChanged(); + } else { + defnBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder addDefn(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (defnBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDefnIsMutable(); + defn_.add(value); + onChanged(); + } else { + defnBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder addDefn( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (defnBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDefnIsMutable(); + defn_.add(index, value); + onChanged(); + } else { + defnBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder addDefn( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (defnBuilder_ == null) { + ensureDefnIsMutable(); + defn_.add(builderForValue.build()); + onChanged(); + } else { + defnBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder addDefn( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (defnBuilder_ == null) { + ensureDefnIsMutable(); + defn_.add(index, builderForValue.build()); + onChanged(); + } else { + defnBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder addAllDefn( + java.lang.Iterable values) { + if (defnBuilder_ == null) { + ensureDefnIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, defn_); + onChanged(); + } else { + defnBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder clearDefn() { + if (defnBuilder_ == null) { + defn_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + defnBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public Builder removeDefn(int index) { + if (defnBuilder_ == null) { + ensureDefnIsMutable(); + defn_.remove(index); + onChanged(); + } else { + defnBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder getDefnBuilder( + int index) { + return getDefnFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getDefnOrBuilder( + int index) { + if (defnBuilder_ == null) { + return defn_.get(index); } else { + return defnBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public java.util.List + getDefnOrBuilderList() { + if (defnBuilder_ != null) { + return defnBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(defn_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder addDefnBuilder() { + return getDefnFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder addDefnBuilder( + int index) { + return getDefnFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position defn = 4; + */ + public java.util.List + getDefnBuilderList() { + return getDefnFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> + getDefnFieldBuilder() { + if (defnBuilder_ == null) { + defnBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder>( + defn_, + ((bitField0_ & 0x00000008) == 0x00000008), + getParentForChildren(), + isClean()); + defn_ = null; + } + return defnBuilder_; + } + + private java.util.List use_ = + java.util.Collections.emptyList(); + private void ensureUseIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + use_ = new java.util.ArrayList(use_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> useBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public java.util.List getUseList() { + if (useBuilder_ == null) { + return java.util.Collections.unmodifiableList(use_); + } else { + return useBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public int getUseCount() { + if (useBuilder_ == null) { + return use_.size(); + } else { + return useBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position getUse(int index) { + if (useBuilder_ == null) { + return use_.get(index); + } else { + return useBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder setUse( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (useBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureUseIsMutable(); + use_.set(index, value); + onChanged(); + } else { + useBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder setUse( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (useBuilder_ == null) { + ensureUseIsMutable(); + use_.set(index, builderForValue.build()); + onChanged(); + } else { + useBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder addUse(fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (useBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureUseIsMutable(); + use_.add(value); + onChanged(); + } else { + useBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder addUse( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position value) { + if (useBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureUseIsMutable(); + use_.add(index, value); + onChanged(); + } else { + useBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder addUse( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (useBuilder_ == null) { + ensureUseIsMutable(); + use_.add(builderForValue.build()); + onChanged(); + } else { + useBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder addUse( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder builderForValue) { + if (useBuilder_ == null) { + ensureUseIsMutable(); + use_.add(index, builderForValue.build()); + onChanged(); + } else { + useBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder addAllUse( + java.lang.Iterable values) { + if (useBuilder_ == null) { + ensureUseIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, use_); + onChanged(); + } else { + useBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder clearUse() { + if (useBuilder_ == null) { + use_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + useBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public Builder removeUse(int index) { + if (useBuilder_ == null) { + ensureUseIsMutable(); + use_.remove(index); + onChanged(); + } else { + useBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder getUseBuilder( + int index) { + return getUseFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder getUseOrBuilder( + int index) { + if (useBuilder_ == null) { + return use_.get(index); } else { + return useBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public java.util.List + getUseOrBuilderList() { + if (useBuilder_ != null) { + return useBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(use_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder addUseBuilder() { + return getUseFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder addUseBuilder( + int index) { + return getUseFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.Position use = 5; + */ + public java.util.List + getUseBuilderList() { + return getUseFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder> + getUseFieldBuilder() { + if (useBuilder_ == null) { + useBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Position.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.PositionOrBuilder>( + use_, + ((bitField0_ & 0x00000010) == 0x00000010), + getParentForChildren(), + isClean()); + use_ = null; + } + return useBuilder_; + } + + private com.google.protobuf.LazyStringList dvar_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureDvarIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + dvar_ = new com.google.protobuf.LazyStringArrayList(dvar_); + bitField0_ |= 0x00000020; + } + } + /** + * repeated string dvar = 6; + */ + public com.google.protobuf.ProtocolStringList + getDvarList() { + return dvar_.getUnmodifiableView(); + } + /** + * repeated string dvar = 6; + */ + public int getDvarCount() { + return dvar_.size(); + } + /** + * repeated string dvar = 6; + */ + public java.lang.String getDvar(int index) { + return dvar_.get(index); + } + /** + * repeated string dvar = 6; + */ + public com.google.protobuf.ByteString + getDvarBytes(int index) { + return dvar_.getByteString(index); + } + /** + * repeated string dvar = 6; + */ + public Builder setDvar( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDvarIsMutable(); + dvar_.set(index, value); + onChanged(); + return this; + } + /** + * repeated string dvar = 6; + */ + public Builder addDvar( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDvarIsMutable(); + dvar_.add(value); + onChanged(); + return this; + } + /** + * repeated string dvar = 6; + */ + public Builder addAllDvar( + java.lang.Iterable values) { + ensureDvarIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, dvar_); + onChanged(); + return this; + } + /** + * repeated string dvar = 6; + */ + public Builder clearDvar() { + dvar_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + /** + * repeated string dvar = 6; + */ + public Builder addDvarBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + ensureDvarIsMutable(); + dvar_.add(value); + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringList alias_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureAliasIsMutable() { + if (!((bitField0_ & 0x00000040) == 0x00000040)) { + alias_ = new com.google.protobuf.LazyStringArrayList(alias_); + bitField0_ |= 0x00000040; + } + } + /** + * repeated string alias = 7; + */ + public com.google.protobuf.ProtocolStringList + getAliasList() { + return alias_.getUnmodifiableView(); + } + /** + * repeated string alias = 7; + */ + public int getAliasCount() { + return alias_.size(); + } + /** + * repeated string alias = 7; + */ + public java.lang.String getAlias(int index) { + return alias_.get(index); + } + /** + * repeated string alias = 7; + */ + public com.google.protobuf.ByteString + getAliasBytes(int index) { + return alias_.getByteString(index); + } + /** + * repeated string alias = 7; + */ + public Builder setAlias( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAliasIsMutable(); + alias_.set(index, value); + onChanged(); + return this; + } + /** + * repeated string alias = 7; + */ + public Builder addAlias( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAliasIsMutable(); + alias_.add(value); + onChanged(); + return this; + } + /** + * repeated string alias = 7; + */ + public Builder addAllAlias( + java.lang.Iterable values) { + ensureAliasIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, alias_); + onChanged(); + return this; + } + /** + * repeated string alias = 7; + */ + public Builder clearAlias() { + alias_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + return this; + } + /** + * repeated string alias = 7; + */ + public Builder addAliasBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + ensureAliasIsMutable(); + alias_.add(value); + onChanged(); + return this; + } + + private java.util.List cfunc_ = + java.util.Collections.emptyList(); + private void ensureCfuncIsMutable() { + if (!((bitField0_ & 0x00000080) == 0x00000080)) { + cfunc_ = new java.util.ArrayList(cfunc_); + bitField0_ |= 0x00000080; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder> cfuncBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public java.util.List getCfuncList() { + if (cfuncBuilder_ == null) { + return java.util.Collections.unmodifiableList(cfunc_); + } else { + return cfuncBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public int getCfuncCount() { + if (cfuncBuilder_ == null) { + return cfunc_.size(); + } else { + return cfuncBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl getCfunc(int index) { + if (cfuncBuilder_ == null) { + return cfunc_.get(index); + } else { + return cfuncBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder setCfunc( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl value) { + if (cfuncBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCfuncIsMutable(); + cfunc_.set(index, value); + onChanged(); + } else { + cfuncBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder setCfunc( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder builderForValue) { + if (cfuncBuilder_ == null) { + ensureCfuncIsMutable(); + cfunc_.set(index, builderForValue.build()); + onChanged(); + } else { + cfuncBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder addCfunc(fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl value) { + if (cfuncBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCfuncIsMutable(); + cfunc_.add(value); + onChanged(); + } else { + cfuncBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder addCfunc( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl value) { + if (cfuncBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCfuncIsMutable(); + cfunc_.add(index, value); + onChanged(); + } else { + cfuncBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder addCfunc( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder builderForValue) { + if (cfuncBuilder_ == null) { + ensureCfuncIsMutable(); + cfunc_.add(builderForValue.build()); + onChanged(); + } else { + cfuncBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder addCfunc( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder builderForValue) { + if (cfuncBuilder_ == null) { + ensureCfuncIsMutable(); + cfunc_.add(index, builderForValue.build()); + onChanged(); + } else { + cfuncBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder addAllCfunc( + java.lang.Iterable values) { + if (cfuncBuilder_ == null) { + ensureCfuncIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, cfunc_); + onChanged(); + } else { + cfuncBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder clearCfunc() { + if (cfuncBuilder_ == null) { + cfunc_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + onChanged(); + } else { + cfuncBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public Builder removeCfunc(int index) { + if (cfuncBuilder_ == null) { + ensureCfuncIsMutable(); + cfunc_.remove(index); + onChanged(); + } else { + cfuncBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder getCfuncBuilder( + int index) { + return getCfuncFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder getCfuncOrBuilder( + int index) { + if (cfuncBuilder_ == null) { + return cfunc_.get(index); } else { + return cfuncBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public java.util.List + getCfuncOrBuilderList() { + if (cfuncBuilder_ != null) { + return cfuncBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(cfunc_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder addCfuncBuilder() { + return getCfuncFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder addCfuncBuilder( + int index) { + return getCfuncFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl cfunc = 8; + */ + public java.util.List + getCfuncBuilderList() { + return getCfuncFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder> + getCfuncFieldBuilder() { + if (cfuncBuilder_ == null) { + cfuncBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDecl.Builder, fast.Fast.Slices.Slice.SourceFile.Function.Variable.FunctionDeclOrBuilder>( + cfunc_, + ((bitField0_ & 0x00000080) == 0x00000080), + getParentForChildren(), + isClean()); + cfunc_ = null; + } + return cfuncBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice.SourceFile.Function.Variable) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice.SourceFile.Function.Variable) + private static final fast.Fast.Slices.Slice.SourceFile.Function.Variable DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice.SourceFile.Function.Variable(); + } + + public static fast.Fast.Slices.Slice.SourceFile.Function.Variable getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Variable parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Variable(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice.SourceFile.Function.Variable getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int VARIABLE_FIELD_NUMBER = 1; + private java.util.List variable_; + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public java.util.List getVariableList() { + return variable_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public java.util.List + getVariableOrBuilderList() { + return variable_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public int getVariableCount() { + return variable_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable getVariable(int index) { + return variable_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder getVariableOrBuilder( + int index) { + return variable_.get(index); + } + + public static final int NAME_FIELD_NUMBER = 2; + private volatile java.lang.Object name_; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TYPE_FIELD_NUMBER = 3; + private int type_; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < variable_.size(); i++) { + output.writeMessage(1, variable_.get(i)); + } + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, name_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + output.writeEnum(3, type_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < variable_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, variable_.get(i)); + } + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, name_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, type_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice.SourceFile.Function)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice.SourceFile.Function other = (fast.Fast.Slices.Slice.SourceFile.Function) obj; + + boolean result = true; + result = result && getVariableList() + .equals(other.getVariableList()); + result = result && getName() + .equals(other.getName()); + result = result && type_ == other.type_; + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getVariableCount() > 0) { + hash = (37 * hash) + VARIABLE_FIELD_NUMBER; + hash = (53 * hash) + getVariableList().hashCode(); + } + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile.Function parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice.SourceFile.Function prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile.Function} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice.SourceFile.Function) + fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.Function.class, fast.Fast.Slices.Slice.SourceFile.Function.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.SourceFile.Function.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getVariableFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (variableBuilder_ == null) { + variable_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + variableBuilder_.clear(); + } + name_ = ""; + + type_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_Function_descriptor; + } + + public fast.Fast.Slices.Slice.SourceFile.Function getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.SourceFile.Function.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice.SourceFile.Function build() { + fast.Fast.Slices.Slice.SourceFile.Function result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice.SourceFile.Function buildPartial() { + fast.Fast.Slices.Slice.SourceFile.Function result = new fast.Fast.Slices.Slice.SourceFile.Function(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (variableBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + variable_ = java.util.Collections.unmodifiableList(variable_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.variable_ = variable_; + } else { + result.variable_ = variableBuilder_.build(); + } + result.name_ = name_; + result.type_ = type_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice.SourceFile.Function) { + return mergeFrom((fast.Fast.Slices.Slice.SourceFile.Function)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice.SourceFile.Function other) { + if (other == fast.Fast.Slices.Slice.SourceFile.Function.getDefaultInstance()) return this; + if (variableBuilder_ == null) { + if (!other.variable_.isEmpty()) { + if (variable_.isEmpty()) { + variable_ = other.variable_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureVariableIsMutable(); + variable_.addAll(other.variable_); + } + onChanged(); + } + } else { + if (!other.variable_.isEmpty()) { + if (variableBuilder_.isEmpty()) { + variableBuilder_.dispose(); + variableBuilder_ = null; + variable_ = other.variable_; + bitField0_ = (bitField0_ & ~0x00000001); + variableBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getVariableFieldBuilder() : null; + } else { + variableBuilder_.addAllMessages(other.variable_); + } + } + } + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice.SourceFile.Function parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice.SourceFile.Function) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List variable_ = + java.util.Collections.emptyList(); + private void ensureVariableIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + variable_ = new java.util.ArrayList(variable_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder, fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder> variableBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public java.util.List getVariableList() { + if (variableBuilder_ == null) { + return java.util.Collections.unmodifiableList(variable_); + } else { + return variableBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public int getVariableCount() { + if (variableBuilder_ == null) { + return variable_.size(); + } else { + return variableBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable getVariable(int index) { + if (variableBuilder_ == null) { + return variable_.get(index); + } else { + return variableBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder setVariable( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable value) { + if (variableBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVariableIsMutable(); + variable_.set(index, value); + onChanged(); + } else { + variableBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder setVariable( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder builderForValue) { + if (variableBuilder_ == null) { + ensureVariableIsMutable(); + variable_.set(index, builderForValue.build()); + onChanged(); + } else { + variableBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder addVariable(fast.Fast.Slices.Slice.SourceFile.Function.Variable value) { + if (variableBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVariableIsMutable(); + variable_.add(value); + onChanged(); + } else { + variableBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder addVariable( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable value) { + if (variableBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVariableIsMutable(); + variable_.add(index, value); + onChanged(); + } else { + variableBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder addVariable( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder builderForValue) { + if (variableBuilder_ == null) { + ensureVariableIsMutable(); + variable_.add(builderForValue.build()); + onChanged(); + } else { + variableBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder addVariable( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder builderForValue) { + if (variableBuilder_ == null) { + ensureVariableIsMutable(); + variable_.add(index, builderForValue.build()); + onChanged(); + } else { + variableBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder addAllVariable( + java.lang.Iterable values) { + if (variableBuilder_ == null) { + ensureVariableIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, variable_); + onChanged(); + } else { + variableBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder clearVariable() { + if (variableBuilder_ == null) { + variable_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + variableBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public Builder removeVariable(int index) { + if (variableBuilder_ == null) { + ensureVariableIsMutable(); + variable_.remove(index); + onChanged(); + } else { + variableBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder getVariableBuilder( + int index) { + return getVariableFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder getVariableOrBuilder( + int index) { + if (variableBuilder_ == null) { + return variable_.get(index); } else { + return variableBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public java.util.List + getVariableOrBuilderList() { + if (variableBuilder_ != null) { + return variableBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(variable_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder addVariableBuilder() { + return getVariableFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.Function.Variable.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder addVariableBuilder( + int index) { + return getVariableFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.Function.Variable.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function.Variable variable = 1; + */ + public java.util.List + getVariableBuilderList() { + return getVariableFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder, fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder> + getVariableFieldBuilder() { + if (variableBuilder_ == null) { + variableBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function.Variable, fast.Fast.Slices.Slice.SourceFile.Function.Variable.Builder, fast.Fast.Slices.Slice.SourceFile.Function.VariableOrBuilder>( + variable_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + variable_ = null; + } + return variableBuilder_; + } + + private java.lang.Object name_ = ""; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private int type_ = 0; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setType(fast.Fast.Slices.Slice.ChangeType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice.SourceFile.Function) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice.SourceFile.Function) + private static final fast.Fast.Slices.Slice.SourceFile.Function DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice.SourceFile.Function(); + } + + public static fast.Fast.Slices.Slice.SourceFile.Function getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Function parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Function(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice.SourceFile.Function getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int FUNCTION_FIELD_NUMBER = 1; + private java.util.List function_; + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public java.util.List getFunctionList() { + return function_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public java.util.List + getFunctionOrBuilderList() { + return function_; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public int getFunctionCount() { + return function_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function getFunction(int index) { + return function_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder getFunctionOrBuilder( + int index) { + return function_.get(index); + } + + public static final int NAME_FIELD_NUMBER = 2; + private volatile java.lang.Object name_; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TYPE_FIELD_NUMBER = 3; + private int type_; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < function_.size(); i++) { + output.writeMessage(1, function_.get(i)); + } + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, name_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + output.writeEnum(3, type_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < function_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, function_.get(i)); + } + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, name_); + } + if (type_ != fast.Fast.Slices.Slice.ChangeType.UNCHANGED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, type_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice.SourceFile)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice.SourceFile other = (fast.Fast.Slices.Slice.SourceFile) obj; + + boolean result = true; + result = result && getFunctionList() + .equals(other.getFunctionList()); + result = result && getName() + .equals(other.getName()); + result = result && type_ == other.type_; + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFunctionCount() > 0) { + hash = (37 * hash) + FUNCTION_FIELD_NUMBER; + hash = (53 * hash) + getFunctionList().hashCode(); + } + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice.SourceFile parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice.SourceFile prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice.SourceFile} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice.SourceFile) + fast.Fast.Slices.Slice.SourceFileOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.SourceFile.class, fast.Fast.Slices.Slice.SourceFile.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.SourceFile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFunctionFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (functionBuilder_ == null) { + function_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + functionBuilder_.clear(); + } + name_ = ""; + + type_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_SourceFile_descriptor; + } + + public fast.Fast.Slices.Slice.SourceFile getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.SourceFile.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice.SourceFile build() { + fast.Fast.Slices.Slice.SourceFile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice.SourceFile buildPartial() { + fast.Fast.Slices.Slice.SourceFile result = new fast.Fast.Slices.Slice.SourceFile(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (functionBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + function_ = java.util.Collections.unmodifiableList(function_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.function_ = function_; + } else { + result.function_ = functionBuilder_.build(); + } + result.name_ = name_; + result.type_ = type_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice.SourceFile) { + return mergeFrom((fast.Fast.Slices.Slice.SourceFile)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice.SourceFile other) { + if (other == fast.Fast.Slices.Slice.SourceFile.getDefaultInstance()) return this; + if (functionBuilder_ == null) { + if (!other.function_.isEmpty()) { + if (function_.isEmpty()) { + function_ = other.function_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFunctionIsMutable(); + function_.addAll(other.function_); + } + onChanged(); + } + } else { + if (!other.function_.isEmpty()) { + if (functionBuilder_.isEmpty()) { + functionBuilder_.dispose(); + functionBuilder_ = null; + function_ = other.function_; + bitField0_ = (bitField0_ & ~0x00000001); + functionBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getFunctionFieldBuilder() : null; + } else { + functionBuilder_.addAllMessages(other.function_); + } + } + } + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice.SourceFile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice.SourceFile) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List function_ = + java.util.Collections.emptyList(); + private void ensureFunctionIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + function_ = new java.util.ArrayList(function_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function, fast.Fast.Slices.Slice.SourceFile.Function.Builder, fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder> functionBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public java.util.List getFunctionList() { + if (functionBuilder_ == null) { + return java.util.Collections.unmodifiableList(function_); + } else { + return functionBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public int getFunctionCount() { + if (functionBuilder_ == null) { + return function_.size(); + } else { + return functionBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function getFunction(int index) { + if (functionBuilder_ == null) { + return function_.get(index); + } else { + return functionBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder setFunction( + int index, fast.Fast.Slices.Slice.SourceFile.Function value) { + if (functionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFunctionIsMutable(); + function_.set(index, value); + onChanged(); + } else { + functionBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder setFunction( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Builder builderForValue) { + if (functionBuilder_ == null) { + ensureFunctionIsMutable(); + function_.set(index, builderForValue.build()); + onChanged(); + } else { + functionBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder addFunction(fast.Fast.Slices.Slice.SourceFile.Function value) { + if (functionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFunctionIsMutable(); + function_.add(value); + onChanged(); + } else { + functionBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder addFunction( + int index, fast.Fast.Slices.Slice.SourceFile.Function value) { + if (functionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFunctionIsMutable(); + function_.add(index, value); + onChanged(); + } else { + functionBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder addFunction( + fast.Fast.Slices.Slice.SourceFile.Function.Builder builderForValue) { + if (functionBuilder_ == null) { + ensureFunctionIsMutable(); + function_.add(builderForValue.build()); + onChanged(); + } else { + functionBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder addFunction( + int index, fast.Fast.Slices.Slice.SourceFile.Function.Builder builderForValue) { + if (functionBuilder_ == null) { + ensureFunctionIsMutable(); + function_.add(index, builderForValue.build()); + onChanged(); + } else { + functionBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder addAllFunction( + java.lang.Iterable values) { + if (functionBuilder_ == null) { + ensureFunctionIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, function_); + onChanged(); + } else { + functionBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder clearFunction() { + if (functionBuilder_ == null) { + function_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + functionBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public Builder removeFunction(int index) { + if (functionBuilder_ == null) { + ensureFunctionIsMutable(); + function_.remove(index); + onChanged(); + } else { + functionBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Builder getFunctionBuilder( + int index) { + return getFunctionFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder getFunctionOrBuilder( + int index) { + if (functionBuilder_ == null) { + return function_.get(index); } else { + return functionBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public java.util.List + getFunctionOrBuilderList() { + if (functionBuilder_ != null) { + return functionBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(function_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Builder addFunctionBuilder() { + return getFunctionFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.Function.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Function.Builder addFunctionBuilder( + int index) { + return getFunctionFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.Function.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile.Function function = 1; + */ + public java.util.List + getFunctionBuilderList() { + return getFunctionFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function, fast.Fast.Slices.Slice.SourceFile.Function.Builder, fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder> + getFunctionFieldBuilder() { + if (functionBuilder_ == null) { + functionBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile.Function, fast.Fast.Slices.Slice.SourceFile.Function.Builder, fast.Fast.Slices.Slice.SourceFile.FunctionOrBuilder>( + function_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + function_ = null; + } + return functionBuilder_; + } + + private java.lang.Object name_ = ""; + /** + * string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 2; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string name = 2; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private int type_ = 0; + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public int getTypeValue() { + return type_; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public fast.Fast.Slices.Slice.ChangeType getType() { + fast.Fast.Slices.Slice.ChangeType result = fast.Fast.Slices.Slice.ChangeType.valueOf(type_); + return result == null ? fast.Fast.Slices.Slice.ChangeType.UNRECOGNIZED : result; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder setType(fast.Fast.Slices.Slice.ChangeType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .fast.Slices.Slice.ChangeType type = 3; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice.SourceFile) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice.SourceFile) + private static final fast.Fast.Slices.Slice.SourceFile DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice.SourceFile(); + } + + public static fast.Fast.Slices.Slice.SourceFile getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public SourceFile parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new SourceFile(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice.SourceFile getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int FILE_FIELD_NUMBER = 1; + private java.util.List file_; + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public java.util.List getFileList() { + return file_; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public java.util.List + getFileOrBuilderList() { + return file_; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public int getFileCount() { + return file_.size(); + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFile getFile(int index) { + return file_.get(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFileOrBuilder getFileOrBuilder( + int index) { + return file_.get(index); + } + + public static final int HASH_FIELD_NUMBER = 2; + private volatile java.lang.Object hash_; + /** + * string hash = 2; + */ + public java.lang.String getHash() { + java.lang.Object ref = hash_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + hash_ = s; + return s; + } + } + /** + * string hash = 2; + */ + public com.google.protobuf.ByteString + getHashBytes() { + java.lang.Object ref = hash_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + hash_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < file_.size(); i++) { + output.writeMessage(1, file_.get(i)); + } + if (!getHashBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, hash_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < file_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, file_.get(i)); + } + if (!getHashBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, hash_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices.Slice)) { + return super.equals(obj); + } + fast.Fast.Slices.Slice other = (fast.Fast.Slices.Slice) obj; + + boolean result = true; + result = result && getFileList() + .equals(other.getFileList()); + result = result && getHash() + .equals(other.getHash()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFileCount() > 0) { + hash = (37 * hash) + FILE_FIELD_NUMBER; + hash = (53 * hash) + getFileList().hashCode(); + } + hash = (37 * hash) + HASH_FIELD_NUMBER; + hash = (53 * hash) + getHash().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices.Slice parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices.Slice parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices.Slice parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices.Slice parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices.Slice parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices.Slice prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices.Slice} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices.Slice) + fast.Fast.Slices.SliceOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_Slice_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_Slice_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.Slice.class, fast.Fast.Slices.Slice.Builder.class); + } + + // Construct using fast.Fast.Slices.Slice.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFileFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (fileBuilder_ == null) { + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + fileBuilder_.clear(); + } + hash_ = ""; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_Slice_descriptor; + } + + public fast.Fast.Slices.Slice getDefaultInstanceForType() { + return fast.Fast.Slices.Slice.getDefaultInstance(); + } + + public fast.Fast.Slices.Slice build() { + fast.Fast.Slices.Slice result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices.Slice buildPartial() { + fast.Fast.Slices.Slice result = new fast.Fast.Slices.Slice(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (fileBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + file_ = java.util.Collections.unmodifiableList(file_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.file_ = file_; + } else { + result.file_ = fileBuilder_.build(); + } + result.hash_ = hash_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices.Slice) { + return mergeFrom((fast.Fast.Slices.Slice)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices.Slice other) { + if (other == fast.Fast.Slices.Slice.getDefaultInstance()) return this; + if (fileBuilder_ == null) { + if (!other.file_.isEmpty()) { + if (file_.isEmpty()) { + file_ = other.file_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFileIsMutable(); + file_.addAll(other.file_); + } + onChanged(); + } + } else { + if (!other.file_.isEmpty()) { + if (fileBuilder_.isEmpty()) { + fileBuilder_.dispose(); + fileBuilder_ = null; + file_ = other.file_; + bitField0_ = (bitField0_ & ~0x00000001); + fileBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getFileFieldBuilder() : null; + } else { + fileBuilder_.addAllMessages(other.file_); + } + } + } + if (!other.getHash().isEmpty()) { + hash_ = other.hash_; + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices.Slice parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices.Slice) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List file_ = + java.util.Collections.emptyList(); + private void ensureFileIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + file_ = new java.util.ArrayList(file_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile, fast.Fast.Slices.Slice.SourceFile.Builder, fast.Fast.Slices.Slice.SourceFileOrBuilder> fileBuilder_; + + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public java.util.List getFileList() { + if (fileBuilder_ == null) { + return java.util.Collections.unmodifiableList(file_); + } else { + return fileBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public int getFileCount() { + if (fileBuilder_ == null) { + return file_.size(); + } else { + return fileBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFile getFile(int index) { + if (fileBuilder_ == null) { + return file_.get(index); + } else { + return fileBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder setFile( + int index, fast.Fast.Slices.Slice.SourceFile value) { + if (fileBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.set(index, value); + onChanged(); + } else { + fileBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder setFile( + int index, fast.Fast.Slices.Slice.SourceFile.Builder builderForValue) { + if (fileBuilder_ == null) { + ensureFileIsMutable(); + file_.set(index, builderForValue.build()); + onChanged(); + } else { + fileBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder addFile(fast.Fast.Slices.Slice.SourceFile value) { + if (fileBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(value); + onChanged(); + } else { + fileBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder addFile( + int index, fast.Fast.Slices.Slice.SourceFile value) { + if (fileBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(index, value); + onChanged(); + } else { + fileBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder addFile( + fast.Fast.Slices.Slice.SourceFile.Builder builderForValue) { + if (fileBuilder_ == null) { + ensureFileIsMutable(); + file_.add(builderForValue.build()); + onChanged(); + } else { + fileBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder addFile( + int index, fast.Fast.Slices.Slice.SourceFile.Builder builderForValue) { + if (fileBuilder_ == null) { + ensureFileIsMutable(); + file_.add(index, builderForValue.build()); + onChanged(); + } else { + fileBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder addAllFile( + java.lang.Iterable values) { + if (fileBuilder_ == null) { + ensureFileIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, file_); + onChanged(); + } else { + fileBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder clearFile() { + if (fileBuilder_ == null) { + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + fileBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public Builder removeFile(int index) { + if (fileBuilder_ == null) { + ensureFileIsMutable(); + file_.remove(index); + onChanged(); + } else { + fileBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Builder getFileBuilder( + int index) { + return getFileFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFileOrBuilder getFileOrBuilder( + int index) { + if (fileBuilder_ == null) { + return file_.get(index); } else { + return fileBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public java.util.List + getFileOrBuilderList() { + if (fileBuilder_ != null) { + return fileBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(file_); + } + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Builder addFileBuilder() { + return getFileFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.SourceFile.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public fast.Fast.Slices.Slice.SourceFile.Builder addFileBuilder( + int index) { + return getFileFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.SourceFile.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice.SourceFile file = 1; + */ + public java.util.List + getFileBuilderList() { + return getFileFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile, fast.Fast.Slices.Slice.SourceFile.Builder, fast.Fast.Slices.Slice.SourceFileOrBuilder> + getFileFieldBuilder() { + if (fileBuilder_ == null) { + fileBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice.SourceFile, fast.Fast.Slices.Slice.SourceFile.Builder, fast.Fast.Slices.Slice.SourceFileOrBuilder>( + file_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + file_ = null; + } + return fileBuilder_; + } + + private java.lang.Object hash_ = ""; + /** + * string hash = 2; + */ + public java.lang.String getHash() { + java.lang.Object ref = hash_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + hash_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string hash = 2; + */ + public com.google.protobuf.ByteString + getHashBytes() { + java.lang.Object ref = hash_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + hash_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string hash = 2; + */ + public Builder setHash( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + hash_ = value; + onChanged(); + return this; + } + /** + * string hash = 2; + */ + public Builder clearHash() { + + hash_ = getDefaultInstance().getHash(); + onChanged(); + return this; + } + /** + * string hash = 2; + */ + public Builder setHashBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + hash_ = value; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices.Slice) + } + + // @@protoc_insertion_point(class_scope:fast.Slices.Slice) + private static final fast.Fast.Slices.Slice DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices.Slice(); + } + + public static fast.Fast.Slices.Slice getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Slice parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Slice(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices.Slice getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int SLICE_FIELD_NUMBER = 1; + private java.util.List slice_; + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public java.util.List getSliceList() { + return slice_; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public java.util.List + getSliceOrBuilderList() { + return slice_; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public int getSliceCount() { + return slice_.size(); + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.Slice getSlice(int index) { + return slice_.get(index); + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.SliceOrBuilder getSliceOrBuilder( + int index) { + return slice_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < slice_.size(); i++) { + output.writeMessage(1, slice_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < slice_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, slice_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Slices)) { + return super.equals(obj); + } + fast.Fast.Slices other = (fast.Fast.Slices) obj; + + boolean result = true; + result = result && getSliceList() + .equals(other.getSliceList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getSliceCount() > 0) { + hash = (37 * hash) + SLICE_FIELD_NUMBER; + hash = (53 * hash) + getSliceList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Slices parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Slices parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Slices parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Slices parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Slices parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Slices parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Slices prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Slices} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Slices) + fast.Fast.SlicesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Slices_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Slices_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Slices.class, fast.Fast.Slices.Builder.class); + } + + // Construct using fast.Fast.Slices.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getSliceFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + if (sliceBuilder_ == null) { + slice_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + sliceBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Slices_descriptor; + } + + public fast.Fast.Slices getDefaultInstanceForType() { + return fast.Fast.Slices.getDefaultInstance(); + } + + public fast.Fast.Slices build() { + fast.Fast.Slices result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Slices buildPartial() { + fast.Fast.Slices result = new fast.Fast.Slices(this); + int from_bitField0_ = bitField0_; + if (sliceBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + slice_ = java.util.Collections.unmodifiableList(slice_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.slice_ = slice_; + } else { + result.slice_ = sliceBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Slices) { + return mergeFrom((fast.Fast.Slices)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Slices other) { + if (other == fast.Fast.Slices.getDefaultInstance()) return this; + if (sliceBuilder_ == null) { + if (!other.slice_.isEmpty()) { + if (slice_.isEmpty()) { + slice_ = other.slice_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureSliceIsMutable(); + slice_.addAll(other.slice_); + } + onChanged(); + } + } else { + if (!other.slice_.isEmpty()) { + if (sliceBuilder_.isEmpty()) { + sliceBuilder_.dispose(); + sliceBuilder_ = null; + slice_ = other.slice_; + bitField0_ = (bitField0_ & ~0x00000001); + sliceBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getSliceFieldBuilder() : null; + } else { + sliceBuilder_.addAllMessages(other.slice_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Slices parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Slices) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List slice_ = + java.util.Collections.emptyList(); + private void ensureSliceIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + slice_ = new java.util.ArrayList(slice_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice, fast.Fast.Slices.Slice.Builder, fast.Fast.Slices.SliceOrBuilder> sliceBuilder_; + + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public java.util.List getSliceList() { + if (sliceBuilder_ == null) { + return java.util.Collections.unmodifiableList(slice_); + } else { + return sliceBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public int getSliceCount() { + if (sliceBuilder_ == null) { + return slice_.size(); + } else { + return sliceBuilder_.getCount(); + } + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.Slice getSlice(int index) { + if (sliceBuilder_ == null) { + return slice_.get(index); + } else { + return sliceBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder setSlice( + int index, fast.Fast.Slices.Slice value) { + if (sliceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSliceIsMutable(); + slice_.set(index, value); + onChanged(); + } else { + sliceBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder setSlice( + int index, fast.Fast.Slices.Slice.Builder builderForValue) { + if (sliceBuilder_ == null) { + ensureSliceIsMutable(); + slice_.set(index, builderForValue.build()); + onChanged(); + } else { + sliceBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder addSlice(fast.Fast.Slices.Slice value) { + if (sliceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSliceIsMutable(); + slice_.add(value); + onChanged(); + } else { + sliceBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder addSlice( + int index, fast.Fast.Slices.Slice value) { + if (sliceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSliceIsMutable(); + slice_.add(index, value); + onChanged(); + } else { + sliceBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder addSlice( + fast.Fast.Slices.Slice.Builder builderForValue) { + if (sliceBuilder_ == null) { + ensureSliceIsMutable(); + slice_.add(builderForValue.build()); + onChanged(); + } else { + sliceBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder addSlice( + int index, fast.Fast.Slices.Slice.Builder builderForValue) { + if (sliceBuilder_ == null) { + ensureSliceIsMutable(); + slice_.add(index, builderForValue.build()); + onChanged(); + } else { + sliceBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder addAllSlice( + java.lang.Iterable values) { + if (sliceBuilder_ == null) { + ensureSliceIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, slice_); + onChanged(); + } else { + sliceBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder clearSlice() { + if (sliceBuilder_ == null) { + slice_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + sliceBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public Builder removeSlice(int index) { + if (sliceBuilder_ == null) { + ensureSliceIsMutable(); + slice_.remove(index); + onChanged(); + } else { + sliceBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.Slice.Builder getSliceBuilder( + int index) { + return getSliceFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.SliceOrBuilder getSliceOrBuilder( + int index) { + if (sliceBuilder_ == null) { + return slice_.get(index); } else { + return sliceBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public java.util.List + getSliceOrBuilderList() { + if (sliceBuilder_ != null) { + return sliceBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(slice_); + } + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.Slice.Builder addSliceBuilder() { + return getSliceFieldBuilder().addBuilder( + fast.Fast.Slices.Slice.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public fast.Fast.Slices.Slice.Builder addSliceBuilder( + int index) { + return getSliceFieldBuilder().addBuilder( + index, fast.Fast.Slices.Slice.getDefaultInstance()); + } + /** + * repeated .fast.Slices.Slice slice = 1; + */ + public java.util.List + getSliceBuilderList() { + return getSliceFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice, fast.Fast.Slices.Slice.Builder, fast.Fast.Slices.SliceOrBuilder> + getSliceFieldBuilder() { + if (sliceBuilder_ == null) { + sliceBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Slices.Slice, fast.Fast.Slices.Slice.Builder, fast.Fast.Slices.SliceOrBuilder>( + slice_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + slice_ = null; + } + return sliceBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Slices) + } + + // @@protoc_insertion_point(class_scope:fast.Slices) + private static final fast.Fast.Slices DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Slices(); + } + + public static fast.Fast.Slices getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Slices parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Slices(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Slices getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface BugsOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Bugs) + com.google.protobuf.MessageOrBuilder { + + /** + * string repository = 1; + */ + java.lang.String getRepository(); + /** + * string repository = 1; + */ + com.google.protobuf.ByteString + getRepositoryBytes(); + + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + java.util.List + getBugList(); + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + fast.Fast.Bugs.Bug getBug(int index); + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + int getBugCount(); + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + java.util.List + getBugOrBuilderList(); + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + fast.Fast.Bugs.BugOrBuilder getBugOrBuilder( + int index); + } + /** + * Protobuf type {@code fast.Bugs} + */ + public static final class Bugs extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Bugs) + BugsOrBuilder { + // Use Bugs.newBuilder() to construct. + private Bugs(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Bugs() { + repository_ = ""; + bug_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Bugs( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + repository_ = s; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + bug_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + bug_.add( + input.readMessage(fast.Fast.Bugs.Bug.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + bug_ = java.util.Collections.unmodifiableList(bug_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.class, fast.Fast.Bugs.Builder.class); + } + + public interface BugOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Bugs.Bug) + com.google.protobuf.MessageOrBuilder { + + /** + * bytes id = 1; + */ + com.google.protobuf.ByteString getId(); + + /** + * bytes opendate = 2; + */ + com.google.protobuf.ByteString getOpendate(); + + /** + * bytes fixdate = 3; + */ + com.google.protobuf.ByteString getFixdate(); + + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + boolean hasBuginfo(); + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + fast.Fast.Bugs.Bug.Info getBuginfo(); + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + fast.Fast.Bugs.Bug.InfoOrBuilder getBuginfoOrBuilder(); + + /** + * repeated bytes fixed_file = 5; + */ + java.util.List getFixedFileList(); + /** + * repeated bytes fixed_file = 5; + */ + int getFixedFileCount(); + /** + * repeated bytes fixed_file = 5; + */ + com.google.protobuf.ByteString getFixedFile(int index); + } + /** + * Protobuf type {@code fast.Bugs.Bug} + */ + public static final class Bug extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Bugs.Bug) + BugOrBuilder { + // Use Bug.newBuilder() to construct. + private Bug(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Bug() { + id_ = com.google.protobuf.ByteString.EMPTY; + opendate_ = com.google.protobuf.ByteString.EMPTY; + fixdate_ = com.google.protobuf.ByteString.EMPTY; + fixedFile_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Bug( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + + id_ = input.readBytes(); + break; + } + case 18: { + + opendate_ = input.readBytes(); + break; + } + case 26: { + + fixdate_ = input.readBytes(); + break; + } + case 34: { + fast.Fast.Bugs.Bug.Info.Builder subBuilder = null; + if (buginfo_ != null) { + subBuilder = buginfo_.toBuilder(); + } + buginfo_ = input.readMessage(fast.Fast.Bugs.Bug.Info.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(buginfo_); + buginfo_ = subBuilder.buildPartial(); + } + + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + fixedFile_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + fixedFile_.add(input.readBytes()); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + fixedFile_ = java.util.Collections.unmodifiableList(fixedFile_); + } + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_Bug_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_Bug_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.Bug.class, fast.Fast.Bugs.Bug.Builder.class); + } + + public interface InfoOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Bugs.Bug.Info) + com.google.protobuf.MessageOrBuilder { + + /** + * bytes summary = 1; + */ + com.google.protobuf.ByteString getSummary(); + + /** + * bytes description = 2; + */ + com.google.protobuf.ByteString getDescription(); + } + /** + * Protobuf type {@code fast.Bugs.Bug.Info} + */ + public static final class Info extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Bugs.Bug.Info) + InfoOrBuilder { + // Use Info.newBuilder() to construct. + private Info(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Info() { + summary_ = com.google.protobuf.ByteString.EMPTY; + description_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Info( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + + summary_ = input.readBytes(); + break; + } + case 18: { + + description_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_Bug_Info_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_Bug_Info_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.Bug.Info.class, fast.Fast.Bugs.Bug.Info.Builder.class); + } + + public static final int SUMMARY_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString summary_; + /** + * bytes summary = 1; + */ + public com.google.protobuf.ByteString getSummary() { + return summary_; + } + + public static final int DESCRIPTION_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString description_; + /** + * bytes description = 2; + */ + public com.google.protobuf.ByteString getDescription() { + return description_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!summary_.isEmpty()) { + output.writeBytes(1, summary_); + } + if (!description_.isEmpty()) { + output.writeBytes(2, description_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!summary_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, summary_); + } + if (!description_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, description_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Bugs.Bug.Info)) { + return super.equals(obj); + } + fast.Fast.Bugs.Bug.Info other = (fast.Fast.Bugs.Bug.Info) obj; + + boolean result = true; + result = result && getSummary() + .equals(other.getSummary()); + result = result && getDescription() + .equals(other.getDescription()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SUMMARY_FIELD_NUMBER; + hash = (53 * hash) + getSummary().hashCode(); + hash = (37 * hash) + DESCRIPTION_FIELD_NUMBER; + hash = (53 * hash) + getDescription().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Bugs.Bug.Info parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug.Info parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug.Info parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs.Bug.Info parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug.Info parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug.Info parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Bugs.Bug.Info prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Bugs.Bug.Info} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Bugs.Bug.Info) + fast.Fast.Bugs.Bug.InfoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_Bug_Info_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_Bug_Info_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.Bug.Info.class, fast.Fast.Bugs.Bug.Info.Builder.class); + } + + // Construct using fast.Fast.Bugs.Bug.Info.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + summary_ = com.google.protobuf.ByteString.EMPTY; + + description_ = com.google.protobuf.ByteString.EMPTY; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Bugs_Bug_Info_descriptor; + } + + public fast.Fast.Bugs.Bug.Info getDefaultInstanceForType() { + return fast.Fast.Bugs.Bug.Info.getDefaultInstance(); + } + + public fast.Fast.Bugs.Bug.Info build() { + fast.Fast.Bugs.Bug.Info result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Bugs.Bug.Info buildPartial() { + fast.Fast.Bugs.Bug.Info result = new fast.Fast.Bugs.Bug.Info(this); + result.summary_ = summary_; + result.description_ = description_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Bugs.Bug.Info) { + return mergeFrom((fast.Fast.Bugs.Bug.Info)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Bugs.Bug.Info other) { + if (other == fast.Fast.Bugs.Bug.Info.getDefaultInstance()) return this; + if (other.getSummary() != com.google.protobuf.ByteString.EMPTY) { + setSummary(other.getSummary()); + } + if (other.getDescription() != com.google.protobuf.ByteString.EMPTY) { + setDescription(other.getDescription()); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Bugs.Bug.Info parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Bugs.Bug.Info) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private com.google.protobuf.ByteString summary_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes summary = 1; + */ + public com.google.protobuf.ByteString getSummary() { + return summary_; + } + /** + * bytes summary = 1; + */ + public Builder setSummary(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + summary_ = value; + onChanged(); + return this; + } + /** + * bytes summary = 1; + */ + public Builder clearSummary() { + + summary_ = getDefaultInstance().getSummary(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString description_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes description = 2; + */ + public com.google.protobuf.ByteString getDescription() { + return description_; + } + /** + * bytes description = 2; + */ + public Builder setDescription(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + description_ = value; + onChanged(); + return this; + } + /** + * bytes description = 2; + */ + public Builder clearDescription() { + + description_ = getDefaultInstance().getDescription(); + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Bugs.Bug.Info) + } + + // @@protoc_insertion_point(class_scope:fast.Bugs.Bug.Info) + private static final fast.Fast.Bugs.Bug.Info DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Bugs.Bug.Info(); + } + + public static fast.Fast.Bugs.Bug.Info getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Info parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Info(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Bugs.Bug.Info getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int ID_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString id_; + /** + * bytes id = 1; + */ + public com.google.protobuf.ByteString getId() { + return id_; + } + + public static final int OPENDATE_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString opendate_; + /** + * bytes opendate = 2; + */ + public com.google.protobuf.ByteString getOpendate() { + return opendate_; + } + + public static final int FIXDATE_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString fixdate_; + /** + * bytes fixdate = 3; + */ + public com.google.protobuf.ByteString getFixdate() { + return fixdate_; + } + + public static final int BUGINFO_FIELD_NUMBER = 4; + private fast.Fast.Bugs.Bug.Info buginfo_; + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public boolean hasBuginfo() { + return buginfo_ != null; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public fast.Fast.Bugs.Bug.Info getBuginfo() { + return buginfo_ == null ? fast.Fast.Bugs.Bug.Info.getDefaultInstance() : buginfo_; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public fast.Fast.Bugs.Bug.InfoOrBuilder getBuginfoOrBuilder() { + return getBuginfo(); + } + + public static final int FIXED_FILE_FIELD_NUMBER = 5; + private java.util.List fixedFile_; + /** + * repeated bytes fixed_file = 5; + */ + public java.util.List + getFixedFileList() { + return fixedFile_; + } + /** + * repeated bytes fixed_file = 5; + */ + public int getFixedFileCount() { + return fixedFile_.size(); + } + /** + * repeated bytes fixed_file = 5; + */ + public com.google.protobuf.ByteString getFixedFile(int index) { + return fixedFile_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!id_.isEmpty()) { + output.writeBytes(1, id_); + } + if (!opendate_.isEmpty()) { + output.writeBytes(2, opendate_); + } + if (!fixdate_.isEmpty()) { + output.writeBytes(3, fixdate_); + } + if (buginfo_ != null) { + output.writeMessage(4, getBuginfo()); + } + for (int i = 0; i < fixedFile_.size(); i++) { + output.writeBytes(5, fixedFile_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!id_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, id_); + } + if (!opendate_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, opendate_); + } + if (!fixdate_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, fixdate_); + } + if (buginfo_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getBuginfo()); + } + { + int dataSize = 0; + for (int i = 0; i < fixedFile_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(fixedFile_.get(i)); + } + size += dataSize; + size += 1 * getFixedFileList().size(); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Bugs.Bug)) { + return super.equals(obj); + } + fast.Fast.Bugs.Bug other = (fast.Fast.Bugs.Bug) obj; + + boolean result = true; + result = result && getId() + .equals(other.getId()); + result = result && getOpendate() + .equals(other.getOpendate()); + result = result && getFixdate() + .equals(other.getFixdate()); + result = result && (hasBuginfo() == other.hasBuginfo()); + if (hasBuginfo()) { + result = result && getBuginfo() + .equals(other.getBuginfo()); + } + result = result && getFixedFileList() + .equals(other.getFixedFileList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + ID_FIELD_NUMBER; + hash = (53 * hash) + getId().hashCode(); + hash = (37 * hash) + OPENDATE_FIELD_NUMBER; + hash = (53 * hash) + getOpendate().hashCode(); + hash = (37 * hash) + FIXDATE_FIELD_NUMBER; + hash = (53 * hash) + getFixdate().hashCode(); + if (hasBuginfo()) { + hash = (37 * hash) + BUGINFO_FIELD_NUMBER; + hash = (53 * hash) + getBuginfo().hashCode(); + } + if (getFixedFileCount() > 0) { + hash = (37 * hash) + FIXED_FILE_FIELD_NUMBER; + hash = (53 * hash) + getFixedFileList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Bugs.Bug parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs.Bug parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs.Bug parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs.Bug parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs.Bug parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs.Bug parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Bugs.Bug prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Bugs.Bug} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Bugs.Bug) + fast.Fast.Bugs.BugOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_Bug_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_Bug_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.Bug.class, fast.Fast.Bugs.Bug.Builder.class); + } + + // Construct using fast.Fast.Bugs.Bug.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + id_ = com.google.protobuf.ByteString.EMPTY; + + opendate_ = com.google.protobuf.ByteString.EMPTY; + + fixdate_ = com.google.protobuf.ByteString.EMPTY; + + if (buginfoBuilder_ == null) { + buginfo_ = null; + } else { + buginfo_ = null; + buginfoBuilder_ = null; + } + fixedFile_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Bugs_Bug_descriptor; + } + + public fast.Fast.Bugs.Bug getDefaultInstanceForType() { + return fast.Fast.Bugs.Bug.getDefaultInstance(); + } + + public fast.Fast.Bugs.Bug build() { + fast.Fast.Bugs.Bug result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Bugs.Bug buildPartial() { + fast.Fast.Bugs.Bug result = new fast.Fast.Bugs.Bug(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.id_ = id_; + result.opendate_ = opendate_; + result.fixdate_ = fixdate_; + if (buginfoBuilder_ == null) { + result.buginfo_ = buginfo_; + } else { + result.buginfo_ = buginfoBuilder_.build(); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + fixedFile_ = java.util.Collections.unmodifiableList(fixedFile_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.fixedFile_ = fixedFile_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Bugs.Bug) { + return mergeFrom((fast.Fast.Bugs.Bug)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Bugs.Bug other) { + if (other == fast.Fast.Bugs.Bug.getDefaultInstance()) return this; + if (other.getId() != com.google.protobuf.ByteString.EMPTY) { + setId(other.getId()); + } + if (other.getOpendate() != com.google.protobuf.ByteString.EMPTY) { + setOpendate(other.getOpendate()); + } + if (other.getFixdate() != com.google.protobuf.ByteString.EMPTY) { + setFixdate(other.getFixdate()); + } + if (other.hasBuginfo()) { + mergeBuginfo(other.getBuginfo()); + } + if (!other.fixedFile_.isEmpty()) { + if (fixedFile_.isEmpty()) { + fixedFile_ = other.fixedFile_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureFixedFileIsMutable(); + fixedFile_.addAll(other.fixedFile_); + } + onChanged(); + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Bugs.Bug parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Bugs.Bug) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString id_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes id = 1; + */ + public com.google.protobuf.ByteString getId() { + return id_; + } + /** + * bytes id = 1; + */ + public Builder setId(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + id_ = value; + onChanged(); + return this; + } + /** + * bytes id = 1; + */ + public Builder clearId() { + + id_ = getDefaultInstance().getId(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString opendate_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes opendate = 2; + */ + public com.google.protobuf.ByteString getOpendate() { + return opendate_; + } + /** + * bytes opendate = 2; + */ + public Builder setOpendate(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + opendate_ = value; + onChanged(); + return this; + } + /** + * bytes opendate = 2; + */ + public Builder clearOpendate() { + + opendate_ = getDefaultInstance().getOpendate(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString fixdate_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes fixdate = 3; + */ + public com.google.protobuf.ByteString getFixdate() { + return fixdate_; + } + /** + * bytes fixdate = 3; + */ + public Builder setFixdate(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + fixdate_ = value; + onChanged(); + return this; + } + /** + * bytes fixdate = 3; + */ + public Builder clearFixdate() { + + fixdate_ = getDefaultInstance().getFixdate(); + onChanged(); + return this; + } + + private fast.Fast.Bugs.Bug.Info buginfo_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs.Bug.Info, fast.Fast.Bugs.Bug.Info.Builder, fast.Fast.Bugs.Bug.InfoOrBuilder> buginfoBuilder_; + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public boolean hasBuginfo() { + return buginfoBuilder_ != null || buginfo_ != null; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public fast.Fast.Bugs.Bug.Info getBuginfo() { + if (buginfoBuilder_ == null) { + return buginfo_ == null ? fast.Fast.Bugs.Bug.Info.getDefaultInstance() : buginfo_; + } else { + return buginfoBuilder_.getMessage(); + } + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public Builder setBuginfo(fast.Fast.Bugs.Bug.Info value) { + if (buginfoBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + buginfo_ = value; + onChanged(); + } else { + buginfoBuilder_.setMessage(value); + } + + return this; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public Builder setBuginfo( + fast.Fast.Bugs.Bug.Info.Builder builderForValue) { + if (buginfoBuilder_ == null) { + buginfo_ = builderForValue.build(); + onChanged(); + } else { + buginfoBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public Builder mergeBuginfo(fast.Fast.Bugs.Bug.Info value) { + if (buginfoBuilder_ == null) { + if (buginfo_ != null) { + buginfo_ = + fast.Fast.Bugs.Bug.Info.newBuilder(buginfo_).mergeFrom(value).buildPartial(); + } else { + buginfo_ = value; + } + onChanged(); + } else { + buginfoBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public Builder clearBuginfo() { + if (buginfoBuilder_ == null) { + buginfo_ = null; + onChanged(); + } else { + buginfo_ = null; + buginfoBuilder_ = null; + } + + return this; + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public fast.Fast.Bugs.Bug.Info.Builder getBuginfoBuilder() { + + onChanged(); + return getBuginfoFieldBuilder().getBuilder(); + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + public fast.Fast.Bugs.Bug.InfoOrBuilder getBuginfoOrBuilder() { + if (buginfoBuilder_ != null) { + return buginfoBuilder_.getMessageOrBuilder(); + } else { + return buginfo_ == null ? + fast.Fast.Bugs.Bug.Info.getDefaultInstance() : buginfo_; + } + } + /** + * .fast.Bugs.Bug.Info buginfo = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs.Bug.Info, fast.Fast.Bugs.Bug.Info.Builder, fast.Fast.Bugs.Bug.InfoOrBuilder> + getBuginfoFieldBuilder() { + if (buginfoBuilder_ == null) { + buginfoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs.Bug.Info, fast.Fast.Bugs.Bug.Info.Builder, fast.Fast.Bugs.Bug.InfoOrBuilder>( + getBuginfo(), + getParentForChildren(), + isClean()); + buginfo_ = null; + } + return buginfoBuilder_; + } + + private java.util.List fixedFile_ = java.util.Collections.emptyList(); + private void ensureFixedFileIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + fixedFile_ = new java.util.ArrayList(fixedFile_); + bitField0_ |= 0x00000010; + } + } + /** + * repeated bytes fixed_file = 5; + */ + public java.util.List + getFixedFileList() { + return java.util.Collections.unmodifiableList(fixedFile_); + } + /** + * repeated bytes fixed_file = 5; + */ + public int getFixedFileCount() { + return fixedFile_.size(); + } + /** + * repeated bytes fixed_file = 5; + */ + public com.google.protobuf.ByteString getFixedFile(int index) { + return fixedFile_.get(index); + } + /** + * repeated bytes fixed_file = 5; + */ + public Builder setFixedFile( + int index, com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFixedFileIsMutable(); + fixedFile_.set(index, value); + onChanged(); + return this; + } + /** + * repeated bytes fixed_file = 5; + */ + public Builder addFixedFile(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFixedFileIsMutable(); + fixedFile_.add(value); + onChanged(); + return this; + } + /** + * repeated bytes fixed_file = 5; + */ + public Builder addAllFixedFile( + java.lang.Iterable values) { + ensureFixedFileIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, fixedFile_); + onChanged(); + return this; + } + /** + * repeated bytes fixed_file = 5; + */ + public Builder clearFixedFile() { + fixedFile_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Bugs.Bug) + } + + // @@protoc_insertion_point(class_scope:fast.Bugs.Bug) + private static final fast.Fast.Bugs.Bug DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Bugs.Bug(); + } + + public static fast.Fast.Bugs.Bug getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Bug parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Bug(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Bugs.Bug getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int REPOSITORY_FIELD_NUMBER = 1; + private volatile java.lang.Object repository_; + /** + * string repository = 1; + */ + public java.lang.String getRepository() { + java.lang.Object ref = repository_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + repository_ = s; + return s; + } + } + /** + * string repository = 1; + */ + public com.google.protobuf.ByteString + getRepositoryBytes() { + java.lang.Object ref = repository_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + repository_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int BUG_FIELD_NUMBER = 2; + private java.util.List bug_; + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public java.util.List getBugList() { + return bug_; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public java.util.List + getBugOrBuilderList() { + return bug_; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public int getBugCount() { + return bug_.size(); + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.Bug getBug(int index) { + return bug_.get(index); + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.BugOrBuilder getBugOrBuilder( + int index) { + return bug_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getRepositoryBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, repository_); + } + for (int i = 0; i < bug_.size(); i++) { + output.writeMessage(2, bug_.get(i)); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getRepositoryBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, repository_); + } + for (int i = 0; i < bug_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, bug_.get(i)); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Bugs)) { + return super.equals(obj); + } + fast.Fast.Bugs other = (fast.Fast.Bugs) obj; + + boolean result = true; + result = result && getRepository() + .equals(other.getRepository()); + result = result && getBugList() + .equals(other.getBugList()); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + REPOSITORY_FIELD_NUMBER; + hash = (53 * hash) + getRepository().hashCode(); + if (getBugCount() > 0) { + hash = (37 * hash) + BUG_FIELD_NUMBER; + hash = (53 * hash) + getBugList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Bugs parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Bugs parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Bugs parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Bugs parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Bugs parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Bugs parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Bugs prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Bugs} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Bugs) + fast.Fast.BugsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Bugs_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Bugs_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Bugs.class, fast.Fast.Bugs.Builder.class); + } + + // Construct using fast.Fast.Bugs.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getBugFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + repository_ = ""; + + if (bugBuilder_ == null) { + bug_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + bugBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Bugs_descriptor; + } + + public fast.Fast.Bugs getDefaultInstanceForType() { + return fast.Fast.Bugs.getDefaultInstance(); + } + + public fast.Fast.Bugs build() { + fast.Fast.Bugs result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Bugs buildPartial() { + fast.Fast.Bugs result = new fast.Fast.Bugs(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.repository_ = repository_; + if (bugBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002)) { + bug_ = java.util.Collections.unmodifiableList(bug_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.bug_ = bug_; + } else { + result.bug_ = bugBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Bugs) { + return mergeFrom((fast.Fast.Bugs)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Bugs other) { + if (other == fast.Fast.Bugs.getDefaultInstance()) return this; + if (!other.getRepository().isEmpty()) { + repository_ = other.repository_; + onChanged(); + } + if (bugBuilder_ == null) { + if (!other.bug_.isEmpty()) { + if (bug_.isEmpty()) { + bug_ = other.bug_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureBugIsMutable(); + bug_.addAll(other.bug_); + } + onChanged(); + } + } else { + if (!other.bug_.isEmpty()) { + if (bugBuilder_.isEmpty()) { + bugBuilder_.dispose(); + bugBuilder_ = null; + bug_ = other.bug_; + bitField0_ = (bitField0_ & ~0x00000002); + bugBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getBugFieldBuilder() : null; + } else { + bugBuilder_.addAllMessages(other.bug_); + } + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Bugs parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Bugs) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object repository_ = ""; + /** + * string repository = 1; + */ + public java.lang.String getRepository() { + java.lang.Object ref = repository_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + repository_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string repository = 1; + */ + public com.google.protobuf.ByteString + getRepositoryBytes() { + java.lang.Object ref = repository_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + repository_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string repository = 1; + */ + public Builder setRepository( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + repository_ = value; + onChanged(); + return this; + } + /** + * string repository = 1; + */ + public Builder clearRepository() { + + repository_ = getDefaultInstance().getRepository(); + onChanged(); + return this; + } + /** + * string repository = 1; + */ + public Builder setRepositoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + repository_ = value; + onChanged(); + return this; + } + + private java.util.List bug_ = + java.util.Collections.emptyList(); + private void ensureBugIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + bug_ = new java.util.ArrayList(bug_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Bugs.Bug, fast.Fast.Bugs.Bug.Builder, fast.Fast.Bugs.BugOrBuilder> bugBuilder_; + + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public java.util.List getBugList() { + if (bugBuilder_ == null) { + return java.util.Collections.unmodifiableList(bug_); + } else { + return bugBuilder_.getMessageList(); + } + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public int getBugCount() { + if (bugBuilder_ == null) { + return bug_.size(); + } else { + return bugBuilder_.getCount(); + } + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.Bug getBug(int index) { + if (bugBuilder_ == null) { + return bug_.get(index); + } else { + return bugBuilder_.getMessage(index); + } + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder setBug( + int index, fast.Fast.Bugs.Bug value) { + if (bugBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBugIsMutable(); + bug_.set(index, value); + onChanged(); + } else { + bugBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder setBug( + int index, fast.Fast.Bugs.Bug.Builder builderForValue) { + if (bugBuilder_ == null) { + ensureBugIsMutable(); + bug_.set(index, builderForValue.build()); + onChanged(); + } else { + bugBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder addBug(fast.Fast.Bugs.Bug value) { + if (bugBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBugIsMutable(); + bug_.add(value); + onChanged(); + } else { + bugBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder addBug( + int index, fast.Fast.Bugs.Bug value) { + if (bugBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBugIsMutable(); + bug_.add(index, value); + onChanged(); + } else { + bugBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder addBug( + fast.Fast.Bugs.Bug.Builder builderForValue) { + if (bugBuilder_ == null) { + ensureBugIsMutable(); + bug_.add(builderForValue.build()); + onChanged(); + } else { + bugBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder addBug( + int index, fast.Fast.Bugs.Bug.Builder builderForValue) { + if (bugBuilder_ == null) { + ensureBugIsMutable(); + bug_.add(index, builderForValue.build()); + onChanged(); + } else { + bugBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder addAllBug( + java.lang.Iterable values) { + if (bugBuilder_ == null) { + ensureBugIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, bug_); + onChanged(); + } else { + bugBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder clearBug() { + if (bugBuilder_ == null) { + bug_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + bugBuilder_.clear(); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public Builder removeBug(int index) { + if (bugBuilder_ == null) { + ensureBugIsMutable(); + bug_.remove(index); + onChanged(); + } else { + bugBuilder_.remove(index); + } + return this; + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.Bug.Builder getBugBuilder( + int index) { + return getBugFieldBuilder().getBuilder(index); + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.BugOrBuilder getBugOrBuilder( + int index) { + if (bugBuilder_ == null) { + return bug_.get(index); } else { + return bugBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public java.util.List + getBugOrBuilderList() { + if (bugBuilder_ != null) { + return bugBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(bug_); + } + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.Bug.Builder addBugBuilder() { + return getBugFieldBuilder().addBuilder( + fast.Fast.Bugs.Bug.getDefaultInstance()); + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public fast.Fast.Bugs.Bug.Builder addBugBuilder( + int index) { + return getBugFieldBuilder().addBuilder( + index, fast.Fast.Bugs.Bug.getDefaultInstance()); + } + /** + * repeated .fast.Bugs.Bug bug = 2; + */ + public java.util.List + getBugBuilderList() { + return getBugFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Bugs.Bug, fast.Fast.Bugs.Bug.Builder, fast.Fast.Bugs.BugOrBuilder> + getBugFieldBuilder() { + if (bugBuilder_ == null) { + bugBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + fast.Fast.Bugs.Bug, fast.Fast.Bugs.Bug.Builder, fast.Fast.Bugs.BugOrBuilder>( + bug_, + ((bitField0_ & 0x00000002) == 0x00000002), + getParentForChildren(), + isClean()); + bug_ = null; + } + return bugBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Bugs) + } + + // @@protoc_insertion_point(class_scope:fast.Bugs) + private static final fast.Fast.Bugs DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Bugs(); + } + + public static fast.Fast.Bugs getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Bugs parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Bugs(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Bugs getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DataOrBuilder extends + // @@protoc_insertion_point(interface_extends:fast.Data) + com.google.protobuf.MessageOrBuilder { + + /** + * .fast.Element element = 1; + */ + fast.Fast.Element getElement(); + /** + * .fast.Element element = 1; + */ + fast.Fast.ElementOrBuilder getElementOrBuilder(); + + /** + * .fast.Log log = 2; + */ + fast.Fast.Log getLog(); + /** + * .fast.Log log = 2; + */ + fast.Fast.LogOrBuilder getLogOrBuilder(); + + /** + * .fast.Delta delta = 3; + */ + fast.Fast.Delta getDelta(); + /** + * .fast.Delta delta = 3; + */ + fast.Fast.DeltaOrBuilder getDeltaOrBuilder(); + + /** + * .fast.Pairs pairs = 4; + */ + fast.Fast.Pairs getPairs(); + /** + * .fast.Pairs pairs = 4; + */ + fast.Fast.PairsOrBuilder getPairsOrBuilder(); + + /** + * .fast.Slices slices = 5; + */ + fast.Fast.Slices getSlices(); + /** + * .fast.Slices slices = 5; + */ + fast.Fast.SlicesOrBuilder getSlicesOrBuilder(); + + /** + * .fast.Bugs bugs = 6; + */ + fast.Fast.Bugs getBugs(); + /** + * .fast.Bugs bugs = 6; + */ + fast.Fast.BugsOrBuilder getBugsOrBuilder(); + + public fast.Fast.Data.RecordTypeCase getRecordTypeCase(); + } + /** + * Protobuf type {@code fast.Data} + */ + public static final class Data extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:fast.Data) + DataOrBuilder { + // Use Data.newBuilder() to construct. + private Data(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Data() { + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return com.google.protobuf.UnknownFieldSet.getDefaultInstance(); + } + private Data( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!input.skipField(tag)) { + done = true; + } + break; + } + case 10: { + fast.Fast.Element.Builder subBuilder = null; + if (recordTypeCase_ == 1) { + subBuilder = ((fast.Fast.Element) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Element.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Element) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 1; + break; + } + case 18: { + fast.Fast.Log.Builder subBuilder = null; + if (recordTypeCase_ == 2) { + subBuilder = ((fast.Fast.Log) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Log.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Log) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 2; + break; + } + case 26: { + fast.Fast.Delta.Builder subBuilder = null; + if (recordTypeCase_ == 3) { + subBuilder = ((fast.Fast.Delta) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Delta.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Delta) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 3; + break; + } + case 34: { + fast.Fast.Pairs.Builder subBuilder = null; + if (recordTypeCase_ == 4) { + subBuilder = ((fast.Fast.Pairs) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Pairs.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Pairs) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 4; + break; + } + case 42: { + fast.Fast.Slices.Builder subBuilder = null; + if (recordTypeCase_ == 5) { + subBuilder = ((fast.Fast.Slices) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Slices.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Slices) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 5; + break; + } + case 50: { + fast.Fast.Bugs.Builder subBuilder = null; + if (recordTypeCase_ == 6) { + subBuilder = ((fast.Fast.Bugs) recordType_).toBuilder(); + } + recordType_ = + input.readMessage(fast.Fast.Bugs.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((fast.Fast.Bugs) recordType_); + recordType_ = subBuilder.buildPartial(); + } + recordTypeCase_ = 6; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Data_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Data_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Data.class, fast.Fast.Data.Builder.class); + } + + private int recordTypeCase_ = 0; + private java.lang.Object recordType_; + public enum RecordTypeCase + implements com.google.protobuf.Internal.EnumLite { + ELEMENT(1), + LOG(2), + DELTA(3), + PAIRS(4), + SLICES(5), + BUGS(6), + RECORDTYPE_NOT_SET(0); + private final int value; + private RecordTypeCase(int value) { + this.value = value; + } + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static RecordTypeCase valueOf(int value) { + return forNumber(value); + } + + public static RecordTypeCase forNumber(int value) { + switch (value) { + case 1: return ELEMENT; + case 2: return LOG; + case 3: return DELTA; + case 4: return PAIRS; + case 5: return SLICES; + case 6: return BUGS; + case 0: return RECORDTYPE_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public RecordTypeCase + getRecordTypeCase() { + return RecordTypeCase.forNumber( + recordTypeCase_); + } + + public static final int ELEMENT_FIELD_NUMBER = 1; + /** + * .fast.Element element = 1; + */ + public fast.Fast.Element getElement() { + if (recordTypeCase_ == 1) { + return (fast.Fast.Element) recordType_; + } + return fast.Fast.Element.getDefaultInstance(); + } + /** + * .fast.Element element = 1; + */ + public fast.Fast.ElementOrBuilder getElementOrBuilder() { + if (recordTypeCase_ == 1) { + return (fast.Fast.Element) recordType_; + } + return fast.Fast.Element.getDefaultInstance(); + } + + public static final int LOG_FIELD_NUMBER = 2; + /** + * .fast.Log log = 2; + */ + public fast.Fast.Log getLog() { + if (recordTypeCase_ == 2) { + return (fast.Fast.Log) recordType_; + } + return fast.Fast.Log.getDefaultInstance(); + } + /** + * .fast.Log log = 2; + */ + public fast.Fast.LogOrBuilder getLogOrBuilder() { + if (recordTypeCase_ == 2) { + return (fast.Fast.Log) recordType_; + } + return fast.Fast.Log.getDefaultInstance(); + } + + public static final int DELTA_FIELD_NUMBER = 3; + /** + * .fast.Delta delta = 3; + */ + public fast.Fast.Delta getDelta() { + if (recordTypeCase_ == 3) { + return (fast.Fast.Delta) recordType_; + } + return fast.Fast.Delta.getDefaultInstance(); + } + /** + * .fast.Delta delta = 3; + */ + public fast.Fast.DeltaOrBuilder getDeltaOrBuilder() { + if (recordTypeCase_ == 3) { + return (fast.Fast.Delta) recordType_; + } + return fast.Fast.Delta.getDefaultInstance(); + } + + public static final int PAIRS_FIELD_NUMBER = 4; + /** + * .fast.Pairs pairs = 4; + */ + public fast.Fast.Pairs getPairs() { + if (recordTypeCase_ == 4) { + return (fast.Fast.Pairs) recordType_; + } + return fast.Fast.Pairs.getDefaultInstance(); + } + /** + * .fast.Pairs pairs = 4; + */ + public fast.Fast.PairsOrBuilder getPairsOrBuilder() { + if (recordTypeCase_ == 4) { + return (fast.Fast.Pairs) recordType_; + } + return fast.Fast.Pairs.getDefaultInstance(); + } + + public static final int SLICES_FIELD_NUMBER = 5; + /** + * .fast.Slices slices = 5; + */ + public fast.Fast.Slices getSlices() { + if (recordTypeCase_ == 5) { + return (fast.Fast.Slices) recordType_; + } + return fast.Fast.Slices.getDefaultInstance(); + } + /** + * .fast.Slices slices = 5; + */ + public fast.Fast.SlicesOrBuilder getSlicesOrBuilder() { + if (recordTypeCase_ == 5) { + return (fast.Fast.Slices) recordType_; + } + return fast.Fast.Slices.getDefaultInstance(); + } + + public static final int BUGS_FIELD_NUMBER = 6; + /** + * .fast.Bugs bugs = 6; + */ + public fast.Fast.Bugs getBugs() { + if (recordTypeCase_ == 6) { + return (fast.Fast.Bugs) recordType_; + } + return fast.Fast.Bugs.getDefaultInstance(); + } + /** + * .fast.Bugs bugs = 6; + */ + public fast.Fast.BugsOrBuilder getBugsOrBuilder() { + if (recordTypeCase_ == 6) { + return (fast.Fast.Bugs) recordType_; + } + return fast.Fast.Bugs.getDefaultInstance(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (recordTypeCase_ == 1) { + output.writeMessage(1, (fast.Fast.Element) recordType_); + } + if (recordTypeCase_ == 2) { + output.writeMessage(2, (fast.Fast.Log) recordType_); + } + if (recordTypeCase_ == 3) { + output.writeMessage(3, (fast.Fast.Delta) recordType_); + } + if (recordTypeCase_ == 4) { + output.writeMessage(4, (fast.Fast.Pairs) recordType_); + } + if (recordTypeCase_ == 5) { + output.writeMessage(5, (fast.Fast.Slices) recordType_); + } + if (recordTypeCase_ == 6) { + output.writeMessage(6, (fast.Fast.Bugs) recordType_); + } + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (recordTypeCase_ == 1) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, (fast.Fast.Element) recordType_); + } + if (recordTypeCase_ == 2) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, (fast.Fast.Log) recordType_); + } + if (recordTypeCase_ == 3) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, (fast.Fast.Delta) recordType_); + } + if (recordTypeCase_ == 4) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, (fast.Fast.Pairs) recordType_); + } + if (recordTypeCase_ == 5) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, (fast.Fast.Slices) recordType_); + } + if (recordTypeCase_ == 6) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, (fast.Fast.Bugs) recordType_); + } + memoizedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof fast.Fast.Data)) { + return super.equals(obj); + } + fast.Fast.Data other = (fast.Fast.Data) obj; + + boolean result = true; + result = result && getRecordTypeCase().equals( + other.getRecordTypeCase()); + if (!result) return false; + switch (recordTypeCase_) { + case 1: + result = result && getElement() + .equals(other.getElement()); + break; + case 2: + result = result && getLog() + .equals(other.getLog()); + break; + case 3: + result = result && getDelta() + .equals(other.getDelta()); + break; + case 4: + result = result && getPairs() + .equals(other.getPairs()); + break; + case 5: + result = result && getSlices() + .equals(other.getSlices()); + break; + case 6: + result = result && getBugs() + .equals(other.getBugs()); + break; + case 0: + default: + } + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + switch (recordTypeCase_) { + case 1: + hash = (37 * hash) + ELEMENT_FIELD_NUMBER; + hash = (53 * hash) + getElement().hashCode(); + break; + case 2: + hash = (37 * hash) + LOG_FIELD_NUMBER; + hash = (53 * hash) + getLog().hashCode(); + break; + case 3: + hash = (37 * hash) + DELTA_FIELD_NUMBER; + hash = (53 * hash) + getDelta().hashCode(); + break; + case 4: + hash = (37 * hash) + PAIRS_FIELD_NUMBER; + hash = (53 * hash) + getPairs().hashCode(); + break; + case 5: + hash = (37 * hash) + SLICES_FIELD_NUMBER; + hash = (53 * hash) + getSlices().hashCode(); + break; + case 6: + hash = (37 * hash) + BUGS_FIELD_NUMBER; + hash = (53 * hash) + getBugs().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static fast.Fast.Data parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Data parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Data parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Data parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Data parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static fast.Fast.Data parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static fast.Fast.Data parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Data parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Data parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static fast.Fast.Data parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static fast.Fast.Data parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static fast.Fast.Data parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(fast.Fast.Data prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code fast.Data} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:fast.Data) + fast.Fast.DataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return fast.Fast.internal_static_fast_Data_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return fast.Fast.internal_static_fast_Data_fieldAccessorTable + .ensureFieldAccessorsInitialized( + fast.Fast.Data.class, fast.Fast.Data.Builder.class); + } + + // Construct using fast.Fast.Data.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + recordTypeCase_ = 0; + recordType_ = null; + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return fast.Fast.internal_static_fast_Data_descriptor; + } + + public fast.Fast.Data getDefaultInstanceForType() { + return fast.Fast.Data.getDefaultInstance(); + } + + public fast.Fast.Data build() { + fast.Fast.Data result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public fast.Fast.Data buildPartial() { + fast.Fast.Data result = new fast.Fast.Data(this); + if (recordTypeCase_ == 1) { + if (elementBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = elementBuilder_.build(); + } + } + if (recordTypeCase_ == 2) { + if (logBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = logBuilder_.build(); + } + } + if (recordTypeCase_ == 3) { + if (deltaBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = deltaBuilder_.build(); + } + } + if (recordTypeCase_ == 4) { + if (pairsBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = pairsBuilder_.build(); + } + } + if (recordTypeCase_ == 5) { + if (slicesBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = slicesBuilder_.build(); + } + } + if (recordTypeCase_ == 6) { + if (bugsBuilder_ == null) { + result.recordType_ = recordType_; + } else { + result.recordType_ = bugsBuilder_.build(); + } + } + result.recordTypeCase_ = recordTypeCase_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof fast.Fast.Data) { + return mergeFrom((fast.Fast.Data)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(fast.Fast.Data other) { + if (other == fast.Fast.Data.getDefaultInstance()) return this; + switch (other.getRecordTypeCase()) { + case ELEMENT: { + mergeElement(other.getElement()); + break; + } + case LOG: { + mergeLog(other.getLog()); + break; + } + case DELTA: { + mergeDelta(other.getDelta()); + break; + } + case PAIRS: { + mergePairs(other.getPairs()); + break; + } + case SLICES: { + mergeSlices(other.getSlices()); + break; + } + case BUGS: { + mergeBugs(other.getBugs()); + break; + } + case RECORDTYPE_NOT_SET: { + break; + } + } + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + fast.Fast.Data parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (fast.Fast.Data) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int recordTypeCase_ = 0; + private java.lang.Object recordType_; + public RecordTypeCase + getRecordTypeCase() { + return RecordTypeCase.forNumber( + recordTypeCase_); + } + + public Builder clearRecordType() { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + return this; + } + + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> elementBuilder_; + /** + * .fast.Element element = 1; + */ + public fast.Fast.Element getElement() { + if (elementBuilder_ == null) { + if (recordTypeCase_ == 1) { + return (fast.Fast.Element) recordType_; + } + return fast.Fast.Element.getDefaultInstance(); + } else { + if (recordTypeCase_ == 1) { + return elementBuilder_.getMessage(); + } + return fast.Fast.Element.getDefaultInstance(); + } + } + /** + * .fast.Element element = 1; + */ + public Builder setElement(fast.Fast.Element value) { + if (elementBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + elementBuilder_.setMessage(value); + } + recordTypeCase_ = 1; + return this; + } + /** + * .fast.Element element = 1; + */ + public Builder setElement( + fast.Fast.Element.Builder builderForValue) { + if (elementBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + elementBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 1; + return this; + } + /** + * .fast.Element element = 1; + */ + public Builder mergeElement(fast.Fast.Element value) { + if (elementBuilder_ == null) { + if (recordTypeCase_ == 1 && + recordType_ != fast.Fast.Element.getDefaultInstance()) { + recordType_ = fast.Fast.Element.newBuilder((fast.Fast.Element) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 1) { + elementBuilder_.mergeFrom(value); + } + elementBuilder_.setMessage(value); + } + recordTypeCase_ = 1; + return this; + } + /** + * .fast.Element element = 1; + */ + public Builder clearElement() { + if (elementBuilder_ == null) { + if (recordTypeCase_ == 1) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 1) { + recordTypeCase_ = 0; + recordType_ = null; + } + elementBuilder_.clear(); + } + return this; + } + /** + * .fast.Element element = 1; + */ + public fast.Fast.Element.Builder getElementBuilder() { + return getElementFieldBuilder().getBuilder(); + } + /** + * .fast.Element element = 1; + */ + public fast.Fast.ElementOrBuilder getElementOrBuilder() { + if ((recordTypeCase_ == 1) && (elementBuilder_ != null)) { + return elementBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 1) { + return (fast.Fast.Element) recordType_; + } + return fast.Fast.Element.getDefaultInstance(); + } + } + /** + * .fast.Element element = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder> + getElementFieldBuilder() { + if (elementBuilder_ == null) { + if (!(recordTypeCase_ == 1)) { + recordType_ = fast.Fast.Element.getDefaultInstance(); + } + elementBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Element, fast.Fast.Element.Builder, fast.Fast.ElementOrBuilder>( + (fast.Fast.Element) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 1; + onChanged();; + return elementBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log, fast.Fast.Log.Builder, fast.Fast.LogOrBuilder> logBuilder_; + /** + * .fast.Log log = 2; + */ + public fast.Fast.Log getLog() { + if (logBuilder_ == null) { + if (recordTypeCase_ == 2) { + return (fast.Fast.Log) recordType_; + } + return fast.Fast.Log.getDefaultInstance(); + } else { + if (recordTypeCase_ == 2) { + return logBuilder_.getMessage(); + } + return fast.Fast.Log.getDefaultInstance(); + } + } + /** + * .fast.Log log = 2; + */ + public Builder setLog(fast.Fast.Log value) { + if (logBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + logBuilder_.setMessage(value); + } + recordTypeCase_ = 2; + return this; + } + /** + * .fast.Log log = 2; + */ + public Builder setLog( + fast.Fast.Log.Builder builderForValue) { + if (logBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + logBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 2; + return this; + } + /** + * .fast.Log log = 2; + */ + public Builder mergeLog(fast.Fast.Log value) { + if (logBuilder_ == null) { + if (recordTypeCase_ == 2 && + recordType_ != fast.Fast.Log.getDefaultInstance()) { + recordType_ = fast.Fast.Log.newBuilder((fast.Fast.Log) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 2) { + logBuilder_.mergeFrom(value); + } + logBuilder_.setMessage(value); + } + recordTypeCase_ = 2; + return this; + } + /** + * .fast.Log log = 2; + */ + public Builder clearLog() { + if (logBuilder_ == null) { + if (recordTypeCase_ == 2) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 2) { + recordTypeCase_ = 0; + recordType_ = null; + } + logBuilder_.clear(); + } + return this; + } + /** + * .fast.Log log = 2; + */ + public fast.Fast.Log.Builder getLogBuilder() { + return getLogFieldBuilder().getBuilder(); + } + /** + * .fast.Log log = 2; + */ + public fast.Fast.LogOrBuilder getLogOrBuilder() { + if ((recordTypeCase_ == 2) && (logBuilder_ != null)) { + return logBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 2) { + return (fast.Fast.Log) recordType_; + } + return fast.Fast.Log.getDefaultInstance(); + } + } + /** + * .fast.Log log = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log, fast.Fast.Log.Builder, fast.Fast.LogOrBuilder> + getLogFieldBuilder() { + if (logBuilder_ == null) { + if (!(recordTypeCase_ == 2)) { + recordType_ = fast.Fast.Log.getDefaultInstance(); + } + logBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Log, fast.Fast.Log.Builder, fast.Fast.LogOrBuilder>( + (fast.Fast.Log) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 2; + onChanged();; + return logBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta, fast.Fast.Delta.Builder, fast.Fast.DeltaOrBuilder> deltaBuilder_; + /** + * .fast.Delta delta = 3; + */ + public fast.Fast.Delta getDelta() { + if (deltaBuilder_ == null) { + if (recordTypeCase_ == 3) { + return (fast.Fast.Delta) recordType_; + } + return fast.Fast.Delta.getDefaultInstance(); + } else { + if (recordTypeCase_ == 3) { + return deltaBuilder_.getMessage(); + } + return fast.Fast.Delta.getDefaultInstance(); + } + } + /** + * .fast.Delta delta = 3; + */ + public Builder setDelta(fast.Fast.Delta value) { + if (deltaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + deltaBuilder_.setMessage(value); + } + recordTypeCase_ = 3; + return this; + } + /** + * .fast.Delta delta = 3; + */ + public Builder setDelta( + fast.Fast.Delta.Builder builderForValue) { + if (deltaBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + deltaBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 3; + return this; + } + /** + * .fast.Delta delta = 3; + */ + public Builder mergeDelta(fast.Fast.Delta value) { + if (deltaBuilder_ == null) { + if (recordTypeCase_ == 3 && + recordType_ != fast.Fast.Delta.getDefaultInstance()) { + recordType_ = fast.Fast.Delta.newBuilder((fast.Fast.Delta) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 3) { + deltaBuilder_.mergeFrom(value); + } + deltaBuilder_.setMessage(value); + } + recordTypeCase_ = 3; + return this; + } + /** + * .fast.Delta delta = 3; + */ + public Builder clearDelta() { + if (deltaBuilder_ == null) { + if (recordTypeCase_ == 3) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 3) { + recordTypeCase_ = 0; + recordType_ = null; + } + deltaBuilder_.clear(); + } + return this; + } + /** + * .fast.Delta delta = 3; + */ + public fast.Fast.Delta.Builder getDeltaBuilder() { + return getDeltaFieldBuilder().getBuilder(); + } + /** + * .fast.Delta delta = 3; + */ + public fast.Fast.DeltaOrBuilder getDeltaOrBuilder() { + if ((recordTypeCase_ == 3) && (deltaBuilder_ != null)) { + return deltaBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 3) { + return (fast.Fast.Delta) recordType_; + } + return fast.Fast.Delta.getDefaultInstance(); + } + } + /** + * .fast.Delta delta = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta, fast.Fast.Delta.Builder, fast.Fast.DeltaOrBuilder> + getDeltaFieldBuilder() { + if (deltaBuilder_ == null) { + if (!(recordTypeCase_ == 3)) { + recordType_ = fast.Fast.Delta.getDefaultInstance(); + } + deltaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Delta, fast.Fast.Delta.Builder, fast.Fast.DeltaOrBuilder>( + (fast.Fast.Delta) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 3; + onChanged();; + return deltaBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs, fast.Fast.Pairs.Builder, fast.Fast.PairsOrBuilder> pairsBuilder_; + /** + * .fast.Pairs pairs = 4; + */ + public fast.Fast.Pairs getPairs() { + if (pairsBuilder_ == null) { + if (recordTypeCase_ == 4) { + return (fast.Fast.Pairs) recordType_; + } + return fast.Fast.Pairs.getDefaultInstance(); + } else { + if (recordTypeCase_ == 4) { + return pairsBuilder_.getMessage(); + } + return fast.Fast.Pairs.getDefaultInstance(); + } + } + /** + * .fast.Pairs pairs = 4; + */ + public Builder setPairs(fast.Fast.Pairs value) { + if (pairsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + pairsBuilder_.setMessage(value); + } + recordTypeCase_ = 4; + return this; + } + /** + * .fast.Pairs pairs = 4; + */ + public Builder setPairs( + fast.Fast.Pairs.Builder builderForValue) { + if (pairsBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + pairsBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 4; + return this; + } + /** + * .fast.Pairs pairs = 4; + */ + public Builder mergePairs(fast.Fast.Pairs value) { + if (pairsBuilder_ == null) { + if (recordTypeCase_ == 4 && + recordType_ != fast.Fast.Pairs.getDefaultInstance()) { + recordType_ = fast.Fast.Pairs.newBuilder((fast.Fast.Pairs) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 4) { + pairsBuilder_.mergeFrom(value); + } + pairsBuilder_.setMessage(value); + } + recordTypeCase_ = 4; + return this; + } + /** + * .fast.Pairs pairs = 4; + */ + public Builder clearPairs() { + if (pairsBuilder_ == null) { + if (recordTypeCase_ == 4) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 4) { + recordTypeCase_ = 0; + recordType_ = null; + } + pairsBuilder_.clear(); + } + return this; + } + /** + * .fast.Pairs pairs = 4; + */ + public fast.Fast.Pairs.Builder getPairsBuilder() { + return getPairsFieldBuilder().getBuilder(); + } + /** + * .fast.Pairs pairs = 4; + */ + public fast.Fast.PairsOrBuilder getPairsOrBuilder() { + if ((recordTypeCase_ == 4) && (pairsBuilder_ != null)) { + return pairsBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 4) { + return (fast.Fast.Pairs) recordType_; + } + return fast.Fast.Pairs.getDefaultInstance(); + } + } + /** + * .fast.Pairs pairs = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs, fast.Fast.Pairs.Builder, fast.Fast.PairsOrBuilder> + getPairsFieldBuilder() { + if (pairsBuilder_ == null) { + if (!(recordTypeCase_ == 4)) { + recordType_ = fast.Fast.Pairs.getDefaultInstance(); + } + pairsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Pairs, fast.Fast.Pairs.Builder, fast.Fast.PairsOrBuilder>( + (fast.Fast.Pairs) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 4; + onChanged();; + return pairsBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> slicesBuilder_; + /** + * .fast.Slices slices = 5; + */ + public fast.Fast.Slices getSlices() { + if (slicesBuilder_ == null) { + if (recordTypeCase_ == 5) { + return (fast.Fast.Slices) recordType_; + } + return fast.Fast.Slices.getDefaultInstance(); + } else { + if (recordTypeCase_ == 5) { + return slicesBuilder_.getMessage(); + } + return fast.Fast.Slices.getDefaultInstance(); + } + } + /** + * .fast.Slices slices = 5; + */ + public Builder setSlices(fast.Fast.Slices value) { + if (slicesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + slicesBuilder_.setMessage(value); + } + recordTypeCase_ = 5; + return this; + } + /** + * .fast.Slices slices = 5; + */ + public Builder setSlices( + fast.Fast.Slices.Builder builderForValue) { + if (slicesBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + slicesBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 5; + return this; + } + /** + * .fast.Slices slices = 5; + */ + public Builder mergeSlices(fast.Fast.Slices value) { + if (slicesBuilder_ == null) { + if (recordTypeCase_ == 5 && + recordType_ != fast.Fast.Slices.getDefaultInstance()) { + recordType_ = fast.Fast.Slices.newBuilder((fast.Fast.Slices) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 5) { + slicesBuilder_.mergeFrom(value); + } + slicesBuilder_.setMessage(value); + } + recordTypeCase_ = 5; + return this; + } + /** + * .fast.Slices slices = 5; + */ + public Builder clearSlices() { + if (slicesBuilder_ == null) { + if (recordTypeCase_ == 5) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 5) { + recordTypeCase_ = 0; + recordType_ = null; + } + slicesBuilder_.clear(); + } + return this; + } + /** + * .fast.Slices slices = 5; + */ + public fast.Fast.Slices.Builder getSlicesBuilder() { + return getSlicesFieldBuilder().getBuilder(); + } + /** + * .fast.Slices slices = 5; + */ + public fast.Fast.SlicesOrBuilder getSlicesOrBuilder() { + if ((recordTypeCase_ == 5) && (slicesBuilder_ != null)) { + return slicesBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 5) { + return (fast.Fast.Slices) recordType_; + } + return fast.Fast.Slices.getDefaultInstance(); + } + } + /** + * .fast.Slices slices = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder> + getSlicesFieldBuilder() { + if (slicesBuilder_ == null) { + if (!(recordTypeCase_ == 5)) { + recordType_ = fast.Fast.Slices.getDefaultInstance(); + } + slicesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Slices, fast.Fast.Slices.Builder, fast.Fast.SlicesOrBuilder>( + (fast.Fast.Slices) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 5; + onChanged();; + return slicesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs, fast.Fast.Bugs.Builder, fast.Fast.BugsOrBuilder> bugsBuilder_; + /** + * .fast.Bugs bugs = 6; + */ + public fast.Fast.Bugs getBugs() { + if (bugsBuilder_ == null) { + if (recordTypeCase_ == 6) { + return (fast.Fast.Bugs) recordType_; + } + return fast.Fast.Bugs.getDefaultInstance(); + } else { + if (recordTypeCase_ == 6) { + return bugsBuilder_.getMessage(); + } + return fast.Fast.Bugs.getDefaultInstance(); + } + } + /** + * .fast.Bugs bugs = 6; + */ + public Builder setBugs(fast.Fast.Bugs value) { + if (bugsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + recordType_ = value; + onChanged(); + } else { + bugsBuilder_.setMessage(value); + } + recordTypeCase_ = 6; + return this; + } + /** + * .fast.Bugs bugs = 6; + */ + public Builder setBugs( + fast.Fast.Bugs.Builder builderForValue) { + if (bugsBuilder_ == null) { + recordType_ = builderForValue.build(); + onChanged(); + } else { + bugsBuilder_.setMessage(builderForValue.build()); + } + recordTypeCase_ = 6; + return this; + } + /** + * .fast.Bugs bugs = 6; + */ + public Builder mergeBugs(fast.Fast.Bugs value) { + if (bugsBuilder_ == null) { + if (recordTypeCase_ == 6 && + recordType_ != fast.Fast.Bugs.getDefaultInstance()) { + recordType_ = fast.Fast.Bugs.newBuilder((fast.Fast.Bugs) recordType_) + .mergeFrom(value).buildPartial(); + } else { + recordType_ = value; + } + onChanged(); + } else { + if (recordTypeCase_ == 6) { + bugsBuilder_.mergeFrom(value); + } + bugsBuilder_.setMessage(value); + } + recordTypeCase_ = 6; + return this; + } + /** + * .fast.Bugs bugs = 6; + */ + public Builder clearBugs() { + if (bugsBuilder_ == null) { + if (recordTypeCase_ == 6) { + recordTypeCase_ = 0; + recordType_ = null; + onChanged(); + } + } else { + if (recordTypeCase_ == 6) { + recordTypeCase_ = 0; + recordType_ = null; + } + bugsBuilder_.clear(); + } + return this; + } + /** + * .fast.Bugs bugs = 6; + */ + public fast.Fast.Bugs.Builder getBugsBuilder() { + return getBugsFieldBuilder().getBuilder(); + } + /** + * .fast.Bugs bugs = 6; + */ + public fast.Fast.BugsOrBuilder getBugsOrBuilder() { + if ((recordTypeCase_ == 6) && (bugsBuilder_ != null)) { + return bugsBuilder_.getMessageOrBuilder(); + } else { + if (recordTypeCase_ == 6) { + return (fast.Fast.Bugs) recordType_; + } + return fast.Fast.Bugs.getDefaultInstance(); + } + } + /** + * .fast.Bugs bugs = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs, fast.Fast.Bugs.Builder, fast.Fast.BugsOrBuilder> + getBugsFieldBuilder() { + if (bugsBuilder_ == null) { + if (!(recordTypeCase_ == 6)) { + recordType_ = fast.Fast.Bugs.getDefaultInstance(); + } + bugsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + fast.Fast.Bugs, fast.Fast.Bugs.Builder, fast.Fast.BugsOrBuilder>( + (fast.Fast.Bugs) recordType_, + getParentForChildren(), + isClean()); + recordType_ = null; + } + recordTypeCase_ = 6; + onChanged();; + return bugsBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return this; + } + + + // @@protoc_insertion_point(builder_scope:fast.Data) + } + + // @@protoc_insertion_point(class_scope:fast.Data) + private static final fast.Fast.Data DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new fast.Fast.Data(); + } + + public static fast.Fast.Data getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Data parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Data(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public fast.Fast.Data getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Element_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Element_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Element_Unit_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Element_Unit_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Element_Literal_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Element_Literal_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_Match_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_Match_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_Add_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_Add_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_Del_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_Del_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_Move_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_Move_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Delta_Diff_Update_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Delta_Diff_Update_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Pairs_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Pairs_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Pairs_Pair_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Pairs_Pair_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Pairs_Pair_Diff_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Pairs_Pair_Diff_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Commit_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Commit_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Commit_Committer_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Commit_Committer_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Commit_Diff_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Commit_Diff_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Commit_Diff_Hunk_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Commit_Diff_Hunk_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Commit_Diff_Hunk_ModLine_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Log_Author_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Log_Author_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_SourceFile_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_SourceFile_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_SourceFile_Function_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_SourceFile_Function_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Bugs_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Bugs_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Bugs_Bug_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Bugs_Bug_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Bugs_Bug_Info_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Bugs_Bug_Info_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_fast_Data_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_fast_Data_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\nfast.proto\022\004fast\"\3618\n\007Element\022\"\n\004kind\030\001" + + " \001(\0162\022.fast.Element.KindH\000\022%\n\nsmali_kind" + + "\030\002 \001(\0162\017.fast.SmaliKindH\000\022\014\n\004text\030\003 \001(\014\022" + + "\013\n\003pos\030\004 \001(\005\022\016\n\006length\030\005 \001(\005\022\034\n\005child\030\006 " + + "\003(\0132\r.fast.Element\022\014\n\004tail\030\007 \001(\014\022\"\n\004unit" + + "\030\010 \001(\0132\022.fast.Element.UnitH\001\022(\n\007literal\030" + + "\t \001(\0132\025.fast.Element.LiteralH\001\022\014\n\004line\030\n" + + " \001(\005\022\016\n\006column\030\013 \001(\005\022\r\n\005label\030\014 \001(\002\022&\n\006c" + + "hange\030\r \001(\0162\026.fast.Element.DiffType\032\334\001\n\004" + + "Unit\022\020\n\010filename\030\001 \001(\t\022\020\n\010revision\030\002 \001(\t", + "\0221\n\010language\030\003 \001(\0162\037.fast.Element.Unit.L" + + "anguageType\022\014\n\004item\030\004 \001(\005\"o\n\014LanguageTyp" + + "e\022\t\n\005DUMMY\020\000\022\007\n\003ALL\020\001\022\006\n\002OO\020\002\022\007\n\003CXX\020\003\022\005" + + "\n\001C\020\004\022\014\n\010C_FAMILY\020\005\022\010\n\004JAVA\020\006\022\n\n\006CSHARP\020" + + "\007\022\017\n\013OBJECTIVE_C\020\010\032\253\001\n\007Literal\022/\n\004type\030\001" + + " \001(\0162!.fast.Element.Literal.LiteralType\"" + + "o\n\013LiteralType\022\016\n\ndummy_type\020\000\022\017\n\013number" + + "_type\020\001\022\r\n\tchar_type\020\002\022\017\n\013string_type\020\003\022" + + "\020\n\014boolean_type\020\004\022\r\n\tnull_type\020\005\"\2572\n\004Kin" + + "d\022\r\n\tUNIT_KIND\020\000\022\010\n\004DECL\020\001\022\r\n\tDECL_STMT\020", + "\002\022\010\n\004INIT\020\003\022\010\n\004EXPR\020\004\022\r\n\tEXPR_STMT\020\005\022\013\n\007" + + "COMMENT\020\006\022\010\n\004CALL\020\007\022\013\n\007CONTROL\020\010\022\010\n\004INCR" + + "\020\t\022\010\n\004NONE\020\n\022\014\n\010VARIABLE\020\013\022\014\n\010FUNCTION\020\014" + + "\022\021\n\rFUNCTION_DECL\020\r\022\017\n\013CONSTRUCTOR\020\016\022\024\n\020" + + "CONSTRUCTOR_DECL\020\017\022\016\n\nDESTRUCTOR\020\020\022\023\n\017DE" + + "STRUCTOR_DECL\020\021\022\t\n\005MACRO\020\022\022\020\n\014SINGLE_MAC" + + "RO\020\023\022\020\n\014NULLOPERATOR\020\024\022\r\n\tENUM_DEFN\020\025\022\r\n" + + "\tENUM_DECL\020\026\022\024\n\020GLOBAL_ATTRIBUTE\020\027\022\025\n\021PR" + + "OPERTY_ACCESSOR\020\030\022\032\n\026PROPERTY_ACCESSOR_D" + + "ECL\020\031\022\016\n\nEXPRESSION\020\032\022\016\n\nCLASS_DEFN\020\033\022\016\n", + "\nCLASS_DECL\020\034\022\016\n\nUNION_DEFN\020\035\022\016\n\nUNION_D" + + "ECL\020\036\022\017\n\013STRUCT_DEFN\020\037\022\017\n\013STRUCT_DECL\020 \022" + + "\022\n\016INTERFACE_DEFN\020!\022\022\n\016INTERFACE_DECL\020\"\022" + + "\021\n\rACCESS_REGION\020#\022\t\n\005USING\020$\022\025\n\021OPERATO" + + "R_FUNCTION\020%\022\032\n\026OPERATOR_FUNCTION_DECL\020&" + + "\022\t\n\005EVENT\020\'\022\014\n\010PROPERTY\020(\022\023\n\017ANNOTATION_" + + "DEFN\020)\022\023\n\017GLOBAL_TEMPLATE\020*\022\010\n\004UNIT\020+\022\026\n" + + "\022TART_ELEMENT_TOKEN\020,\022\007\n\003NOP\020-\022\n\n\006STRING" + + "\020.\022\010\n\004CHAR\020/\022\013\n\007LITERAL\0200\022\013\n\007BOOLEAN\0201\022\010" + + "\n\004NULL\0202\022\013\n\007COMPLEX\0203\022\014\n\010OPERATOR\0204\022\014\n\010M", + "ODIFIER\0205\022\010\n\004NAME\0206\022\t\n\005ONAME\0207\022\t\n\005CNAME\020" + + "8\022\010\n\004TYPE\0209\022\014\n\010TYPEPREV\020:\022\r\n\tCONDITION\020;" + + "\022\t\n\005BLOCK\020<\022\020\n\014PSEUDO_BLOCK\020=\022\t\n\005INDEX\020>" + + "\022\010\n\004ENUM\020?\022\024\n\020ENUM_DECLARATION\020@\022\020\n\014IF_S" + + "TATEMENT\020A\022\013\n\007TERNARY\020B\022\010\n\004THEN\020C\022\010\n\004ELS" + + "E\020D\022\n\n\006ELSEIF\020E\022\023\n\017WHILE_STATEMENT\020F\022\020\n\014" + + "DO_STATEMENT\020G\022\021\n\rFOR_STATEMENT\020H\022\025\n\021FOR" + + "EACH_STATEMENT\020I\022\017\n\013FOR_CONTROL\020J\022\026\n\022FOR" + + "_INITIALIZATION\020K\022\021\n\rFOR_CONDITION\020L\022\021\n\r" + + "FOR_INCREMENT\020M\022\024\n\020FOR_LIKE_CONTROL\020N\022\030\n", + "\024EXPRESSION_STATEMENT\020O\022\021\n\rFUNCTION_CALL" + + "\020Q\022\031\n\025DECLARATION_STATEMENT\020R\022\017\n\013DECLARA" + + "TION\020S\022\036\n\032DECLARATION_INITIALIZATION\020T\022\025" + + "\n\021DECLARATION_RANGE\020U\022\t\n\005RANGE\020V\022\022\n\016GOTO" + + "_STATEMENT\020W\022\026\n\022CONTINUE_STATEMENT\020X\022\023\n\017" + + "BREAK_STATEMENT\020Y\022\023\n\017LABEL_STATEMENT\020Z\022\t" + + "\n\005LABEL\020[\022\n\n\006SWITCH\020\\\022\010\n\004CASE\020]\022\013\n\007DEFAU" + + "LT\020^\022\027\n\023FUNCTION_DEFINITION\020_\022\030\n\024FUNCTIO" + + "N_DECLARATION\020`\022\n\n\006LAMBDA\020a\022\023\n\017FUNCTION_" + + "LAMBDA\020b\022\026\n\022FUNCTION_SPECIFIER\020c\022\024\n\020RETU", + "RN_STATEMENT\020d\022\022\n\016PARAMETER_LIST\020e\022\r\n\tPA" + + "RAMETER\020f\022\024\n\020KRPARAMETER_LIST\020g\022\017\n\013KRPAR" + + "AMETER\020h\022\021\n\rARGUMENT_LIST\020i\022\014\n\010ARGUMENT\020" + + "j\022\031\n\025PSEUDO_PARAMETER_LIST\020k\022\032\n\026INDEXER_" + + "PARAMETER_LIST\020l\022\t\n\005CLASS\020m\022\025\n\021CLASS_DEC" + + "LARATION\020n\022\n\n\006STRUCT\020o\022\026\n\022STRUCT_DECLARA" + + "TION\020p\022\t\n\005UNION\020q\022\025\n\021UNION_DECLARATION\020r" + + "\022\023\n\017DERIVATION_LIST\020s\022\021\n\rPUBLIC_ACCESS\020t" + + "\022\031\n\025PUBLIC_ACCESS_DEFAULT\020u\022\022\n\016PRIVATE_A" + + "CCESS\020v\022\032\n\026PRIVATE_ACCESS_DEFAULT\020w\022\024\n\020P", + "ROTECTED_ACCESS\020x\022\034\n\030PROTECTED_ACCESS_DE" + + "FAULT\020y\022\024\n\020MEMBER_INIT_LIST\020z\022\036\n\032MEMBER_" + + "INITIALIZATION_LIST\020{\022\031\n\025MEMBER_INITIALI" + + "ZATION\020|\022\032\n\026CONSTRUCTOR_DEFINITION\020}\022\033\n\027" + + "CONSTRUCTOR_DECLARATION\020~\022\031\n\025DESTRUCTOR_" + + "DEFINITION\020\177\022\033\n\026DESTRUCTOR_DECLARATION\020\200" + + "\001\022\013\n\006FRIEND\020\201\001\022\024\n\017CLASS_SPECIFIER\020\202\001\022\016\n\t" + + "TRY_BLOCK\020\203\001\022\020\n\013CATCH_BLOCK\020\204\001\022\022\n\rFINALL" + + "Y_BLOCK\020\205\001\022\024\n\017THROW_STATEMENT\020\206\001\022\024\n\017THRO" + + "W_SPECIFIER\020\207\001\022\031\n\024THROW_SPECIFIER_JAVA\020\210", + "\001\022\r\n\010TEMPLATE\020\211\001\022\025\n\020GENERIC_ARGUMENT\020\212\001\022" + + "\032\n\025GENERIC_ARGUMENT_LIST\020\213\001\022\027\n\022TEMPLATE_" + + "PARAMETER\020\214\001\022\034\n\027TEMPLATE_PARAMETER_LIST\020" + + "\215\001\022\026\n\021GENERIC_PARAMETER\020\216\001\022\033\n\026GENERIC_PA" + + "RAMETER_LIST\020\217\001\022\014\n\007TYPEDEF\020\220\001\022\010\n\003ASM\020\221\001\022" + + "\017\n\nMACRO_CALL\020\222\001\022\020\n\013SIZEOF_CALL\020\223\001\022\013\n\006EX" + + "TERN\020\224\001\022\016\n\tNAMESPACE\020\225\001\022\024\n\017USING_DIRECTI" + + "VE\020\226\001\022\016\n\tDIRECTIVE\020\227\001\022\013\n\006ATOMIC\020\230\001\022\034\n\027ST" + + "ATIC_ASSERT_STATEMENT\020\231\001\022\026\n\021GENERIC_SELE" + + "CTION\020\232\001\022\025\n\020GENERIC_SELECTOR\020\233\001\022\035\n\030GENER", + "IC_ASSOCIATION_LIST\020\234\001\022\030\n\023GENERIC_ASSOCI" + + "ATION\020\235\001\022\014\n\007ALIGNAS\020\236\001\022\r\n\010DECLTYPE\020\237\001\022\014\n" + + "\007CAPTURE\020\240\001\022\023\n\016LAMBDA_CAPTURE\020\241\001\022\r\n\010NOEX" + + "CEPT\020\242\001\022\r\n\010TYPENAME\020\243\001\022\014\n\007ALIGNOF\020\244\001\022\013\n\006" + + "TYPEID\020\245\001\022\020\n\013SIZEOF_PACK\020\246\001\022\017\n\nENUM_CLAS" + + "S\020\247\001\022\033\n\026ENUM_CLASS_DECLARATION\020\250\001\022\022\n\rREF" + + "_QUALIFIER\020\253\001\022\022\n\rSIGNAL_ACCESS\020\254\001\022\026\n\021FOR" + + "EVER_STATEMENT\020\255\001\022\023\n\016EMIT_STATEMENT\020\256\001\022\022" + + "\n\rCPP_DIRECTIVE\020\257\001\022\021\n\014CPP_FILENAME\020\260\001\022\t\n" + + "\004FILE\020\261\001\022\013\n\006NUMBER\020\262\001\022\017\n\nCPP_NUMBER\020\263\001\022\020", + "\n\013CPP_LITERAL\020\264\001\022\023\n\016CPP_MACRO_DEFN\020\265\001\022\024\n" + + "\017CPP_MACRO_VALUE\020\266\001\022\n\n\005ERROR\020\267\001\022\016\n\tCPP_E" + + "RROR\020\270\001\022\020\n\013CPP_WARNING\020\271\001\022\017\n\nCPP_PRAGMA\020" + + "\272\001\022\020\n\013CPP_INCLUDE\020\273\001\022\017\n\nCPP_DEFINE\020\274\001\022\016\n" + + "\tCPP_UNDEF\020\275\001\022\r\n\010CPP_LINE\020\276\001\022\013\n\006CPP_IF\020\277" + + "\001\022\016\n\tCPP_IFDEF\020\300\001\022\017\n\nCPP_IFNDEF\020\301\001\022\r\n\010CP" + + "P_THEN\020\302\001\022\r\n\010CPP_ELSE\020\303\001\022\r\n\010CPP_ELIF\020\304\001\022" + + "\016\n\tCPP_EMPTY\020\305\001\022\017\n\nCPP_REGION\020\306\001\022\022\n\rCPP_" + + "ENDREGION\020\307\001\022\017\n\nUSING_STMT\020\310\001\022\013\n\006ESCAPE\020" + + "\311\001\022\n\n\005VALUE\020\312\001\022\017\n\nCPP_IMPORT\020\313\001\022\016\n\tCPP_E", + "NDIF\020\314\001\022\013\n\006MARKER\020\315\001\022\020\n\013ERROR_PARSE\020\316\001\022\017" + + "\n\nERROR_MODE\020\317\001\022\017\n\nIMPLEMENTS\020\320\001\022\014\n\007EXTE" + + "NDS\020\321\001\022\013\n\006IMPORT\020\322\001\022\014\n\007PACKAGE\020\323\001\022\025\n\020ASS" + + "ERT_STATEMENT\020\324\001\022\016\n\tINTERFACE\020\325\001\022\032\n\025INTE" + + "RFACE_DECLARATION\020\326\001\022\033\n\026SYNCHRONIZED_STA" + + "TEMENT\020\327\001\022\017\n\nANNOTATION\020\330\001\022\021\n\014STATIC_BLO" + + "CK\020\332\001\022\026\n\021CHECKED_STATEMENT\020\333\001\022\030\n\023UNCHECK" + + "ED_STATEMENT\020\334\001\022\016\n\tATTRIBUTE\020\335\001\022\013\n\006TARGE" + + "T\020\336\001\022\025\n\020UNSAFE_STATEMENT\020\337\001\022\023\n\016LOCK_STAT" + + "EMENT\020\340\001\022\024\n\017FIXED_STATEMENT\020\341\001\022\013\n\006TYPEOF", + "\020\342\001\022\024\n\017USING_STATEMENT\020\343\001\022\026\n\021FUNCTION_DE" + + "LEGATE\020\344\001\022\017\n\nCONSTRAINT\020\346\001\022\t\n\004LINQ\020\347\001\022\t\n" + + "\004FROM\020\350\001\022\n\n\005WHERE\020\351\001\022\013\n\006SELECT\020\352\001\022\010\n\003LET" + + "\020\353\001\022\014\n\007ORDERBY\020\354\001\022\t\n\004JOIN\020\355\001\022\n\n\005GROUP\020\356\001" + + "\022\007\n\002IN\020\357\001\022\007\n\002ON\020\360\001\022\013\n\006EQUALS\020\361\001\022\007\n\002BY\020\362\001" + + "\022\t\n\004INTO\020\363\001\022\n\n\005EMPTY\020\364\001\022\017\n\nEMPTY_STMT\020\365\001" + + "\022\r\n\010RECEIVER\020\366\001\022\014\n\007MESSAGE\020\367\001\022\r\n\010SELECTO" + + "R\020\370\001\022\022\n\rPROTOCOL_LIST\020\371\001\022\r\n\010CATEGORY\020\372\001\022" + + "\r\n\010PROTOCOL\020\373\001\022\025\n\020REQUIRED_DEFAULT\020\374\001\022\r\n" + + "\010REQUIRED\020\375\001\022\r\n\010OPTIONAL\020\376\001\022\023\n\016ATTRIBUTE", + "_LIST\020\200\002\022\017\n\nSYNTHESIZE\020\201\002\022\014\n\007DYNAMIC\020\202\002\022" + + "\013\n\006ENCODE\020\203\002\022\024\n\017AUTORELEASEPOOL\020\204\002\022\030\n\023CO" + + "MPATIBILITY_ALIAS\020\205\002\022\010\n\003NIL\020\206\002\022\024\n\017CLASS_" + + "INTERFACE\020\207\002\022\031\n\024CLASS_IMPLEMENTATION\020\210\002\022" + + "\031\n\024PROTOCOL_DECLARATION\020\211\002\022\t\n\004CAST\020\212\002\022\017\n" + + "\nCONST_CAST\020\213\002\022\021\n\014DYNAMIC_CAST\020\214\002\022\025\n\020REI" + + "NTERPRET_CAST\020\215\002\022\020\n\013STATIC_CAST\020\216\002\022\r\n\010PO" + + "SITION\020\217\002\022\027\n\022CUDA_ARGUMENT_LIST\020\220\002\022\022\n\rOM" + + "P_DIRECTIVE\020\221\002\022\r\n\010OMP_NAME\020\222\002\022\017\n\nOMP_CLA" + + "USE\020\223\002\022\026\n\021OMP_ARGUMENT_LIST\020\224\002\022\021\n\014OMP_AR", + "GUMENT\020\225\002\022\023\n\016OMP_EXPRESSION\020\226\002\022\026\n\021END_EL" + + "EMENT_TOKEN\020\227\002\022\t\n\004MAIN\020\230\002\022\n\n\005BREAK\020\231\002\022\r\n" + + "\010CONTINUE\020\232\002\022\n\n\005WHILE\020\233\002\022\007\n\002DO\020\234\002\022\010\n\003FOR" + + "\020\235\002\022\007\n\002IF\020\236\002\022\t\n\004GOTO\020\245\002\022\023\n\016VISUAL_CXX_AS" + + "M\020\247\002\022\013\n\006SIZEOF\020\250\002\022\t\n\004AUTO\020\252\002\022\r\n\010REGISTER" + + "\020\253\002\022\r\n\010RESTRICT\020\254\002\022\016\n\tIMAGINARY\020\260\002\022\r\n\010NO" + + "RETURN\020\261\002\022\022\n\rSTATIC_ASSERT\020\262\002\022\016\n\tCRESTRI" + + "CT\020\263\002\022\014\n\007CXX_TRY\020\264\002\022\016\n\tCXX_CATCH\020\265\002\022\016\n\tC" + + "XX_CLASS\020\266\002\022\016\n\tCONSTEXPR\020\267\002\022\021\n\014THREAD_LO" + + "CAL\020\271\002\022\014\n\007NULLPTR\020\272\002\022\t\n\004VOID\020\306\002\022\013\n\006RETUR", + "N\020\307\002\022\014\n\007INCLUDE\020\310\002\022\013\n\006DEFINE\020\311\002\022\t\n\004ELIF\020" + + "\312\002\022\n\n\005ENDIF\020\313\002\022\016\n\tERRORPREC\020\314\002\022\014\n\007WARNIN" + + "G\020\315\002\022\n\n\005IFDEF\020\316\002\022\013\n\006IFNDEF\020\317\002\022\t\n\004LINE\020\320\002" + + "\022\013\n\006PRAGMA\020\321\002\022\n\n\005UNDEF\020\322\002\022\013\n\006INLINE\020\323\002\022\024" + + "\n\017MACRO_TYPE_NAME\020\324\002\022\017\n\nMACRO_CASE\020\325\002\022\020\n" + + "\013MACRO_LABEL\020\326\002\022\016\n\tSPECIFIER\020\330\002\022\010\n\003TRY\020\331" + + "\002\022\n\n\005CATCH\020\332\002\022\n\n\005THROW\020\333\002\022\013\n\006THROWS\020\334\002\022\013" + + "\n\006PUBLIC\020\336\002\022\014\n\007PRIVATE\020\337\002\022\016\n\tPROTECTED\020\340" + + "\002\022\014\n\007VIRTUAL\020\341\002\022\r\n\010EXPLICIT\020\344\002\022\014\n\007FOREVE" + + "R\020\345\002\022\013\n\006SIGNAL\020\346\002\022\t\n\004EMIT\020\347\002\022\010\n\003NEW\020\353\002\022\013", + "\n\006DELETE\020\354\002\022\013\n\006STATIC\020\355\002\022\n\n\005CONST\020\356\002\022\014\n\007" + + "MUTABLE\020\357\002\022\r\n\010VOLATILE\020\360\002\022\016\n\tTRANSIENT\020\361" + + "\002\022\014\n\007FINALLY\020\364\002\022\n\n\005FINAL\020\370\002\022\r\n\010ABSTRACT\020" + + "\371\002\022\n\n\005SUPER\020\372\002\022\021\n\014SYNCHRONIZED\020\373\002\022\013\n\006NAT" + + "IVE\020\374\002\022\r\n\010STRICTFP\020\375\002\022\020\n\013NULLLITERAL\020\376\002\022" + + "\013\n\006ASSERT\020\377\002\022\014\n\007FOREACH\020\200\003\022\010\n\003REF\020\201\003\022\010\n\003" + + "OUT\020\202\003\022\t\n\004LOCK\020\204\003\022\007\n\002IS\020\205\003\022\r\n\010INTERNAL\020\206" + + "\003\022\013\n\006SEALED\020\207\003\022\r\n\010OVERRIDE\020\210\003\022\r\n\010IMPLICI" + + "T\020\211\003\022\017\n\nSTACKALLOC\020\212\003\022\007\n\002AS\020\213\003\022\r\n\010DELEGA" + + "TE\020\214\003\022\n\n\005FIXED\020\215\003\022\014\n\007CHECKED\020\216\003\022\016\n\tUNCHE", + "CKED\020\217\003\022\013\n\006REGION\020\220\003\022\016\n\tENDREGION\020\221\003\022\013\n\006" + + "UNSAFE\020\222\003\022\r\n\010READONLY\020\223\003\022\010\n\003GET\020\224\003\022\010\n\003SE" + + "T\020\225\003\022\010\n\003ADD\020\226\003\022\013\n\006REMOVE\020\227\003\022\n\n\005YIELD\020\230\003\022" + + "\014\n\007PARTIAL\020\231\003\022\n\n\005AWAIT\020\232\003\022\n\n\005ASYNC\020\234\003\022\t\n" + + "\004THIS\020\235\003\022\013\n\006PARAMS\020\236\003\022\n\n\005ALIAS\020\240\003\022\016\n\tASC" + + "ENDING\020\246\003\022\017\n\nDESCENDING\020\247\003\022\020\n\013ATINTERFAC" + + "E\020\256\003\022\025\n\020ATIMPLEMENTATION\020\257\003\022\n\n\005ATEND\020\260\003\022" + + "\017\n\nATPROTOCOL\020\261\003\022\017\n\nATREQUIRED\020\262\003\022\017\n\nATO" + + "PTIONAL\020\263\003\022\014\n\007ATCLASS\020\271\003\022\t\n\004WEAK\020\273\003\022\013\n\006S" + + "TRONG\020\274\003\022\014\n\007OMP_OMP\020\300\003\022\022\n\rSPECIAL_CHARS\020", + "\301\003\"Q\n\010DiffType\022\013\n\007MATCHED\020\000\022\t\n\005ADDED\020\001\022\013" + + "\n\007DELETED\020\002\022\020\n\014CHANGED_FROM\020\003\022\016\n\nCHANGED" + + "_TO\020\004B\006\n\004typeB\007\n\005extra\"\304\004\n\005Delta\022\013\n\003src\030" + + "\001 \001(\t\022\013\n\003dst\030\002 \001(\t\022\036\n\004diff\030\003 \003(\0132\020.fast." + + "Delta.Diff\032\200\004\n\004Diff\022(\n\004type\030\001 \001(\0162\032.fast" + + ".Delta.Diff.DeltaType\022\'\n\005match\030\002 \001(\0132\026.f" + + "ast.Delta.Diff.MatchH\000\022#\n\003add\030\003 \001(\0132\024.fa" + + "st.Delta.Diff.AddH\000\022#\n\003del\030\004 \001(\0132\024.fast." + + "Delta.Diff.DelH\000\022%\n\004move\030\005 \001(\0132\025.fast.De" + + "lta.Diff.MoveH\000\022)\n\006update\030\006 \001(\0132\027.fast.D", + "elta.Diff.UpdateH\000\032!\n\005Match\022\013\n\003src\030\001 \001(\005" + + "\022\013\n\003dst\030\002 \001(\005\0321\n\003Add\022\013\n\003src\030\001 \001(\005\022\013\n\003dst" + + "\030\002 \001(\005\022\020\n\010position\030\003 \001(\005\032\022\n\003Del\022\013\n\003src\030\001" + + " \001(\005\0322\n\004Move\022\013\n\003src\030\001 \001(\005\022\013\n\003dst\030\002 \001(\005\022\020" + + "\n\010position\030\003 \001(\005\032\"\n\006Update\022\013\n\003src\030\001 \001(\005\022" + + "\013\n\003dst\030\002 \001(\005\">\n\tDeltaType\022\t\n\005MATCH\020\000\022\007\n\003" + + "ADD\020\001\022\007\n\003DEL\020\002\022\010\n\004MOVE\020\003\022\n\n\006UPDATE\020\004B\007\n\005" + + "delta\"\250\003\n\005Pairs\022\036\n\004pair\030\001 \003(\0132\020.fast.Pai" + + "rs.Pair\032\376\002\n\004Pair\022#\n\004left\030\001 \001(\0132\025.fast.Pa" + + "irs.Pair.Diff\022$\n\005right\030\002 \001(\0132\025.fast.Pair", + "s.Pair.Diff\022(\n\004type\030\003 \001(\0162\032.fast.Pairs.P" + + "air.CloneType\032\327\001\n\004Diff\022\017\n\007project\030\001 \001(\t\022" + + "\021\n\tleft_line\030\002 \001(\005\022\023\n\013left_column\030\003 \001(\005\022" + + "\022\n\nright_line\030\004 \001(\005\022\024\n\014right_column\030\005 \001(" + + "\005\022\037\n\010old_code\030\006 \001(\0132\r.fast.Element\022\037\n\010ne" + + "w_code\030\007 \001(\0132\r.fast.Element\022\014\n\004hash\030\010 \001(" + + "\t\022\034\n\006slices\030\t \001(\0132\014.fast.Slices\"\'\n\tClone" + + "Type\022\t\n\005MAYBE\020\000\022\007\n\003YES\020\001\022\006\n\002NO\020\002\"\254\006\n\003Log" + + "\022 \n\006commit\030\001 \003(\0132\020.fast.Log.Commit\022 \n\006au" + + "thor\030\002 \003(\0132\020.fast.Log.Author\032\255\005\n\006Commit\022", + "\n\n\002id\030\001 \001(\t\022\014\n\004text\030\002 \001(\014\022\021\n\tauthor_id\030\003" + + " \001(\005\022\023\n\013author_date\030\004 \001(\t\022/\n\tcommitter\030\005" + + " \001(\0132\032.fast.Log.Commit.CommitterH\000\022#\n\004di" + + "ff\030\006 \003(\0132\025.fast.Log.Commit.Diff\022\033\n\005slice" + + "\030\007 \001(\0132\014.fast.Slices\0326\n\tCommitter\022\024\n\014com" + + "mitter_id\030\001 \001(\005\022\023\n\013commit_date\030\002 \001(\t\032\254\003\n" + + "\004Diff\022\t\n\001a\030\001 \001(\t\022\t\n\001b\030\002 \001(\t\022\016\n\006is_new\030\003 " + + "\001(\010\022\017\n\007is_code\030\004 \001(\t\022\022\n\nindex_from\030\005 \001(\t" + + "\022\020\n\010index_to\030\006 \001(\t\022\014\n\004mode\030\007 \001(\t\022(\n\004hunk" + + "\030\010 \003(\0132\032.fast.Log.Commit.Diff.Hunk\032\216\002\n\004H", + "unk\022\023\n\013from_lineno\030\001 \001(\005\022\023\n\013from_column\030" + + "\002 \001(\005\022\021\n\tto_lineno\030\003 \001(\005\022\021\n\tto_column\030\004 " + + "\001(\005\022\017\n\007context\030\005 \001(\t\022\036\n\007element\030\006 \003(\0132\r." + + "fast.Element\022/\n\003mod\030\007 \003(\0132\".fast.Log.Com" + + "mit.Diff.Hunk.ModLine\022\033\n\005slice\030\010 \001(\0132\014.f" + + "ast.Slices\0327\n\007ModLine\022\014\n\004line\030\001 \001(\014\022\016\n\006i" + + "s_add\030\002 \001(\010\022\016\n\006is_del\030\003 \001(\010B\007\n\005extra\0321\n\006" + + "Author\022\n\n\002id\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\022\r\n\005emai" + + "l\030\003 \001(\t\"\303\007\n\006Slices\022!\n\005slice\030\001 \003(\0132\022.fast" + + ".Slices.Slice\032\225\007\n\005Slice\022+\n\004file\030\001 \003(\0132\035.", + "fast.Slices.Slice.SourceFile\022\014\n\004hash\030\002 \001" + + "(\t\032\241\006\n\nSourceFile\0228\n\010function\030\001 \003(\0132&.fa" + + "st.Slices.Slice.SourceFile.Function\022\014\n\004n" + + "ame\030\002 \001(\t\022+\n\004type\030\003 \001(\0162\035.fast.Slices.Sl" + + "ice.ChangeType\032\235\005\n\010Function\022A\n\010variable\030" + + "\001 \003(\0132/.fast.Slices.Slice.SourceFile.Fun" + + "ction.Variable\022\014\n\004name\030\002 \001(\t\022+\n\004type\030\003 \001" + + "(\0162\035.fast.Slices.Slice.ChangeType\032\222\004\n\010Va" + + "riable\022\014\n\004name\030\001 \001(\t\022E\n\003pos\030\002 \001(\01328.fast" + + ".Slices.Slice.SourceFile.Function.Variab", + "le.Position\022+\n\004type\030\003 \001(\0162\035.fast.Slices." + + "Slice.ChangeType\022F\n\004defn\030\004 \003(\01328.fast.Sl" + + "ices.Slice.SourceFile.Function.Variable." + + "Position\022E\n\003use\030\005 \003(\01328.fast.Slices.Slic" + + "e.SourceFile.Function.Variable.Position\022" + + "\014\n\004dvar\030\006 \003(\t\022\r\n\005alias\030\007 \003(\t\022K\n\005cfunc\030\010 " + + "\003(\0132<.fast.Slices.Slice.SourceFile.Funct" + + "ion.Variable.FunctionDecl\032]\n\010Position\022\016\n" + + "\006lineno\030\001 \001(\005\022+\n\004type\030\002 \001(\0162\035.fast.Slice" + + "s.Slice.ChangeType\022\024\n\014delta_lineno\030\005 \001(\005", + "\032,\n\014FunctionDecl\022\014\n\004name\030\001 \001(\t\022\016\n\006lineno" + + "\030\002 \001(\005\"-\n\nChangeType\022\r\n\tUNCHANGED\020\000\022\007\n\003A" + + "DD\020\001\022\007\n\003DEL\020\002\"\326\001\n\004Bugs\022\022\n\nrepository\030\001 \001" + + "(\t\022\033\n\003bug\030\002 \003(\0132\016.fast.Bugs.Bug\032\234\001\n\003Bug\022" + + "\n\n\002id\030\001 \001(\014\022\020\n\010opendate\030\002 \001(\014\022\017\n\007fixdate" + + "\030\003 \001(\014\022$\n\007buginfo\030\004 \001(\0132\023.fast.Bugs.Bug." + + "Info\022\022\n\nfixed_file\030\005 \003(\014\032,\n\004Info\022\017\n\007summ" + + "ary\030\001 \001(\014\022\023\n\013description\030\002 \001(\014\"\310\001\n\004Data\022" + + " \n\007element\030\001 \001(\0132\r.fast.ElementH\000\022\030\n\003log" + + "\030\002 \001(\0132\t.fast.LogH\000\022\034\n\005delta\030\003 \001(\0132\013.fas", + "t.DeltaH\000\022\034\n\005pairs\030\004 \001(\0132\013.fast.PairsH\000\022" + + "\036\n\006slices\030\005 \001(\0132\014.fast.SlicesH\000\022\032\n\004bugs\030" + + "\006 \001(\0132\n.fast.BugsH\000B\014\n\nRecordType*\273\022\n\tSm" + + "aliKind\022\016\n\nsmali_file\020\000\022\016\n\nclass_spec\020\001\022" + + "\016\n\nsuper_spec\020\002\022\023\n\017implements_spec\020\003\022\017\n\013" + + "source_spec\020\004\022\017\n\013access_list\020\005\022\t\n\005field\020" + + "\006\022\n\n\006method\020\007\022\035\n\031statements_and_directiv" + + "es\020\010\022\027\n\023ordered_method_item\020\t\022\027\n\023registe" + + "rs_directive\020\n\022\024\n\020param_list_or_id\020\013\022\017\n\013" + + "simple_name\020\014\022\017\n\013member_name\020\r\022\024\n\020method", + "_prototype\020\016\022#\n\037param_list_or_id_primiti" + + "ve_type\020\017\022\016\n\nparam_list\020\020\022\024\n\020array_descr" + + "iptor\020\021\022\023\n\017type_descriptor\020\022\022\033\n\027nonvoid_" + + "type_descriptor\020\023\022\035\n\031reference_type_desc" + + "riptor\020\024\022\023\n\017integer_literal\020\025\022\021\n\rfloat_l" + + "iteral\020\026\022\022\n\016double_literal\020\027\022\013\n\007literal\020" + + "\030\022\032\n\026parsed_integer_literal\020\031\022\024\n\020integra" + + "l_literal\020\032\022\027\n\023fixed_32bit_literal\020\033\022\021\n\r" + + "fixed_literal\020\034\022\021\n\rarray_literal\020\035\022\026\n\022an" + + "notation_element\020\036\022\016\n\nannotation\020\037\022\021\n\rsu", + "bannotation\020 \022\020\n\014enum_literal\020!\022\035\n\031type_" + + "field_method_literal\020\"\022\024\n\020method_referen" + + "ce\020#\022\023\n\017field_reference\020$\022\t\n\005label\020%\022\r\n\t" + + "label_ref\020&\022\021\n\rregister_list\020\'\022\022\n\016regist" + + "er_range\020(\022 \n\034verification_error_referen" + + "ce\020)\022\023\n\017catch_directive\020*\022\026\n\022catchall_di" + + "rective\020+\022\027\n\023parameter_directive\020,\022\023\n\017de" + + "bug_directive\020-\022\022\n\016line_directive\020.\022\023\n\017l" + + "ocal_directive\020/\022\027\n\023end_local_directive\020" + + "0\022\033\n\027restart_local_directive\0201\022\026\n\022prolog", + "ue_directive\0202\022\026\n\022epilogue_directive\0203\022\024" + + "\n\020source_directive\0204\022\031\n\025instruction_form" + + "at12x\0205\022\031\n\025instruction_format22s\0206\022\031\n\025in" + + "struction_format31i\0207\022\017\n\013instruction\0208\022\022" + + "\n\016insn_format10t\0209\022\022\n\016insn_format10x\020:\022\027" + + "\n\023insn_format10x_odex\020;\022\022\n\016insn_format11" + + "n\020<\022\022\n\016insn_format11x\020=\022\022\n\016insn_format12" + + "x\020>\022\023\n\017insn_format20bc\020?\022\022\n\016insn_format2" + + "0t\020@\022\030\n\024insn_format21c_field\020A\022\035\n\031insn_f" + + "ormat21c_field_odex\020B\022\031\n\025insn_format21c_", + "string\020C\022\027\n\023insn_format21c_type\020D\022\023\n\017ins" + + "n_format21ih\020E\022\023\n\017insn_format21lh\020F\022\022\n\016i" + + "nsn_format21s\020G\022\022\n\016insn_format21t\020H\022\022\n\016i" + + "nsn_format22b\020I\022\030\n\024insn_format22c_field\020" + + "J\022\035\n\031insn_format22c_field_odex\020K\022\027\n\023insn" + + "_format22c_type\020L\022\031\n\025insn_format22cs_fie" + + "ld\020M\022\022\n\016insn_format22s\020N\022\022\n\016insn_format2" + + "2t\020O\022\022\n\016insn_format22x\020P\022\022\n\016insn_format2" + + "3x\020Q\022\022\n\016insn_format30t\020R\022\022\n\016insn_format3" + + "1c\020S\022\022\n\016insn_format31i\020T\022\022\n\016insn_format3", + "1t\020U\022\022\n\016insn_format32x\020V\022\031\n\025insn_format3" + + "5c_method\020W\022\027\n\023insn_format35c_type\020X\022\036\n\032" + + "insn_format35c_method_odex\020Y\022\032\n\026insn_for" + + "mat35mi_method\020Z\022\032\n\026insn_format35ms_meth" + + "od\020[\022\031\n\025insn_format3rc_method\020\\\022\036\n\032insn_" + + "format3rc_method_odex\020]\022\027\n\023insn_format3r" + + "c_type\020^\022\032\n\026insn_format3rmi_method\020_\022\032\n\026" + + "insn_format3rms_method\020`\022\032\n\026insn_format4" + + "5cc_method\020a\022\032\n\026insn_format4rcc_method\020b" + + "\022\022\n\016insn_format51l\020c\022\035\n\031insn_array_data_", + "directive\020d\022 \n\034insn_packed_switch_direct" + + "ive\020e\022 \n\034insn_sparse_switch_directive\020fb" + + "\006proto3" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_fast_Element_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_fast_Element_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Element_descriptor, + new java.lang.String[] { "Kind", "SmaliKind", "Text", "Pos", "Length", "Child", "Tail", "Unit", "Literal", "Line", "Column", "Label", "Change", "Type", "Extra", }); + internal_static_fast_Element_Unit_descriptor = + internal_static_fast_Element_descriptor.getNestedTypes().get(0); + internal_static_fast_Element_Unit_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Element_Unit_descriptor, + new java.lang.String[] { "Filename", "Revision", "Language", "Item", }); + internal_static_fast_Element_Literal_descriptor = + internal_static_fast_Element_descriptor.getNestedTypes().get(1); + internal_static_fast_Element_Literal_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Element_Literal_descriptor, + new java.lang.String[] { "Type", }); + internal_static_fast_Delta_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_fast_Delta_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_descriptor, + new java.lang.String[] { "Src", "Dst", "Diff", }); + internal_static_fast_Delta_Diff_descriptor = + internal_static_fast_Delta_descriptor.getNestedTypes().get(0); + internal_static_fast_Delta_Diff_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_descriptor, + new java.lang.String[] { "Type", "Match", "Add", "Del", "Move", "Update", "Delta", }); + internal_static_fast_Delta_Diff_Match_descriptor = + internal_static_fast_Delta_Diff_descriptor.getNestedTypes().get(0); + internal_static_fast_Delta_Diff_Match_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_Match_descriptor, + new java.lang.String[] { "Src", "Dst", }); + internal_static_fast_Delta_Diff_Add_descriptor = + internal_static_fast_Delta_Diff_descriptor.getNestedTypes().get(1); + internal_static_fast_Delta_Diff_Add_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_Add_descriptor, + new java.lang.String[] { "Src", "Dst", "Position", }); + internal_static_fast_Delta_Diff_Del_descriptor = + internal_static_fast_Delta_Diff_descriptor.getNestedTypes().get(2); + internal_static_fast_Delta_Diff_Del_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_Del_descriptor, + new java.lang.String[] { "Src", }); + internal_static_fast_Delta_Diff_Move_descriptor = + internal_static_fast_Delta_Diff_descriptor.getNestedTypes().get(3); + internal_static_fast_Delta_Diff_Move_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_Move_descriptor, + new java.lang.String[] { "Src", "Dst", "Position", }); + internal_static_fast_Delta_Diff_Update_descriptor = + internal_static_fast_Delta_Diff_descriptor.getNestedTypes().get(4); + internal_static_fast_Delta_Diff_Update_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Delta_Diff_Update_descriptor, + new java.lang.String[] { "Src", "Dst", }); + internal_static_fast_Pairs_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_fast_Pairs_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Pairs_descriptor, + new java.lang.String[] { "Pair", }); + internal_static_fast_Pairs_Pair_descriptor = + internal_static_fast_Pairs_descriptor.getNestedTypes().get(0); + internal_static_fast_Pairs_Pair_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Pairs_Pair_descriptor, + new java.lang.String[] { "Left", "Right", "Type", }); + internal_static_fast_Pairs_Pair_Diff_descriptor = + internal_static_fast_Pairs_Pair_descriptor.getNestedTypes().get(0); + internal_static_fast_Pairs_Pair_Diff_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Pairs_Pair_Diff_descriptor, + new java.lang.String[] { "Project", "LeftLine", "LeftColumn", "RightLine", "RightColumn", "OldCode", "NewCode", "Hash", "Slices", }); + internal_static_fast_Log_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_fast_Log_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_descriptor, + new java.lang.String[] { "Commit", "Author", }); + internal_static_fast_Log_Commit_descriptor = + internal_static_fast_Log_descriptor.getNestedTypes().get(0); + internal_static_fast_Log_Commit_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Commit_descriptor, + new java.lang.String[] { "Id", "Text", "AuthorId", "AuthorDate", "Committer", "Diff", "Slice", "Extra", }); + internal_static_fast_Log_Commit_Committer_descriptor = + internal_static_fast_Log_Commit_descriptor.getNestedTypes().get(0); + internal_static_fast_Log_Commit_Committer_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Commit_Committer_descriptor, + new java.lang.String[] { "CommitterId", "CommitDate", }); + internal_static_fast_Log_Commit_Diff_descriptor = + internal_static_fast_Log_Commit_descriptor.getNestedTypes().get(1); + internal_static_fast_Log_Commit_Diff_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Commit_Diff_descriptor, + new java.lang.String[] { "A", "B", "IsNew", "IsCode", "IndexFrom", "IndexTo", "Mode", "Hunk", }); + internal_static_fast_Log_Commit_Diff_Hunk_descriptor = + internal_static_fast_Log_Commit_Diff_descriptor.getNestedTypes().get(0); + internal_static_fast_Log_Commit_Diff_Hunk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Commit_Diff_Hunk_descriptor, + new java.lang.String[] { "FromLineno", "FromColumn", "ToLineno", "ToColumn", "Context", "Element", "Mod", "Slice", }); + internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor = + internal_static_fast_Log_Commit_Diff_Hunk_descriptor.getNestedTypes().get(0); + internal_static_fast_Log_Commit_Diff_Hunk_ModLine_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Commit_Diff_Hunk_ModLine_descriptor, + new java.lang.String[] { "Line", "IsAdd", "IsDel", }); + internal_static_fast_Log_Author_descriptor = + internal_static_fast_Log_descriptor.getNestedTypes().get(1); + internal_static_fast_Log_Author_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Log_Author_descriptor, + new java.lang.String[] { "Id", "Name", "Email", }); + internal_static_fast_Slices_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_fast_Slices_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_descriptor, + new java.lang.String[] { "Slice", }); + internal_static_fast_Slices_Slice_descriptor = + internal_static_fast_Slices_descriptor.getNestedTypes().get(0); + internal_static_fast_Slices_Slice_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_descriptor, + new java.lang.String[] { "File", "Hash", }); + internal_static_fast_Slices_Slice_SourceFile_descriptor = + internal_static_fast_Slices_Slice_descriptor.getNestedTypes().get(0); + internal_static_fast_Slices_Slice_SourceFile_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_SourceFile_descriptor, + new java.lang.String[] { "Function", "Name", "Type", }); + internal_static_fast_Slices_Slice_SourceFile_Function_descriptor = + internal_static_fast_Slices_Slice_SourceFile_descriptor.getNestedTypes().get(0); + internal_static_fast_Slices_Slice_SourceFile_Function_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_SourceFile_Function_descriptor, + new java.lang.String[] { "Variable", "Name", "Type", }); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor = + internal_static_fast_Slices_Slice_SourceFile_Function_descriptor.getNestedTypes().get(0); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor, + new java.lang.String[] { "Name", "Pos", "Type", "Defn", "Use", "Dvar", "Alias", "Cfunc", }); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor = + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor.getNestedTypes().get(0); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_Position_descriptor, + new java.lang.String[] { "Lineno", "Type", "DeltaLineno", }); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor = + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_descriptor.getNestedTypes().get(1); + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Slices_Slice_SourceFile_Function_Variable_FunctionDecl_descriptor, + new java.lang.String[] { "Name", "Lineno", }); + internal_static_fast_Bugs_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_fast_Bugs_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Bugs_descriptor, + new java.lang.String[] { "Repository", "Bug", }); + internal_static_fast_Bugs_Bug_descriptor = + internal_static_fast_Bugs_descriptor.getNestedTypes().get(0); + internal_static_fast_Bugs_Bug_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Bugs_Bug_descriptor, + new java.lang.String[] { "Id", "Opendate", "Fixdate", "Buginfo", "FixedFile", }); + internal_static_fast_Bugs_Bug_Info_descriptor = + internal_static_fast_Bugs_Bug_descriptor.getNestedTypes().get(0); + internal_static_fast_Bugs_Bug_Info_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Bugs_Bug_Info_descriptor, + new java.lang.String[] { "Summary", "Description", }); + internal_static_fast_Data_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_fast_Data_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_fast_Data_descriptor, + new java.lang.String[] { "Element", "Log", "Delta", "Pairs", "Slices", "Bugs", "RecordType", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/patch.sh b/patch.sh new file mode 100755 index 000000000..e6b942d2f --- /dev/null +++ b/patch.sh @@ -0,0 +1,12 @@ +#!/bin/bash +if [ ! -d gen.antlr3-smali ]; then + git clone https://github.com/JesusFreke/smali gen.antlr3-smali + cp -r smali.patch/* gen.antlr3-smali + cd !$ + gradle build -x test -x checkstyleMain +fi +gradle build -x test -x checkstyleMain +unzip -o dist/build/distributions/gumtree-20170617-2.1.0-SNAPSHOT.zip +sudo cp -r gumtree-20170617-2.1.0-SNAPSHOT/* /usr/local/ +sudo cp gumtree /usr/local/bin +gumtree diff DuplicateVirtualMethods.smali DuplicateVirtualMethods.smali diff --git a/settings.gradle b/settings.gradle index fa5b0d342..e0ef728fb 100644 --- a/settings.gradle +++ b/settings.gradle @@ -15,4 +15,5 @@ include 'benchmark', 'gen.jdt', 'gen.js', 'gen.ruby', - 'gen.srcml' + 'gen.srcml', + 'gen.pb' diff --git a/smali.patch/gen.antlr3-smali/smali/build.gradle b/smali.patch/gen.antlr3-smali/smali/build.gradle new file mode 100644 index 000000000..5b1567403 --- /dev/null +++ b/smali.patch/gen.antlr3-smali/smali/build.gradle @@ -0,0 +1,154 @@ +/* + * Copyright 2012, Google Inc. + * All rights reserved. + * + * 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. + */ + +apply plugin: 'antlr' +apply plugin: 'org.xbib.gradle.plugin.jflex' + +buildscript { + repositories { + mavenCentral() + } + dependencies { + classpath depends.jflex_plugin + classpath depends.proguard_gradle + } +} + +configurations { + // Remove the full antlr library that's added by the antlr plugin. We manually + // add the smaller antlr_runtime library instead + compile.exclude group: 'org.antlr', module: 'antlr' +} + +sourceSets { + main { + resources { + // This adds the generated .tokens files to the jar + srcDir 'build/generated-src/antlr/main' + } + } +} + +idea { + module { + excludeDirs -= buildDir + if (buildDir.exists()) { + excludeDirs.addAll(buildDir.listFiles()) + } + for (sourceDir in (sourceDirs + testSourceDirs)) { + excludeDirs.remove(sourceDir); + while ((sourceDir = sourceDir.getParentFile()) != null) { + excludeDirs.remove(sourceDir); + } + } + } +} + +dependencies { + compile project(':util') + compile project(':dexlib2') + compile depends.antlr_runtime + compile depends.jcommander + compile depends.stringtemplate + compile files('lib/gen.antlr3-2.1.0-SNAPSHOT.jar', 'lib/core-2.1.0-SNAPSHOT.jar') + runtime files('lib/slf4j-simple-1.7.21.jar') + + testCompile depends.junit + + antlr depends.antlr +} + +processResources.inputs.property('version', version) +processResources.expand('version': version) + +// Build a separate jar that contains all dependencies +task fatJar(type: Jar, dependsOn: jar) { + from sourceSets.main.output + from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } } + + classifier = 'fat' + + manifest { + attributes('Main-Class': 'org.jf.smali.Main') + } + + doLast { + if (!System.getProperty('os.name').toLowerCase().contains('windows')) { + ant.symlink(link: file("${destinationDir}/smali.jar"), resource: archivePath, overwrite: true) + } + } +} +tasks.getByPath('build').dependsOn(fatJar) + +generateTestGrammarSource { + outputDirectory = new File(outputDirectory, 'org/jf/smali') +} + +generateGrammarSource { + outputDirectory = new File(outputDirectory, 'org/jf/smali') +} + +jflex { + generateDir = new File(generateDir, 'org/jf/smali') +} + +uploadArchives { + repositories.mavenDeployer { + pom.project { + description 'smali is an assembler for dalvik bytecode' + scm { + url 'https://github.com/JesusFreke/smali/tree/master/smali' + } + } + } +} + +task proguard(type: proguard.gradle.ProGuardTask, dependsOn: fatJar) { + def outFile = fatJar.destinationDir.getPath() + '/' + fatJar.baseName + '-' + + fatJar.version + '-small' + '.' + fatJar.extension + + injars fatJar.archivePath + outjars outFile + + libraryjars "${System.properties['java.home']}/lib/rt.jar" + + dontobfuscate + dontoptimize + + keep 'public class org.jf.smali.Main { public static void main(java.lang.String[]); }' + keep 'class com.beust.jcommander.** { *; }' + keepclassmembers 'enum * { public static **[] values(); public static ** valueOf(java.lang.String); }' + + dontwarn 'com.google.common.**' + dontnote 'com.google.common.**' +} + +// dependsOn(proguard) diff --git a/smali.patch/gen.antlr3-smali/smali/src/main/java/com/github/gumtreediff/gen/antlr3/smali/SmaliTreeGenerator.java b/smali.patch/gen.antlr3-smali/smali/src/main/java/com/github/gumtreediff/gen/antlr3/smali/SmaliTreeGenerator.java new file mode 100644 index 000000000..8cb9de2ac --- /dev/null +++ b/smali.patch/gen.antlr3-smali/smali/src/main/java/com/github/gumtreediff/gen/antlr3/smali/SmaliTreeGenerator.java @@ -0,0 +1,55 @@ +/* + * This file is part of GumTree. + * + * GumTree is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GumTree is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with GumTree. If not, see . + * + * Copyright 2011-2015 Jean-Rémy Falleri + * Copyright 2011-2015 Floréal Morandat + * Copyright 2017 Yijun Yu + */ + +package com.github.gumtreediff.gen.antlr3.smali; + +import com.github.gumtreediff.gen.antlr3.AbstractAntlr3TreeGenerator; +import com.github.gumtreediff.gen.Register; +import org.antlr.runtime.*; +import org.jf.smali.smaliParser; +import org.jf.smali.smaliFlexLexer; +import java.io.*; + +@Register(id = "smali-antlr", accept = "\\.smali$") +public class SmaliTreeGenerator extends AbstractAntlr3TreeGenerator { + + @Override + protected smaliFlexLexer getLexer(ANTLRStringStream stream) { + smaliFlexLexer lexer = new smaliFlexLexer(new StringReader(stream.toString())); + lexer.setSuppressErrors(true); + return lexer; + } + + @Override + protected smaliParser getParser(TokenStream tokens) { + return new smaliParser(tokens); + } + + @Override + protected RuleReturnScope getStartRule(smaliParser parser) throws RecognitionException { + return parser.smali_file(); + } + + @Override + protected final String[] getTokenNames() { + return smaliParser.tokenNames; + } +} diff --git a/smali.patch/lib/core-2.1.0-SNAPSHOT.jar b/smali.patch/lib/core-2.1.0-SNAPSHOT.jar new file mode 100644 index 000000000..a11ee7ab3 Binary files /dev/null and b/smali.patch/lib/core-2.1.0-SNAPSHOT.jar differ diff --git a/smali.patch/lib/gen.antlr3-2.1.0-SNAPSHOT.jar b/smali.patch/lib/gen.antlr3-2.1.0-SNAPSHOT.jar new file mode 100644 index 000000000..4c2c851ba Binary files /dev/null and b/smali.patch/lib/gen.antlr3-2.1.0-SNAPSHOT.jar differ diff --git a/smali.patch/lib/slf4j-simple-1.7.21.jar b/smali.patch/lib/slf4j-simple-1.7.21.jar new file mode 100644 index 000000000..a4086de0b Binary files /dev/null and b/smali.patch/lib/slf4j-simple-1.7.21.jar differ