From 6ec6169215eb33683728c583e231eb5fe9617813 Mon Sep 17 00:00:00 2001 From: "Shawn O. Pearce" Date: Fri, 13 May 2011 07:44:42 -0700 Subject: [PATCH] DHT: Replace TinyProtobuf with Google Protocol Buffers The standard Google distribution of Protocol Buffers in Java is better maintained than TinyProtobuf, and should be faster for most uses. It does use slightly more memory due to many of our key types being stored as strings in protobuf messages, but this is probably worth the small hit to memory in exchange for better maintained code that is easier to reuse in other applications. Exposing all of our data members to the underlying implementation makes it easier to develop reporting and data mining tools, or to expand out a nested structure like RefData into a flat format in a SQL database table. Since the C++ `protoc` tool is necessary to convert the protobuf script into Java code, the generated files are committed as part of the source repository to make it easier for developers who do not have this tool installed to still build the overall JGit package and make use of it. Reviewers will need to be careful to ensure that any edits made to a *.proto file come in a commit that also updates the generated code to match. CQ: 5135 Change-Id: I53e11e82c186b9cf0d7b368e0276519e6a0b2893 Signed-off-by: Shawn O. Pearce Signed-off-by: Chris Aniszczyk --- .eclipse_iplog | 6 + .../.classpath | 7 + .../.gitignore | 2 + .../.project | 28 + .../org.eclipse.core.resources.prefs | 3 + .../.settings/org.eclipse.core.runtime.prefs | 3 + .../.settings/org.eclipse.jdt.core.prefs | 349 + .../.settings/org.eclipse.jdt.ui.prefs | 62 + .../META-INF/MANIFEST.MF | 11 + .../build.properties | 5 + .../generate.sh | 11 + .../plugin.properties | 2 + .../pom.xml | 120 + .../eclipse/jgit/storage/dht/git_cache.proto | 86 + .../eclipse/jgit/storage/dht/git_store.proto | 13 +- .../generated/storage/dht/proto/GitCache.java | 2546 ++++++ .../generated/storage/dht/proto/GitStore.java | 7963 +++++++++++++++++ .../META-INF/MANIFEST.MF | 4 +- org.eclipse.jgit.storage.dht/pom.xml | 6 + .../jgit/storage/dht/DhtText.properties | 11 +- .../jgit/storage/dht/CachedPackInfo.java | 212 - .../jgit/storage/dht/CachedPackKey.java | 23 +- .../jgit/storage/dht/ChunkFormatter.java | 124 +- .../eclipse/jgit/storage/dht/ChunkInfo.java | 226 +- .../eclipse/jgit/storage/dht/ChunkKey.java | 12 - .../eclipse/jgit/storage/dht/ChunkMeta.java | 391 - .../jgit/storage/dht/ChunkMetaUtil.java | 111 + .../jgit/storage/dht/DhtCachedPack.java | 75 +- .../eclipse/jgit/storage/dht/DhtInserter.java | 44 +- .../jgit/storage/dht/DhtInserterOptions.java | 1 + .../storage/dht/DhtObjectRepresentation.java | 2 +- .../jgit/storage/dht/DhtPackParser.java | 226 +- .../eclipse/jgit/storage/dht/DhtReader.java | 12 +- .../jgit/storage/dht/DhtRefDatabase.java | 69 +- .../jgit/storage/dht/DhtRefUpdate.java | 17 +- .../org/eclipse/jgit/storage/dht/DhtText.java | 9 +- .../jgit/storage/dht/LargeNonDeltaObject.java | 6 +- .../eclipse/jgit/storage/dht/ObjectInfo.java | 158 +- .../jgit/storage/dht/ObjectWriter.java | 14 +- .../eclipse/jgit/storage/dht/PackChunk.java | 32 +- .../eclipse/jgit/storage/dht/Prefetcher.java | 14 +- .../jgit/storage/dht/QueueObjectLookup.java | 5 +- .../jgit/storage/dht/RecentChunks.java | 2 +- .../org/eclipse/jgit/storage/dht/RefData.java | 235 - .../eclipse/jgit/storage/dht/RefDataUtil.java | 132 + .../jgit/storage/dht/TinyProtobuf.java | 755 -- .../jgit/storage/dht/spi/ChunkTable.java | 5 +- .../jgit/storage/dht/spi/RefTable.java | 7 +- .../jgit/storage/dht/spi/RepositoryTable.java | 2 +- .../dht/spi/cache/CacheChunkTable.java | 205 +- .../dht/spi/cache/CacheObjectIndexTable.java | 96 +- .../storage/dht/spi/cache/CacheRefTable.java | 2 +- .../dht/spi/cache/CacheRepositoryTable.java | 34 +- .../storage/dht/spi/memory/MemChunkTable.java | 37 +- .../dht/spi/memory/MemObjectIndexTable.java | 33 +- .../storage/dht/spi/memory/MemRefTable.java | 21 +- .../dht/spi/memory/MemRepositoryTable.java | 24 +- pom.xml | 8 + 58 files changed, 12215 insertions(+), 2404 deletions(-) create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.classpath create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.gitignore create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.project create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.resources.prefs create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.runtime.prefs create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.core.prefs create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.ui.prefs create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/META-INF/MANIFEST.MF create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/build.properties create mode 100755 org.eclipse.jgit.generated.storage.dht.proto/generate.sh create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/plugin.properties create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/pom.xml create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_cache.proto rename {org.eclipse.jgit.storage.dht => org.eclipse.jgit.generated.storage.dht.proto}/resources/org/eclipse/jgit/storage/dht/git_store.proto (95%) create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitCache.java create mode 100644 org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitStore.java delete mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackInfo.java delete mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMeta.java create mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMetaUtil.java delete mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefData.java create mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefDataUtil.java delete mode 100644 org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/TinyProtobuf.java diff --git a/.eclipse_iplog b/.eclipse_iplog index 2f518e123..8707214f7 100644 --- a/.eclipse_iplog +++ b/.eclipse_iplog @@ -120,3 +120,9 @@ license = Apache License, 2.0 use = unmodified source & binary state = approved + +[CQ "5135"] + description = Protocol Buffers Version: 2.4.0a (ATO CQ4876) + license = New BSD license + use = unmodified source & binary + state = approved diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.classpath b/org.eclipse.jgit.generated.storage.dht.proto/.classpath new file mode 100644 index 000000000..304e86186 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.gitignore b/org.eclipse.jgit.generated.storage.dht.proto/.gitignore new file mode 100644 index 000000000..934e0e06f --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.gitignore @@ -0,0 +1,2 @@ +/bin +/target diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.project b/org.eclipse.jgit.generated.storage.dht.proto/.project new file mode 100644 index 000000000..22e79eede --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.project @@ -0,0 +1,28 @@ + + + org.eclipse.jgit.generated.storage.dht.proto + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.pde.PluginNature + + diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.resources.prefs b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 000000000..66ac15c47 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,3 @@ +#Mon Aug 11 16:46:12 PDT 2008 +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.runtime.prefs b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.runtime.prefs new file mode 100644 index 000000000..006e07ede --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.core.runtime.prefs @@ -0,0 +1,3 @@ +#Mon Mar 24 18:55:50 EDT 2008 +eclipse.preferences.version=1 +line.separator=\n diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..5bf676448 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,349 @@ +#Thu May 05 16:40:25 PDT 2011 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=optimize out +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=do not generate +org.eclipse.jdt.core.compiler.debug.localVariable=do not generate +org.eclipse.jdt.core.compiler.debug.sourceFile=do not generate +org.eclipse.jdt.core.compiler.doc.comment.support=disabled +org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=ignore +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.autoboxing=ignore +org.eclipse.jdt.core.compiler.problem.comparingIdentical=ignore +org.eclipse.jdt.core.compiler.problem.deadCode=ignore +org.eclipse.jdt.core.compiler.problem.deprecation=ignore +org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled +org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled +org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore +org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore +org.eclipse.jdt.core.compiler.problem.finalParameterBound=ignore +org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=ignore +org.eclipse.jdt.core.compiler.problem.forbiddenReference=ignore +org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=ignore +org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=ignore +org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore +org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error +org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private +org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocComments=error +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected +org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag +org.eclipse.jdt.core.compiler.problem.missingJavadocTags=error +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=ignore +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=ignore +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore +org.eclipse.jdt.core.compiler.problem.nullReference=ignore +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=ignore +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore +org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=ignore +org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled +org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled +org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore +org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled +org.eclipse.jdt.core.compiler.problem.unusedImport=ignore +org.eclipse.jdt.core.compiler.problem.unusedLabel=ignore +org.eclipse.jdt.core.compiler.problem.unusedLocal=ignore +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled +org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=ignore +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=ignore +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=ignore +org.eclipse.jdt.core.compiler.source=1.5 +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=1 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true +org.eclipse.jdt.core.formatter.comment.indent_root_tags=true +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.lineSplit=80 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=tab +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true diff --git a/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.ui.prefs b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 000000000..7b2cdca10 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.settings/org.eclipse.jdt.ui.prefs @@ -0,0 +1,62 @@ +#Thu Aug 26 12:30:58 CDT 2010 +eclipse.preferences.version=1 +editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true +formatter_profile=_JGit Format +formatter_settings_version=11 +org.eclipse.jdt.ui.ignorelowercasenames=true +org.eclipse.jdt.ui.importorder=java;javax;org;com; +org.eclipse.jdt.ui.ondemandthreshold=99 +org.eclipse.jdt.ui.staticondemandthreshold=99 +org.eclipse.jdt.ui.text.custom_code_templates= +sp_cleanup.add_default_serial_version_id=true +sp_cleanup.add_generated_serial_version_id=false +sp_cleanup.add_missing_annotations=false +sp_cleanup.add_missing_deprecated_annotations=true +sp_cleanup.add_missing_methods=false +sp_cleanup.add_missing_nls_tags=false +sp_cleanup.add_missing_override_annotations=true +sp_cleanup.add_missing_override_annotations_interface_methods=false +sp_cleanup.add_serial_version_id=false +sp_cleanup.always_use_blocks=true +sp_cleanup.always_use_parentheses_in_expressions=false +sp_cleanup.always_use_this_for_non_static_field_access=false +sp_cleanup.always_use_this_for_non_static_method_access=false +sp_cleanup.convert_to_enhanced_for_loop=false +sp_cleanup.correct_indentation=false +sp_cleanup.format_source_code=true +sp_cleanup.format_source_code_changes_only=true +sp_cleanup.make_local_variable_final=false +sp_cleanup.make_parameters_final=false +sp_cleanup.make_private_fields_final=true +sp_cleanup.make_type_abstract_if_missing_method=false +sp_cleanup.make_variable_declarations_final=false +sp_cleanup.never_use_blocks=false +sp_cleanup.never_use_parentheses_in_expressions=true +sp_cleanup.on_save_use_additional_actions=true +sp_cleanup.organize_imports=false +sp_cleanup.qualify_static_field_accesses_with_declaring_class=false +sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_with_declaring_class=false +sp_cleanup.qualify_static_method_accesses_with_declaring_class=false +sp_cleanup.remove_private_constructors=true +sp_cleanup.remove_trailing_whitespaces=true +sp_cleanup.remove_trailing_whitespaces_all=true +sp_cleanup.remove_trailing_whitespaces_ignore_empty=false +sp_cleanup.remove_unnecessary_casts=false +sp_cleanup.remove_unnecessary_nls_tags=false +sp_cleanup.remove_unused_imports=false +sp_cleanup.remove_unused_local_variables=false +sp_cleanup.remove_unused_private_fields=true +sp_cleanup.remove_unused_private_members=false +sp_cleanup.remove_unused_private_methods=true +sp_cleanup.remove_unused_private_types=true +sp_cleanup.sort_members=false +sp_cleanup.sort_members_all=false +sp_cleanup.use_blocks=false +sp_cleanup.use_blocks_only_for_return_and_throw=false +sp_cleanup.use_parentheses_in_expressions=false +sp_cleanup.use_this_for_non_static_field_access=false +sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true +sp_cleanup.use_this_for_non_static_method_access=false +sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true diff --git a/org.eclipse.jgit.generated.storage.dht.proto/META-INF/MANIFEST.MF b/org.eclipse.jgit.generated.storage.dht.proto/META-INF/MANIFEST.MF new file mode 100644 index 000000000..f3d2266c6 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/META-INF/MANIFEST.MF @@ -0,0 +1,11 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: %plugin_name +Bundle-SymbolicName: org.eclipse.jgit.generated.storage.dht.proto +Bundle-Version: 1.0.0.qualifier +Bundle-Localization: plugin +Bundle-Vendor: %provider_name +Bundle-ActivationPolicy: lazy +Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Export-Package: org.eclipse.jgit.generated.storage.dht.proto;version="1.0.0" +Import-Package: com.google.protobuf;version="[2.4.0,2.5.0)" diff --git a/org.eclipse.jgit.generated.storage.dht.proto/build.properties b/org.eclipse.jgit.generated.storage.dht.proto/build.properties new file mode 100644 index 000000000..aa1a00826 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/build.properties @@ -0,0 +1,5 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + .,\ + plugin.properties diff --git a/org.eclipse.jgit.generated.storage.dht.proto/generate.sh b/org.eclipse.jgit.generated.storage.dht.proto/generate.sh new file mode 100755 index 000000000..f80989503 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/generate.sh @@ -0,0 +1,11 @@ +#!/bin/sh +# +# Update generated Java code from protocol buffer descriptions. + +set -e + +for proto in resources/org/eclipse/jgit/storage/dht/*.proto +do + echo >&2 Generating from $proto + protoc -Iresources --java_out=src $proto +done diff --git a/org.eclipse.jgit.generated.storage.dht.proto/plugin.properties b/org.eclipse.jgit.generated.storage.dht.proto/plugin.properties new file mode 100644 index 000000000..a9959ca8f --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/plugin.properties @@ -0,0 +1,2 @@ +plugin_name=JGit DHT Storage Protocol Buffer Messages (Incubation) +provider_name=Eclipse.org diff --git a/org.eclipse.jgit.generated.storage.dht.proto/pom.xml b/org.eclipse.jgit.generated.storage.dht.proto/pom.xml new file mode 100644 index 000000000..60942d434 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/pom.xml @@ -0,0 +1,120 @@ + + + + + 4.0.0 + + + org.eclipse.jgit + org.eclipse.jgit-parent + 1.0.0-SNAPSHOT + + + org.eclipse.jgit.generated.storage.dht.proto + JGit - DHT Storage Protocol Buffer Messages + + + Compiled protocol buffer messages for DHT storage + + + + + + + + + com.google.protobuf + protobuf-java + + + + + src/ + + + + . + + plugin.properties + + + + resources/ + + + + + + org.apache.maven.plugins + maven-source-plugin + true + + + attach-sources + process-classes + + jar + + + + ${source-bundle-manifest} + + + + + + + + maven-jar-plugin + + + ${bundle-manifest} + + + + + + diff --git a/org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_cache.proto b/org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_cache.proto new file mode 100644 index 000000000..40a2efd43 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_cache.proto @@ -0,0 +1,86 @@ +// Copyright (C) 2011, Google Inc. +// and other copyright owners as documented in the project's IP log. +// +// This program and the accompanying materials are made available +// under the terms of the Eclipse Distribution License v1.0 which +// accompanies this distribution, is reproduced below, and is +// available at http://www.eclipse.org/org/documents/edl-v10.php +// +// 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 the Eclipse Foundation, 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. + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// +// WARNING: If you edit this file, run generate.sh +// +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +syntax = "proto2"; + +package org.eclipse.jgit.storage.dht; +option java_generate_equals_and_hash = true; +option java_package = "org.eclipse.jgit.generated.storage.dht.proto"; + +import "org/eclipse/jgit/storage/dht/git_store.proto"; + + + // Caches ObjectIndexTable in a single message. + // +message CachedObjectIndex { + message Item { + required string chunk_key = 1; + required ObjectInfo object_info = 2; + optional fixed64 time = 3; + } + repeated Item item = 1; +} + + + // Caches CachedPackInfo in a single message. + // +message CachedPackInfoList { + repeated CachedPackInfo pack = 1; +} + + + // Caches ChunkTable in a single message. + // + // WARNING: Formatters for this message are also hand-coded + // inside of the CacheChunkTable class. If you make changes + // to this message, ensure that class is also updated. + // +message CachedChunk { + required bytes data = 1; + optional bytes index = 2; + optional ChunkMeta meta = 3; +} diff --git a/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/git_store.proto b/org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_store.proto similarity index 95% rename from org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/git_store.proto rename to org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_store.proto index d6674055a..78ad4f2bb 100644 --- a/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/git_store.proto +++ b/org.eclipse.jgit.generated.storage.dht.proto/resources/org/eclipse/jgit/storage/dht/git_store.proto @@ -39,8 +39,17 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -package git_store; -option java_package = "org.eclipse.jgit.storage.dht.proto"; +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// +// WARNING: If you edit this file, run generate.sh +// +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +syntax = "proto2"; + +package org.eclipse.jgit.storage.dht; +option java_generate_equals_and_hash = true; +option java_package = "org.eclipse.jgit.generated.storage.dht.proto"; // Entry in RefTable describing the target of the reference. diff --git a/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitCache.java b/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitCache.java new file mode 100644 index 000000000..d9bba52e3 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitCache.java @@ -0,0 +1,2546 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: org/eclipse/jgit/storage/dht/git_cache.proto + +package org.eclipse.jgit.generated.storage.dht.proto; + +public final class GitCache { + private GitCache() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface CachedObjectIndexOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated .org.eclipse.jgit.storage.dht.CachedObjectIndex.Item item = 1; + java.util.List + getItemList(); + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item getItem(int index); + int getItemCount(); + java.util.List + getItemOrBuilderList(); + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder getItemOrBuilder( + int index); + } + public static final class CachedObjectIndex extends + com.google.protobuf.GeneratedMessage + implements CachedObjectIndexOrBuilder { + // Use CachedObjectIndex.newBuilder() to construct. + private CachedObjectIndex(Builder builder) { + super(builder); + } + private CachedObjectIndex(boolean noInit) {} + + private static final CachedObjectIndex defaultInstance; + public static CachedObjectIndex getDefaultInstance() { + return defaultInstance; + } + + public CachedObjectIndex getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_fieldAccessorTable; + } + + public interface ItemOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string chunk_key = 1; + boolean hasChunkKey(); + String getChunkKey(); + + // required .org.eclipse.jgit.storage.dht.ObjectInfo object_info = 2; + boolean hasObjectInfo(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo getObjectInfo(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder getObjectInfoOrBuilder(); + + // optional fixed64 time = 3; + boolean hasTime(); + long getTime(); + } + public static final class Item extends + com.google.protobuf.GeneratedMessage + implements ItemOrBuilder { + // Use Item.newBuilder() to construct. + private Item(Builder builder) { + super(builder); + } + private Item(boolean noInit) {} + + private static final Item defaultInstance; + public static Item getDefaultInstance() { + return defaultInstance; + } + + public Item getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_fieldAccessorTable; + } + + private int bitField0_; + // required string chunk_key = 1; + public static final int CHUNK_KEY_FIELD_NUMBER = 1; + private Object chunkKey_; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + chunkKey_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getChunkKeyBytes() { + Object ref = chunkKey_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + chunkKey_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required .org.eclipse.jgit.storage.dht.ObjectInfo object_info = 2; + public static final int OBJECT_INFO_FIELD_NUMBER = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo objectInfo_; + public boolean hasObjectInfo() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo getObjectInfo() { + return objectInfo_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder getObjectInfoOrBuilder() { + return objectInfo_; + } + + // optional fixed64 time = 3; + public static final int TIME_FIELD_NUMBER = 3; + private long time_; + public boolean hasTime() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getTime() { + return time_; + } + + private void initFields() { + chunkKey_ = ""; + objectInfo_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance(); + time_ = 0L; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasChunkKey()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasObjectInfo()) { + memoizedIsInitialized = 0; + return false; + } + if (!getObjectInfo().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getChunkKeyBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, objectInfo_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeFixed64(3, time_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getChunkKeyBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, objectInfo_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeFixed64Size(3, time_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item other = (org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item) obj; + + boolean result = true; + result = result && (hasChunkKey() == other.hasChunkKey()); + if (hasChunkKey()) { + result = result && getChunkKey() + .equals(other.getChunkKey()); + } + result = result && (hasObjectInfo() == other.hasObjectInfo()); + if (hasObjectInfo()) { + result = result && getObjectInfo() + .equals(other.getObjectInfo()); + } + result = result && (hasTime() == other.hasTime()); + if (hasTime()) { + result = result && (getTime() + == other.getTime()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasChunkKey()) { + hash = (37 * hash) + CHUNK_KEY_FIELD_NUMBER; + hash = (53 * hash) + getChunkKey().hashCode(); + } + if (hasObjectInfo()) { + hash = (37 * hash) + OBJECT_INFO_FIELD_NUMBER; + hash = (53 * hash) + getObjectInfo().hashCode(); + } + if (hasTime()) { + hash = (37 * hash) + TIME_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getTime()); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getObjectInfoFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + chunkKey_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (objectInfoBuilder_ == null) { + objectInfo_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance(); + } else { + objectInfoBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + time_ = 0L; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item build() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item result = new org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.chunkKey_ = chunkKey_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + if (objectInfoBuilder_ == null) { + result.objectInfo_ = objectInfo_; + } else { + result.objectInfo_ = objectInfoBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.time_ = time_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.getDefaultInstance()) return this; + if (other.hasChunkKey()) { + setChunkKey(other.getChunkKey()); + } + if (other.hasObjectInfo()) { + mergeObjectInfo(other.getObjectInfo()); + } + if (other.hasTime()) { + setTime(other.getTime()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasChunkKey()) { + + return false; + } + if (!hasObjectInfo()) { + + return false; + } + if (!getObjectInfo().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + chunkKey_ = input.readBytes(); + break; + } + case 18: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.newBuilder(); + if (hasObjectInfo()) { + subBuilder.mergeFrom(getObjectInfo()); + } + input.readMessage(subBuilder, extensionRegistry); + setObjectInfo(subBuilder.buildPartial()); + break; + } + case 25: { + bitField0_ |= 0x00000004; + time_ = input.readFixed64(); + break; + } + } + } + } + + private int bitField0_; + + // required string chunk_key = 1; + private Object chunkKey_ = ""; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + chunkKey_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setChunkKey(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + chunkKey_ = value; + onChanged(); + return this; + } + public Builder clearChunkKey() { + bitField0_ = (bitField0_ & ~0x00000001); + chunkKey_ = getDefaultInstance().getChunkKey(); + onChanged(); + return this; + } + void setChunkKey(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000001; + chunkKey_ = value; + onChanged(); + } + + // required .org.eclipse.jgit.storage.dht.ObjectInfo object_info = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo objectInfo_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder> objectInfoBuilder_; + public boolean hasObjectInfo() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo getObjectInfo() { + if (objectInfoBuilder_ == null) { + return objectInfo_; + } else { + return objectInfoBuilder_.getMessage(); + } + } + public Builder setObjectInfo(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo value) { + if (objectInfoBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + objectInfo_ = value; + onChanged(); + } else { + objectInfoBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder setObjectInfo( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder builderForValue) { + if (objectInfoBuilder_ == null) { + objectInfo_ = builderForValue.build(); + onChanged(); + } else { + objectInfoBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder mergeObjectInfo(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo value) { + if (objectInfoBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + objectInfo_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance()) { + objectInfo_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.newBuilder(objectInfo_).mergeFrom(value).buildPartial(); + } else { + objectInfo_ = value; + } + onChanged(); + } else { + objectInfoBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder clearObjectInfo() { + if (objectInfoBuilder_ == null) { + objectInfo_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance(); + onChanged(); + } else { + objectInfoBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder getObjectInfoBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getObjectInfoFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder getObjectInfoOrBuilder() { + if (objectInfoBuilder_ != null) { + return objectInfoBuilder_.getMessageOrBuilder(); + } else { + return objectInfo_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder> + getObjectInfoFieldBuilder() { + if (objectInfoBuilder_ == null) { + objectInfoBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder>( + objectInfo_, + getParentForChildren(), + isClean()); + objectInfo_ = null; + } + return objectInfoBuilder_; + } + + // optional fixed64 time = 3; + private long time_ ; + public boolean hasTime() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getTime() { + return time_; + } + public Builder setTime(long value) { + bitField0_ |= 0x00000004; + time_ = value; + onChanged(); + return this; + } + public Builder clearTime() { + bitField0_ = (bitField0_ & ~0x00000004); + time_ = 0L; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedObjectIndex.Item) + } + + static { + defaultInstance = new Item(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedObjectIndex.Item) + } + + // repeated .org.eclipse.jgit.storage.dht.CachedObjectIndex.Item item = 1; + public static final int ITEM_FIELD_NUMBER = 1; + private java.util.List item_; + public java.util.List getItemList() { + return item_; + } + public java.util.List + getItemOrBuilderList() { + return item_; + } + public int getItemCount() { + return item_.size(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item getItem(int index) { + return item_.get(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder getItemOrBuilder( + int index) { + return item_.get(index); + } + + private void initFields() { + item_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + for (int i = 0; i < getItemCount(); i++) { + if (!getItem(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < item_.size(); i++) { + output.writeMessage(1, item_.get(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < item_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, item_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex other = (org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex) obj; + + boolean result = true; + result = result && getItemList() + .equals(other.getItemList()); + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getItemCount() > 0) { + hash = (37 * hash) + ITEM_FIELD_NUMBER; + hash = (53 * hash) + getItemList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndexOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getItemFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (itemBuilder_ == null) { + item_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + itemBuilder_.clear(); + } + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex build() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex result = new org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex(this); + int from_bitField0_ = bitField0_; + if (itemBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + item_ = java.util.Collections.unmodifiableList(item_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.item_ = item_; + } else { + result.item_ = itemBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.getDefaultInstance()) return this; + if (itemBuilder_ == null) { + if (!other.item_.isEmpty()) { + if (item_.isEmpty()) { + item_ = other.item_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureItemIsMutable(); + item_.addAll(other.item_); + } + onChanged(); + } + } else { + if (!other.item_.isEmpty()) { + if (itemBuilder_.isEmpty()) { + itemBuilder_.dispose(); + itemBuilder_ = null; + item_ = other.item_; + bitField0_ = (bitField0_ & ~0x00000001); + itemBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getItemFieldBuilder() : null; + } else { + itemBuilder_.addAllMessages(other.item_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getItemCount(); i++) { + if (!getItem(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.newBuilder(); + input.readMessage(subBuilder, extensionRegistry); + addItem(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // repeated .org.eclipse.jgit.storage.dht.CachedObjectIndex.Item item = 1; + private java.util.List item_ = + java.util.Collections.emptyList(); + private void ensureItemIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + item_ = new java.util.ArrayList(item_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder> itemBuilder_; + + public java.util.List getItemList() { + if (itemBuilder_ == null) { + return java.util.Collections.unmodifiableList(item_); + } else { + return itemBuilder_.getMessageList(); + } + } + public int getItemCount() { + if (itemBuilder_ == null) { + return item_.size(); + } else { + return itemBuilder_.getCount(); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item getItem(int index) { + if (itemBuilder_ == null) { + return item_.get(index); + } else { + return itemBuilder_.getMessage(index); + } + } + public Builder setItem( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item value) { + if (itemBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureItemIsMutable(); + item_.set(index, value); + onChanged(); + } else { + itemBuilder_.setMessage(index, value); + } + return this; + } + public Builder setItem( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder builderForValue) { + if (itemBuilder_ == null) { + ensureItemIsMutable(); + item_.set(index, builderForValue.build()); + onChanged(); + } else { + itemBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + public Builder addItem(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item value) { + if (itemBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureItemIsMutable(); + item_.add(value); + onChanged(); + } else { + itemBuilder_.addMessage(value); + } + return this; + } + public Builder addItem( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item value) { + if (itemBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureItemIsMutable(); + item_.add(index, value); + onChanged(); + } else { + itemBuilder_.addMessage(index, value); + } + return this; + } + public Builder addItem( + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder builderForValue) { + if (itemBuilder_ == null) { + ensureItemIsMutable(); + item_.add(builderForValue.build()); + onChanged(); + } else { + itemBuilder_.addMessage(builderForValue.build()); + } + return this; + } + public Builder addItem( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder builderForValue) { + if (itemBuilder_ == null) { + ensureItemIsMutable(); + item_.add(index, builderForValue.build()); + onChanged(); + } else { + itemBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + public Builder addAllItem( + java.lang.Iterable values) { + if (itemBuilder_ == null) { + ensureItemIsMutable(); + super.addAll(values, item_); + onChanged(); + } else { + itemBuilder_.addAllMessages(values); + } + return this; + } + public Builder clearItem() { + if (itemBuilder_ == null) { + item_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + itemBuilder_.clear(); + } + return this; + } + public Builder removeItem(int index) { + if (itemBuilder_ == null) { + ensureItemIsMutable(); + item_.remove(index); + onChanged(); + } else { + itemBuilder_.remove(index); + } + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder getItemBuilder( + int index) { + return getItemFieldBuilder().getBuilder(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder getItemOrBuilder( + int index) { + if (itemBuilder_ == null) { + return item_.get(index); } else { + return itemBuilder_.getMessageOrBuilder(index); + } + } + public java.util.List + getItemOrBuilderList() { + if (itemBuilder_ != null) { + return itemBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(item_); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder addItemBuilder() { + return getItemFieldBuilder().addBuilder( + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.getDefaultInstance()); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder addItemBuilder( + int index) { + return getItemFieldBuilder().addBuilder( + index, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.getDefaultInstance()); + } + public java.util.List + getItemBuilderList() { + return getItemFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder> + getItemFieldBuilder() { + if (itemBuilder_ == null) { + itemBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder>( + item_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + item_ = null; + } + return itemBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedObjectIndex) + } + + static { + defaultInstance = new CachedObjectIndex(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedObjectIndex) + } + + public interface CachedPackInfoListOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated .org.eclipse.jgit.storage.dht.CachedPackInfo pack = 1; + java.util.List + getPackList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo getPack(int index); + int getPackCount(); + java.util.List + getPackOrBuilderList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder getPackOrBuilder( + int index); + } + public static final class CachedPackInfoList extends + com.google.protobuf.GeneratedMessage + implements CachedPackInfoListOrBuilder { + // Use CachedPackInfoList.newBuilder() to construct. + private CachedPackInfoList(Builder builder) { + super(builder); + } + private CachedPackInfoList(boolean noInit) {} + + private static final CachedPackInfoList defaultInstance; + public static CachedPackInfoList getDefaultInstance() { + return defaultInstance; + } + + public CachedPackInfoList getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_fieldAccessorTable; + } + + // repeated .org.eclipse.jgit.storage.dht.CachedPackInfo pack = 1; + public static final int PACK_FIELD_NUMBER = 1; + private java.util.List pack_; + public java.util.List getPackList() { + return pack_; + } + public java.util.List + getPackOrBuilderList() { + return pack_; + } + public int getPackCount() { + return pack_.size(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo getPack(int index) { + return pack_.get(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder getPackOrBuilder( + int index) { + return pack_.get(index); + } + + private void initFields() { + pack_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + for (int i = 0; i < getPackCount(); i++) { + if (!getPack(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < pack_.size(); i++) { + output.writeMessage(1, pack_.get(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < pack_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, pack_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList other = (org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList) obj; + + boolean result = true; + result = result && getPackList() + .equals(other.getPackList()); + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getPackCount() > 0) { + hash = (37 * hash) + PACK_FIELD_NUMBER; + hash = (53 * hash) + getPackList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoListOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getPackFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (packBuilder_ == null) { + pack_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + packBuilder_.clear(); + } + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList build() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList result = new org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList(this); + int from_bitField0_ = bitField0_; + if (packBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + pack_ = java.util.Collections.unmodifiableList(pack_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.pack_ = pack_; + } else { + result.pack_ = packBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.getDefaultInstance()) return this; + if (packBuilder_ == null) { + if (!other.pack_.isEmpty()) { + if (pack_.isEmpty()) { + pack_ = other.pack_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensurePackIsMutable(); + pack_.addAll(other.pack_); + } + onChanged(); + } + } else { + if (!other.pack_.isEmpty()) { + if (packBuilder_.isEmpty()) { + packBuilder_.dispose(); + packBuilder_ = null; + pack_ = other.pack_; + bitField0_ = (bitField0_ & ~0x00000001); + packBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getPackFieldBuilder() : null; + } else { + packBuilder_.addAllMessages(other.pack_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getPackCount(); i++) { + if (!getPack(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.newBuilder(); + input.readMessage(subBuilder, extensionRegistry); + addPack(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // repeated .org.eclipse.jgit.storage.dht.CachedPackInfo pack = 1; + private java.util.List pack_ = + java.util.Collections.emptyList(); + private void ensurePackIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + pack_ = new java.util.ArrayList(pack_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder> packBuilder_; + + public java.util.List getPackList() { + if (packBuilder_ == null) { + return java.util.Collections.unmodifiableList(pack_); + } else { + return packBuilder_.getMessageList(); + } + } + public int getPackCount() { + if (packBuilder_ == null) { + return pack_.size(); + } else { + return packBuilder_.getCount(); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo getPack(int index) { + if (packBuilder_ == null) { + return pack_.get(index); + } else { + return packBuilder_.getMessage(index); + } + } + public Builder setPack( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo value) { + if (packBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePackIsMutable(); + pack_.set(index, value); + onChanged(); + } else { + packBuilder_.setMessage(index, value); + } + return this; + } + public Builder setPack( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder builderForValue) { + if (packBuilder_ == null) { + ensurePackIsMutable(); + pack_.set(index, builderForValue.build()); + onChanged(); + } else { + packBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + public Builder addPack(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo value) { + if (packBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePackIsMutable(); + pack_.add(value); + onChanged(); + } else { + packBuilder_.addMessage(value); + } + return this; + } + public Builder addPack( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo value) { + if (packBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePackIsMutable(); + pack_.add(index, value); + onChanged(); + } else { + packBuilder_.addMessage(index, value); + } + return this; + } + public Builder addPack( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder builderForValue) { + if (packBuilder_ == null) { + ensurePackIsMutable(); + pack_.add(builderForValue.build()); + onChanged(); + } else { + packBuilder_.addMessage(builderForValue.build()); + } + return this; + } + public Builder addPack( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder builderForValue) { + if (packBuilder_ == null) { + ensurePackIsMutable(); + pack_.add(index, builderForValue.build()); + onChanged(); + } else { + packBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + public Builder addAllPack( + java.lang.Iterable values) { + if (packBuilder_ == null) { + ensurePackIsMutable(); + super.addAll(values, pack_); + onChanged(); + } else { + packBuilder_.addAllMessages(values); + } + return this; + } + public Builder clearPack() { + if (packBuilder_ == null) { + pack_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + packBuilder_.clear(); + } + return this; + } + public Builder removePack(int index) { + if (packBuilder_ == null) { + ensurePackIsMutable(); + pack_.remove(index); + onChanged(); + } else { + packBuilder_.remove(index); + } + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder getPackBuilder( + int index) { + return getPackFieldBuilder().getBuilder(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder getPackOrBuilder( + int index) { + if (packBuilder_ == null) { + return pack_.get(index); } else { + return packBuilder_.getMessageOrBuilder(index); + } + } + public java.util.List + getPackOrBuilderList() { + if (packBuilder_ != null) { + return packBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(pack_); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder addPackBuilder() { + return getPackFieldBuilder().addBuilder( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.getDefaultInstance()); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder addPackBuilder( + int index) { + return getPackFieldBuilder().addBuilder( + index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.getDefaultInstance()); + } + public java.util.List + getPackBuilderList() { + return getPackFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder> + getPackFieldBuilder() { + if (packBuilder_ == null) { + packBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder>( + pack_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + pack_ = null; + } + return packBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedPackInfoList) + } + + static { + defaultInstance = new CachedPackInfoList(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedPackInfoList) + } + + public interface CachedChunkOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required bytes data = 1; + boolean hasData(); + com.google.protobuf.ByteString getData(); + + // optional bytes index = 2; + boolean hasIndex(); + com.google.protobuf.ByteString getIndex(); + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta meta = 3; + boolean hasMeta(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta getMeta(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder getMetaOrBuilder(); + } + public static final class CachedChunk extends + com.google.protobuf.GeneratedMessage + implements CachedChunkOrBuilder { + // Use CachedChunk.newBuilder() to construct. + private CachedChunk(Builder builder) { + super(builder); + } + private CachedChunk(boolean noInit) {} + + private static final CachedChunk defaultInstance; + public static CachedChunk getDefaultInstance() { + return defaultInstance; + } + + public CachedChunk getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedChunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedChunk_fieldAccessorTable; + } + + private int bitField0_; + // required bytes data = 1; + public static final int DATA_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString data_; + public boolean hasData() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public com.google.protobuf.ByteString getData() { + return data_; + } + + // optional bytes index = 2; + public static final int INDEX_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString index_; + public boolean hasIndex() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public com.google.protobuf.ByteString getIndex() { + return index_; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta meta = 3; + public static final int META_FIELD_NUMBER = 3; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta meta_; + public boolean hasMeta() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta getMeta() { + return meta_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder getMetaOrBuilder() { + return meta_; + } + + private void initFields() { + data_ = com.google.protobuf.ByteString.EMPTY; + index_ = com.google.protobuf.ByteString.EMPTY; + meta_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasData()) { + memoizedIsInitialized = 0; + return false; + } + if (hasMeta()) { + if (!getMeta().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, data_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, index_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, meta_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, data_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, index_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, meta_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk other = (org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk) obj; + + boolean result = true; + result = result && (hasData() == other.hasData()); + if (hasData()) { + result = result && getData() + .equals(other.getData()); + } + result = result && (hasIndex() == other.hasIndex()); + if (hasIndex()) { + result = result && getIndex() + .equals(other.getIndex()); + } + result = result && (hasMeta() == other.hasMeta()); + if (hasMeta()) { + result = result && getMeta() + .equals(other.getMeta()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasData()) { + hash = (37 * hash) + DATA_FIELD_NUMBER; + hash = (53 * hash) + getData().hashCode(); + } + if (hasIndex()) { + hash = (37 * hash) + INDEX_FIELD_NUMBER; + hash = (53 * hash) + getIndex().hashCode(); + } + if (hasMeta()) { + hash = (37 * hash) + META_FIELD_NUMBER; + hash = (53 * hash) + getMeta().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedChunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.internal_static_org_eclipse_jgit_storage_dht_CachedChunk_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getMetaFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + index_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + if (metaBuilder_ == null) { + meta_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance(); + } else { + metaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk build() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk result = new org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.data_ = data_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.index_ = index_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (metaBuilder_ == null) { + result.meta_ = meta_; + } else { + result.meta_ = metaBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.getDefaultInstance()) return this; + if (other.hasData()) { + setData(other.getData()); + } + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + if (other.hasMeta()) { + mergeMeta(other.getMeta()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasData()) { + + return false; + } + if (hasMeta()) { + if (!getMeta().isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + data_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + index_ = input.readBytes(); + break; + } + case 26: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.newBuilder(); + if (hasMeta()) { + subBuilder.mergeFrom(getMeta()); + } + input.readMessage(subBuilder, extensionRegistry); + setMeta(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // required bytes data = 1; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + public boolean hasData() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public com.google.protobuf.ByteString getData() { + return data_; + } + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + data_ = value; + onChanged(); + return this; + } + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000001); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // optional bytes index = 2; + private com.google.protobuf.ByteString index_ = com.google.protobuf.ByteString.EMPTY; + public boolean hasIndex() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public com.google.protobuf.ByteString getIndex() { + return index_; + } + public Builder setIndex(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + index_ = value; + onChanged(); + return this; + } + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000002); + index_ = getDefaultInstance().getIndex(); + onChanged(); + return this; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta meta = 3; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta meta_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder> metaBuilder_; + public boolean hasMeta() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta getMeta() { + if (metaBuilder_ == null) { + return meta_; + } else { + return metaBuilder_.getMessage(); + } + } + public Builder setMeta(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta value) { + if (metaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + meta_ = value; + onChanged(); + } else { + metaBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder setMeta( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder builderForValue) { + if (metaBuilder_ == null) { + meta_ = builderForValue.build(); + onChanged(); + } else { + metaBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder mergeMeta(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta value) { + if (metaBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + meta_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance()) { + meta_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.newBuilder(meta_).mergeFrom(value).buildPartial(); + } else { + meta_ = value; + } + onChanged(); + } else { + metaBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder clearMeta() { + if (metaBuilder_ == null) { + meta_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance(); + onChanged(); + } else { + metaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder getMetaBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getMetaFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder getMetaOrBuilder() { + if (metaBuilder_ != null) { + return metaBuilder_.getMessageOrBuilder(); + } else { + return meta_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder> + getMetaFieldBuilder() { + if (metaBuilder_ == null) { + metaBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder>( + meta_, + getParentForChildren(), + isClean()); + meta_ = null; + } + return metaBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedChunk) + } + + static { + defaultInstance = new CachedChunk(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedChunk) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedChunk_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedChunk_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,org/eclipse/jgit/storage/dht/git_cache" + + ".proto\022\034org.eclipse.jgit.storage.dht\032,or" + + "g/eclipse/jgit/storage/dht/git_store.pro" + + "to\"\277\001\n\021CachedObjectIndex\022B\n\004item\030\001 \003(\01324" + + ".org.eclipse.jgit.storage.dht.CachedObje" + + "ctIndex.Item\032f\n\004Item\022\021\n\tchunk_key\030\001 \002(\t\022" + + "=\n\013object_info\030\002 \002(\0132(.org.eclipse.jgit." + + "storage.dht.ObjectInfo\022\014\n\004time\030\003 \001(\006\"P\n\022" + + "CachedPackInfoList\022:\n\004pack\030\001 \003(\0132,.org.e" + + "clipse.jgit.storage.dht.CachedPackInfo\"a", + "\n\013CachedChunk\022\014\n\004data\030\001 \002(\014\022\r\n\005index\030\002 \001" + + "(\014\0225\n\004meta\030\003 \001(\0132\'.org.eclipse.jgit.stor" + + "age.dht.ChunkMetaB1\n,org.eclipse.jgit.ge" + + "nerated.storage.dht.proto\240\001\001" + }; + 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; + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor, + new java.lang.String[] { "Item", }, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.class, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_descriptor = + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_descriptor.getNestedTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedObjectIndex_Item_descriptor, + new java.lang.String[] { "ChunkKey", "ObjectInfo", "Time", }, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.class, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfoList_descriptor, + new java.lang.String[] { "Pack", }, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.class, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedChunk_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_org_eclipse_jgit_storage_dht_CachedChunk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedChunk_descriptor, + new java.lang.String[] { "Data", "Index", "Meta", }, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.class, + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedChunk.Builder.class); + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.getDescriptor(), + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitStore.java b/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitStore.java new file mode 100644 index 000000000..86a2ffc0e --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/src/org/eclipse/jgit/generated/storage/dht/proto/GitStore.java @@ -0,0 +1,7963 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: org/eclipse/jgit/storage/dht/git_store.proto + +package org.eclipse.jgit.generated.storage.dht.proto; + +public final class GitStore { + private GitStore() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface RefDataOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional string symref = 1; + boolean hasSymref(); + String getSymref(); + + // optional .org.eclipse.jgit.storage.dht.RefData.Id target = 2; + boolean hasTarget(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getTarget(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getTargetOrBuilder(); + + // optional bool is_peeled = 3; + boolean hasIsPeeled(); + boolean getIsPeeled(); + + // optional .org.eclipse.jgit.storage.dht.RefData.Id peeled = 4; + boolean hasPeeled(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getPeeled(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getPeeledOrBuilder(); + } + public static final class RefData extends + com.google.protobuf.GeneratedMessage + implements RefDataOrBuilder { + // Use RefData.newBuilder() to construct. + private RefData(Builder builder) { + super(builder); + } + private RefData(boolean noInit) {} + + private static final RefData defaultInstance; + public static RefData getDefaultInstance() { + return defaultInstance; + } + + public RefData getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_fieldAccessorTable; + } + + public interface IdOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string object_name = 1; + boolean hasObjectName(); + String getObjectName(); + + // optional string chunk_key = 2; + boolean hasChunkKey(); + String getChunkKey(); + } + public static final class Id extends + com.google.protobuf.GeneratedMessage + implements IdOrBuilder { + // Use Id.newBuilder() to construct. + private Id(Builder builder) { + super(builder); + } + private Id(boolean noInit) {} + + private static final Id defaultInstance; + public static Id getDefaultInstance() { + return defaultInstance; + } + + public Id getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_Id_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_Id_fieldAccessorTable; + } + + private int bitField0_; + // required string object_name = 1; + public static final int OBJECT_NAME_FIELD_NUMBER = 1; + private Object objectName_; + public boolean hasObjectName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getObjectName() { + Object ref = objectName_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + objectName_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getObjectNameBytes() { + Object ref = objectName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + objectName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional string chunk_key = 2; + public static final int CHUNK_KEY_FIELD_NUMBER = 2; + private Object chunkKey_; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + chunkKey_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getChunkKeyBytes() { + Object ref = chunkKey_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + chunkKey_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + objectName_ = ""; + chunkKey_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasObjectName()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getObjectNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getChunkKeyBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getObjectNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getChunkKeyBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id) obj; + + boolean result = true; + result = result && (hasObjectName() == other.hasObjectName()); + if (hasObjectName()) { + result = result && getObjectName() + .equals(other.getObjectName()); + } + result = result && (hasChunkKey() == other.hasChunkKey()); + if (hasChunkKey()) { + result = result && getChunkKey() + .equals(other.getChunkKey()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasObjectName()) { + hash = (37 * hash) + OBJECT_NAME_FIELD_NUMBER; + hash = (53 * hash) + getObjectName().hashCode(); + } + if (hasChunkKey()) { + hash = (37 * hash) + CHUNK_KEY_FIELD_NUMBER; + hash = (53 * hash) + getChunkKey().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_Id_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_Id_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + objectName_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + chunkKey_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.objectName_ = objectName_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.chunkKey_ = chunkKey_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance()) return this; + if (other.hasObjectName()) { + setObjectName(other.getObjectName()); + } + if (other.hasChunkKey()) { + setChunkKey(other.getChunkKey()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasObjectName()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + objectName_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + chunkKey_ = input.readBytes(); + break; + } + } + } + } + + private int bitField0_; + + // required string object_name = 1; + private Object objectName_ = ""; + public boolean hasObjectName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getObjectName() { + Object ref = objectName_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + objectName_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setObjectName(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + objectName_ = value; + onChanged(); + return this; + } + public Builder clearObjectName() { + bitField0_ = (bitField0_ & ~0x00000001); + objectName_ = getDefaultInstance().getObjectName(); + onChanged(); + return this; + } + void setObjectName(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000001; + objectName_ = value; + onChanged(); + } + + // optional string chunk_key = 2; + private Object chunkKey_ = ""; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + chunkKey_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setChunkKey(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + chunkKey_ = value; + onChanged(); + return this; + } + public Builder clearChunkKey() { + bitField0_ = (bitField0_ & ~0x00000002); + chunkKey_ = getDefaultInstance().getChunkKey(); + onChanged(); + return this; + } + void setChunkKey(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000002; + chunkKey_ = value; + onChanged(); + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.RefData.Id) + } + + static { + defaultInstance = new Id(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.RefData.Id) + } + + private int bitField0_; + // optional string symref = 1; + public static final int SYMREF_FIELD_NUMBER = 1; + private Object symref_; + public boolean hasSymref() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getSymref() { + Object ref = symref_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + symref_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getSymrefBytes() { + Object ref = symref_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + symref_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional .org.eclipse.jgit.storage.dht.RefData.Id target = 2; + public static final int TARGET_FIELD_NUMBER = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id target_; + public boolean hasTarget() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getTarget() { + return target_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getTargetOrBuilder() { + return target_; + } + + // optional bool is_peeled = 3; + public static final int IS_PEELED_FIELD_NUMBER = 3; + private boolean isPeeled_; + public boolean hasIsPeeled() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public boolean getIsPeeled() { + return isPeeled_; + } + + // optional .org.eclipse.jgit.storage.dht.RefData.Id peeled = 4; + public static final int PEELED_FIELD_NUMBER = 4; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id peeled_; + public boolean hasPeeled() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getPeeled() { + return peeled_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getPeeledOrBuilder() { + return peeled_; + } + + private void initFields() { + symref_ = ""; + target_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + isPeeled_ = false; + peeled_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (hasTarget()) { + if (!getTarget().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasPeeled()) { + if (!getPeeled().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getSymrefBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, target_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, isPeeled_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, peeled_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getSymrefBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, target_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, isPeeled_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, peeled_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData) obj; + + boolean result = true; + result = result && (hasSymref() == other.hasSymref()); + if (hasSymref()) { + result = result && getSymref() + .equals(other.getSymref()); + } + result = result && (hasTarget() == other.hasTarget()); + if (hasTarget()) { + result = result && getTarget() + .equals(other.getTarget()); + } + result = result && (hasIsPeeled() == other.hasIsPeeled()); + if (hasIsPeeled()) { + result = result && (getIsPeeled() + == other.getIsPeeled()); + } + result = result && (hasPeeled() == other.hasPeeled()); + if (hasPeeled()) { + result = result && getPeeled() + .equals(other.getPeeled()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasSymref()) { + hash = (37 * hash) + SYMREF_FIELD_NUMBER; + hash = (53 * hash) + getSymref().hashCode(); + } + if (hasTarget()) { + hash = (37 * hash) + TARGET_FIELD_NUMBER; + hash = (53 * hash) + getTarget().hashCode(); + } + if (hasIsPeeled()) { + hash = (37 * hash) + IS_PEELED_FIELD_NUMBER; + hash = (53 * hash) + hashBoolean(getIsPeeled()); + } + if (hasPeeled()) { + hash = (37 * hash) + PEELED_FIELD_NUMBER; + hash = (53 * hash) + getPeeled().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefDataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_RefData_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getTargetFieldBuilder(); + getPeeledFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symref_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (targetBuilder_ == null) { + target_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + } else { + targetBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + isPeeled_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + if (peeledBuilder_ == null) { + peeled_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + } else { + peeledBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symref_ = symref_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + if (targetBuilder_ == null) { + result.target_ = target_; + } else { + result.target_ = targetBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.isPeeled_ = isPeeled_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + if (peeledBuilder_ == null) { + result.peeled_ = peeled_; + } else { + result.peeled_ = peeledBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.getDefaultInstance()) return this; + if (other.hasSymref()) { + setSymref(other.getSymref()); + } + if (other.hasTarget()) { + mergeTarget(other.getTarget()); + } + if (other.hasIsPeeled()) { + setIsPeeled(other.getIsPeeled()); + } + if (other.hasPeeled()) { + mergePeeled(other.getPeeled()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (hasTarget()) { + if (!getTarget().isInitialized()) { + + return false; + } + } + if (hasPeeled()) { + if (!getPeeled().isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + symref_ = input.readBytes(); + break; + } + case 18: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.newBuilder(); + if (hasTarget()) { + subBuilder.mergeFrom(getTarget()); + } + input.readMessage(subBuilder, extensionRegistry); + setTarget(subBuilder.buildPartial()); + break; + } + case 24: { + bitField0_ |= 0x00000004; + isPeeled_ = input.readBool(); + break; + } + case 34: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.newBuilder(); + if (hasPeeled()) { + subBuilder.mergeFrom(getPeeled()); + } + input.readMessage(subBuilder, extensionRegistry); + setPeeled(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // optional string symref = 1; + private Object symref_ = ""; + public boolean hasSymref() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getSymref() { + Object ref = symref_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + symref_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setSymref(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + symref_ = value; + onChanged(); + return this; + } + public Builder clearSymref() { + bitField0_ = (bitField0_ & ~0x00000001); + symref_ = getDefaultInstance().getSymref(); + onChanged(); + return this; + } + void setSymref(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000001; + symref_ = value; + onChanged(); + } + + // optional .org.eclipse.jgit.storage.dht.RefData.Id target = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id target_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder> targetBuilder_; + public boolean hasTarget() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getTarget() { + if (targetBuilder_ == null) { + return target_; + } else { + return targetBuilder_.getMessage(); + } + } + public Builder setTarget(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id value) { + if (targetBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + target_ = value; + onChanged(); + } else { + targetBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder setTarget( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder builderForValue) { + if (targetBuilder_ == null) { + target_ = builderForValue.build(); + onChanged(); + } else { + targetBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder mergeTarget(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id value) { + if (targetBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + target_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance()) { + target_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.newBuilder(target_).mergeFrom(value).buildPartial(); + } else { + target_ = value; + } + onChanged(); + } else { + targetBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + public Builder clearTarget() { + if (targetBuilder_ == null) { + target_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + onChanged(); + } else { + targetBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder getTargetBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getTargetFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getTargetOrBuilder() { + if (targetBuilder_ != null) { + return targetBuilder_.getMessageOrBuilder(); + } else { + return target_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder> + getTargetFieldBuilder() { + if (targetBuilder_ == null) { + targetBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder>( + target_, + getParentForChildren(), + isClean()); + target_ = null; + } + return targetBuilder_; + } + + // optional bool is_peeled = 3; + private boolean isPeeled_ ; + public boolean hasIsPeeled() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public boolean getIsPeeled() { + return isPeeled_; + } + public Builder setIsPeeled(boolean value) { + bitField0_ |= 0x00000004; + isPeeled_ = value; + onChanged(); + return this; + } + public Builder clearIsPeeled() { + bitField0_ = (bitField0_ & ~0x00000004); + isPeeled_ = false; + onChanged(); + return this; + } + + // optional .org.eclipse.jgit.storage.dht.RefData.Id peeled = 4; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id peeled_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder> peeledBuilder_; + public boolean hasPeeled() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id getPeeled() { + if (peeledBuilder_ == null) { + return peeled_; + } else { + return peeledBuilder_.getMessage(); + } + } + public Builder setPeeled(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id value) { + if (peeledBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + peeled_ = value; + onChanged(); + } else { + peeledBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder setPeeled( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder builderForValue) { + if (peeledBuilder_ == null) { + peeled_ = builderForValue.build(); + onChanged(); + } else { + peeledBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder mergePeeled(org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id value) { + if (peeledBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + peeled_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance()) { + peeled_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.newBuilder(peeled_).mergeFrom(value).buildPartial(); + } else { + peeled_ = value; + } + onChanged(); + } else { + peeledBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder clearPeeled() { + if (peeledBuilder_ == null) { + peeled_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.getDefaultInstance(); + onChanged(); + } else { + peeledBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder getPeeledBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getPeeledFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder getPeeledOrBuilder() { + if (peeledBuilder_ != null) { + return peeledBuilder_.getMessageOrBuilder(); + } else { + return peeled_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder> + getPeeledFieldBuilder() { + if (peeledBuilder_ == null) { + peeledBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.IdOrBuilder>( + peeled_, + getParentForChildren(), + isClean()); + peeled_ = null; + } + return peeledBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.RefData) + } + + static { + defaultInstance = new RefData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.RefData) + } + + public interface ObjectInfoOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional .org.eclipse.jgit.storage.dht.ObjectInfo.ObjectType object_type = 1; + boolean hasObjectType(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType getObjectType(); + + // required int32 offset = 2; + boolean hasOffset(); + int getOffset(); + + // required int64 packed_size = 3; + boolean hasPackedSize(); + long getPackedSize(); + + // required int64 inflated_size = 4; + boolean hasInflatedSize(); + long getInflatedSize(); + + // optional bytes delta_base = 5; + boolean hasDeltaBase(); + com.google.protobuf.ByteString getDeltaBase(); + + // optional bool is_fragmented = 6; + boolean hasIsFragmented(); + boolean getIsFragmented(); + } + public static final class ObjectInfo extends + com.google.protobuf.GeneratedMessage + implements ObjectInfoOrBuilder { + // Use ObjectInfo.newBuilder() to construct. + private ObjectInfo(Builder builder) { + super(builder); + } + private ObjectInfo(boolean noInit) {} + + private static final ObjectInfo defaultInstance; + public static ObjectInfo getDefaultInstance() { + return defaultInstance; + } + + public ObjectInfo getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_fieldAccessorTable; + } + + public enum ObjectType + implements com.google.protobuf.ProtocolMessageEnum { + COMMIT(0, 1), + TREE(1, 2), + BLOB(2, 3), + TAG(3, 4), + ; + + public static final int COMMIT_VALUE = 1; + public static final int TREE_VALUE = 2; + public static final int BLOB_VALUE = 3; + public static final int TAG_VALUE = 4; + + + public final int getNumber() { return value; } + + public static ObjectType valueOf(int value) { + switch (value) { + case 1: return COMMIT; + case 2: return TREE; + case 3: return BLOB; + case 4: return TAG; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ObjectType findValueByNumber(int number) { + return ObjectType.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDescriptor().getEnumTypes().get(0); + } + + private static final ObjectType[] VALUES = { + COMMIT, TREE, BLOB, TAG, + }; + + public static ObjectType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private ObjectType(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.eclipse.jgit.storage.dht.ObjectInfo.ObjectType) + } + + private int bitField0_; + // optional .org.eclipse.jgit.storage.dht.ObjectInfo.ObjectType object_type = 1; + public static final int OBJECT_TYPE_FIELD_NUMBER = 1; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType objectType_; + public boolean hasObjectType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType getObjectType() { + return objectType_; + } + + // required int32 offset = 2; + public static final int OFFSET_FIELD_NUMBER = 2; + private int offset_; + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getOffset() { + return offset_; + } + + // required int64 packed_size = 3; + public static final int PACKED_SIZE_FIELD_NUMBER = 3; + private long packedSize_; + public boolean hasPackedSize() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getPackedSize() { + return packedSize_; + } + + // required int64 inflated_size = 4; + public static final int INFLATED_SIZE_FIELD_NUMBER = 4; + private long inflatedSize_; + public boolean hasInflatedSize() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public long getInflatedSize() { + return inflatedSize_; + } + + // optional bytes delta_base = 5; + public static final int DELTA_BASE_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString deltaBase_; + public boolean hasDeltaBase() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public com.google.protobuf.ByteString getDeltaBase() { + return deltaBase_; + } + + // optional bool is_fragmented = 6; + public static final int IS_FRAGMENTED_FIELD_NUMBER = 6; + private boolean isFragmented_; + public boolean hasIsFragmented() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public boolean getIsFragmented() { + return isFragmented_; + } + + private void initFields() { + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType.COMMIT; + offset_ = 0; + packedSize_ = 0L; + inflatedSize_ = 0L; + deltaBase_ = com.google.protobuf.ByteString.EMPTY; + isFragmented_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasOffset()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasPackedSize()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasInflatedSize()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, objectType_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, offset_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt64(3, packedSize_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt64(4, inflatedSize_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, deltaBase_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isFragmented_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, objectType_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, offset_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(3, packedSize_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(4, inflatedSize_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, deltaBase_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(6, isFragmented_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo) obj; + + boolean result = true; + result = result && (hasObjectType() == other.hasObjectType()); + if (hasObjectType()) { + result = result && + (getObjectType() == other.getObjectType()); + } + result = result && (hasOffset() == other.hasOffset()); + if (hasOffset()) { + result = result && (getOffset() + == other.getOffset()); + } + result = result && (hasPackedSize() == other.hasPackedSize()); + if (hasPackedSize()) { + result = result && (getPackedSize() + == other.getPackedSize()); + } + result = result && (hasInflatedSize() == other.hasInflatedSize()); + if (hasInflatedSize()) { + result = result && (getInflatedSize() + == other.getInflatedSize()); + } + result = result && (hasDeltaBase() == other.hasDeltaBase()); + if (hasDeltaBase()) { + result = result && getDeltaBase() + .equals(other.getDeltaBase()); + } + result = result && (hasIsFragmented() == other.hasIsFragmented()); + if (hasIsFragmented()) { + result = result && (getIsFragmented() + == other.getIsFragmented()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasObjectType()) { + hash = (37 * hash) + OBJECT_TYPE_FIELD_NUMBER; + hash = (53 * hash) + hashEnum(getObjectType()); + } + if (hasOffset()) { + hash = (37 * hash) + OFFSET_FIELD_NUMBER; + hash = (53 * hash) + getOffset(); + } + if (hasPackedSize()) { + hash = (37 * hash) + PACKED_SIZE_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getPackedSize()); + } + if (hasInflatedSize()) { + hash = (37 * hash) + INFLATED_SIZE_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getInflatedSize()); + } + if (hasDeltaBase()) { + hash = (37 * hash) + DELTA_BASE_FIELD_NUMBER; + hash = (53 * hash) + getDeltaBase().hashCode(); + } + if (hasIsFragmented()) { + hash = (37 * hash) + IS_FRAGMENTED_FIELD_NUMBER; + hash = (53 * hash) + hashBoolean(getIsFragmented()); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType.COMMIT; + bitField0_ = (bitField0_ & ~0x00000001); + offset_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + packedSize_ = 0L; + bitField0_ = (bitField0_ & ~0x00000004); + inflatedSize_ = 0L; + bitField0_ = (bitField0_ & ~0x00000008); + deltaBase_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + isFragmented_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.objectType_ = objectType_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.offset_ = offset_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.packedSize_ = packedSize_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.inflatedSize_ = inflatedSize_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.deltaBase_ = deltaBase_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isFragmented_ = isFragmented_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.getDefaultInstance()) return this; + if (other.hasObjectType()) { + setObjectType(other.getObjectType()); + } + if (other.hasOffset()) { + setOffset(other.getOffset()); + } + if (other.hasPackedSize()) { + setPackedSize(other.getPackedSize()); + } + if (other.hasInflatedSize()) { + setInflatedSize(other.getInflatedSize()); + } + if (other.hasDeltaBase()) { + setDeltaBase(other.getDeltaBase()); + } + if (other.hasIsFragmented()) { + setIsFragmented(other.getIsFragmented()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasOffset()) { + + return false; + } + if (!hasPackedSize()) { + + return false; + } + if (!hasInflatedSize()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType value = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + objectType_ = value; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + offset_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + packedSize_ = input.readInt64(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + inflatedSize_ = input.readInt64(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + deltaBase_ = input.readBytes(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + isFragmented_ = input.readBool(); + break; + } + } + } + } + + private int bitField0_; + + // optional .org.eclipse.jgit.storage.dht.ObjectInfo.ObjectType object_type = 1; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType.COMMIT; + public boolean hasObjectType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType getObjectType() { + return objectType_; + } + public Builder setObjectType(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + objectType_ = value; + onChanged(); + return this; + } + public Builder clearObjectType() { + bitField0_ = (bitField0_ & ~0x00000001); + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType.COMMIT; + onChanged(); + return this; + } + + // required int32 offset = 2; + private int offset_ ; + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getOffset() { + return offset_; + } + public Builder setOffset(int value) { + bitField0_ |= 0x00000002; + offset_ = value; + onChanged(); + return this; + } + public Builder clearOffset() { + bitField0_ = (bitField0_ & ~0x00000002); + offset_ = 0; + onChanged(); + return this; + } + + // required int64 packed_size = 3; + private long packedSize_ ; + public boolean hasPackedSize() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getPackedSize() { + return packedSize_; + } + public Builder setPackedSize(long value) { + bitField0_ |= 0x00000004; + packedSize_ = value; + onChanged(); + return this; + } + public Builder clearPackedSize() { + bitField0_ = (bitField0_ & ~0x00000004); + packedSize_ = 0L; + onChanged(); + return this; + } + + // required int64 inflated_size = 4; + private long inflatedSize_ ; + public boolean hasInflatedSize() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public long getInflatedSize() { + return inflatedSize_; + } + public Builder setInflatedSize(long value) { + bitField0_ |= 0x00000008; + inflatedSize_ = value; + onChanged(); + return this; + } + public Builder clearInflatedSize() { + bitField0_ = (bitField0_ & ~0x00000008); + inflatedSize_ = 0L; + onChanged(); + return this; + } + + // optional bytes delta_base = 5; + private com.google.protobuf.ByteString deltaBase_ = com.google.protobuf.ByteString.EMPTY; + public boolean hasDeltaBase() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public com.google.protobuf.ByteString getDeltaBase() { + return deltaBase_; + } + public Builder setDeltaBase(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + deltaBase_ = value; + onChanged(); + return this; + } + public Builder clearDeltaBase() { + bitField0_ = (bitField0_ & ~0x00000010); + deltaBase_ = getDefaultInstance().getDeltaBase(); + onChanged(); + return this; + } + + // optional bool is_fragmented = 6; + private boolean isFragmented_ ; + public boolean hasIsFragmented() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public boolean getIsFragmented() { + return isFragmented_; + } + public Builder setIsFragmented(boolean value) { + bitField0_ |= 0x00000020; + isFragmented_ = value; + onChanged(); + return this; + } + public Builder clearIsFragmented() { + bitField0_ = (bitField0_ & ~0x00000020); + isFragmented_ = false; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ObjectInfo) + } + + static { + defaultInstance = new ObjectInfo(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ObjectInfo) + } + + public interface ChunkInfoOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.Source source = 1; + boolean hasSource(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source getSource(); + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectType object_type = 2; + boolean hasObjectType(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType getObjectType(); + + // optional bool is_fragment = 3; + boolean hasIsFragment(); + boolean getIsFragment(); + + // optional string cached_pack_key = 4; + boolean hasCachedPackKey(); + String getCachedPackKey(); + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectCounts object_counts = 5; + boolean hasObjectCounts(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts getObjectCounts(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder getObjectCountsOrBuilder(); + + // optional int32 chunk_size = 6; + boolean hasChunkSize(); + int getChunkSize(); + + // optional int32 index_size = 7; + boolean hasIndexSize(); + int getIndexSize(); + + // optional int32 meta_size = 8; + boolean hasMetaSize(); + int getMetaSize(); + } + public static final class ChunkInfo extends + com.google.protobuf.GeneratedMessage + implements ChunkInfoOrBuilder { + // Use ChunkInfo.newBuilder() to construct. + private ChunkInfo(Builder builder) { + super(builder); + } + private ChunkInfo(boolean noInit) {} + + private static final ChunkInfo defaultInstance; + public static ChunkInfo getDefaultInstance() { + return defaultInstance; + } + + public ChunkInfo getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_fieldAccessorTable; + } + + public enum Source + implements com.google.protobuf.ProtocolMessageEnum { + RECEIVE(0, 1), + INSERT(1, 2), + REPACK(2, 3), + ; + + public static final int RECEIVE_VALUE = 1; + public static final int INSERT_VALUE = 2; + public static final int REPACK_VALUE = 3; + + + public final int getNumber() { return value; } + + public static Source valueOf(int value) { + switch (value) { + case 1: return RECEIVE; + case 2: return INSERT; + case 3: return REPACK; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Source findValueByNumber(int number) { + return Source.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.getDescriptor().getEnumTypes().get(0); + } + + private static final Source[] VALUES = { + RECEIVE, INSERT, REPACK, + }; + + public static Source valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private Source(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.eclipse.jgit.storage.dht.ChunkInfo.Source) + } + + public enum ObjectType + implements com.google.protobuf.ProtocolMessageEnum { + MIXED(0, 0), + COMMIT(1, 1), + TREE(2, 2), + BLOB(3, 3), + TAG(4, 4), + ; + + public static final int MIXED_VALUE = 0; + public static final int COMMIT_VALUE = 1; + public static final int TREE_VALUE = 2; + public static final int BLOB_VALUE = 3; + public static final int TAG_VALUE = 4; + + + public final int getNumber() { return value; } + + public static ObjectType valueOf(int value) { + switch (value) { + case 0: return MIXED; + case 1: return COMMIT; + case 2: return TREE; + case 3: return BLOB; + case 4: return TAG; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ObjectType findValueByNumber(int number) { + return ObjectType.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.getDescriptor().getEnumTypes().get(1); + } + + private static final ObjectType[] VALUES = { + MIXED, COMMIT, TREE, BLOB, TAG, + }; + + public static ObjectType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private ObjectType(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.eclipse.jgit.storage.dht.ChunkInfo.ObjectType) + } + + public interface ObjectCountsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional int32 total = 1; + boolean hasTotal(); + int getTotal(); + + // optional int32 whole = 2; + boolean hasWhole(); + int getWhole(); + + // optional int32 ofs_delta = 3; + boolean hasOfsDelta(); + int getOfsDelta(); + + // optional int32 ref_delta = 4; + boolean hasRefDelta(); + int getRefDelta(); + } + public static final class ObjectCounts extends + com.google.protobuf.GeneratedMessage + implements ObjectCountsOrBuilder { + // Use ObjectCounts.newBuilder() to construct. + private ObjectCounts(Builder builder) { + super(builder); + } + private ObjectCounts(boolean noInit) {} + + private static final ObjectCounts defaultInstance; + public static ObjectCounts getDefaultInstance() { + return defaultInstance; + } + + public ObjectCounts getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_fieldAccessorTable; + } + + private int bitField0_; + // optional int32 total = 1; + public static final int TOTAL_FIELD_NUMBER = 1; + private int total_; + public boolean hasTotal() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getTotal() { + return total_; + } + + // optional int32 whole = 2; + public static final int WHOLE_FIELD_NUMBER = 2; + private int whole_; + public boolean hasWhole() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getWhole() { + return whole_; + } + + // optional int32 ofs_delta = 3; + public static final int OFS_DELTA_FIELD_NUMBER = 3; + private int ofsDelta_; + public boolean hasOfsDelta() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public int getOfsDelta() { + return ofsDelta_; + } + + // optional int32 ref_delta = 4; + public static final int REF_DELTA_FIELD_NUMBER = 4; + private int refDelta_; + public boolean hasRefDelta() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public int getRefDelta() { + return refDelta_; + } + + private void initFields() { + total_ = 0; + whole_ = 0; + ofsDelta_ = 0; + refDelta_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, total_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, whole_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, ofsDelta_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, refDelta_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, total_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, whole_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, ofsDelta_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, refDelta_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts) obj; + + boolean result = true; + result = result && (hasTotal() == other.hasTotal()); + if (hasTotal()) { + result = result && (getTotal() + == other.getTotal()); + } + result = result && (hasWhole() == other.hasWhole()); + if (hasWhole()) { + result = result && (getWhole() + == other.getWhole()); + } + result = result && (hasOfsDelta() == other.hasOfsDelta()); + if (hasOfsDelta()) { + result = result && (getOfsDelta() + == other.getOfsDelta()); + } + result = result && (hasRefDelta() == other.hasRefDelta()); + if (hasRefDelta()) { + result = result && (getRefDelta() + == other.getRefDelta()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasTotal()) { + hash = (37 * hash) + TOTAL_FIELD_NUMBER; + hash = (53 * hash) + getTotal(); + } + if (hasWhole()) { + hash = (37 * hash) + WHOLE_FIELD_NUMBER; + hash = (53 * hash) + getWhole(); + } + if (hasOfsDelta()) { + hash = (37 * hash) + OFS_DELTA_FIELD_NUMBER; + hash = (53 * hash) + getOfsDelta(); + } + if (hasRefDelta()) { + hash = (37 * hash) + REF_DELTA_FIELD_NUMBER; + hash = (53 * hash) + getRefDelta(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + total_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + whole_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + ofsDelta_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + refDelta_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.total_ = total_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.whole_ = whole_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.ofsDelta_ = ofsDelta_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.refDelta_ = refDelta_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance()) return this; + if (other.hasTotal()) { + setTotal(other.getTotal()); + } + if (other.hasWhole()) { + setWhole(other.getWhole()); + } + if (other.hasOfsDelta()) { + setOfsDelta(other.getOfsDelta()); + } + if (other.hasRefDelta()) { + setRefDelta(other.getRefDelta()); + } + this.mergeUnknownFields(other.getUnknownFields()); + 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 { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + total_ = input.readInt32(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + whole_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + ofsDelta_ = input.readInt32(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + refDelta_ = input.readInt32(); + break; + } + } + } + } + + private int bitField0_; + + // optional int32 total = 1; + private int total_ ; + public boolean hasTotal() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getTotal() { + return total_; + } + public Builder setTotal(int value) { + bitField0_ |= 0x00000001; + total_ = value; + onChanged(); + return this; + } + public Builder clearTotal() { + bitField0_ = (bitField0_ & ~0x00000001); + total_ = 0; + onChanged(); + return this; + } + + // optional int32 whole = 2; + private int whole_ ; + public boolean hasWhole() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getWhole() { + return whole_; + } + public Builder setWhole(int value) { + bitField0_ |= 0x00000002; + whole_ = value; + onChanged(); + return this; + } + public Builder clearWhole() { + bitField0_ = (bitField0_ & ~0x00000002); + whole_ = 0; + onChanged(); + return this; + } + + // optional int32 ofs_delta = 3; + private int ofsDelta_ ; + public boolean hasOfsDelta() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public int getOfsDelta() { + return ofsDelta_; + } + public Builder setOfsDelta(int value) { + bitField0_ |= 0x00000004; + ofsDelta_ = value; + onChanged(); + return this; + } + public Builder clearOfsDelta() { + bitField0_ = (bitField0_ & ~0x00000004); + ofsDelta_ = 0; + onChanged(); + return this; + } + + // optional int32 ref_delta = 4; + private int refDelta_ ; + public boolean hasRefDelta() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public int getRefDelta() { + return refDelta_; + } + public Builder setRefDelta(int value) { + bitField0_ |= 0x00000008; + refDelta_ = value; + onChanged(); + return this; + } + public Builder clearRefDelta() { + bitField0_ = (bitField0_ & ~0x00000008); + refDelta_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ChunkInfo.ObjectCounts) + } + + static { + defaultInstance = new ObjectCounts(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ChunkInfo.ObjectCounts) + } + + private int bitField0_; + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.Source source = 1; + public static final int SOURCE_FIELD_NUMBER = 1; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source source_; + public boolean hasSource() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source getSource() { + return source_; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectType object_type = 2; + public static final int OBJECT_TYPE_FIELD_NUMBER = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType objectType_; + public boolean hasObjectType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType getObjectType() { + return objectType_; + } + + // optional bool is_fragment = 3; + public static final int IS_FRAGMENT_FIELD_NUMBER = 3; + private boolean isFragment_; + public boolean hasIsFragment() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public boolean getIsFragment() { + return isFragment_; + } + + // optional string cached_pack_key = 4; + public static final int CACHED_PACK_KEY_FIELD_NUMBER = 4; + private Object cachedPackKey_; + public boolean hasCachedPackKey() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public String getCachedPackKey() { + Object ref = cachedPackKey_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + cachedPackKey_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getCachedPackKeyBytes() { + Object ref = cachedPackKey_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + cachedPackKey_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectCounts object_counts = 5; + public static final int OBJECT_COUNTS_FIELD_NUMBER = 5; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts objectCounts_; + public boolean hasObjectCounts() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts getObjectCounts() { + return objectCounts_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder getObjectCountsOrBuilder() { + return objectCounts_; + } + + // optional int32 chunk_size = 6; + public static final int CHUNK_SIZE_FIELD_NUMBER = 6; + private int chunkSize_; + public boolean hasChunkSize() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public int getChunkSize() { + return chunkSize_; + } + + // optional int32 index_size = 7; + public static final int INDEX_SIZE_FIELD_NUMBER = 7; + private int indexSize_; + public boolean hasIndexSize() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + public int getIndexSize() { + return indexSize_; + } + + // optional int32 meta_size = 8; + public static final int META_SIZE_FIELD_NUMBER = 8; + private int metaSize_; + public boolean hasMetaSize() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + public int getMetaSize() { + return metaSize_; + } + + private void initFields() { + source_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source.RECEIVE; + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType.MIXED; + isFragment_ = false; + cachedPackKey_ = ""; + objectCounts_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance(); + chunkSize_ = 0; + indexSize_ = 0; + metaSize_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, source_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeEnum(2, objectType_.getNumber()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, isFragment_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBytes(4, getCachedPackKeyBytes()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, objectCounts_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeInt32(6, chunkSize_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeInt32(7, indexSize_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeInt32(8, metaSize_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, source_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, objectType_.getNumber()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, isFragment_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(4, getCachedPackKeyBytes()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, objectCounts_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(6, chunkSize_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(7, indexSize_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(8, metaSize_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo) obj; + + boolean result = true; + result = result && (hasSource() == other.hasSource()); + if (hasSource()) { + result = result && + (getSource() == other.getSource()); + } + result = result && (hasObjectType() == other.hasObjectType()); + if (hasObjectType()) { + result = result && + (getObjectType() == other.getObjectType()); + } + result = result && (hasIsFragment() == other.hasIsFragment()); + if (hasIsFragment()) { + result = result && (getIsFragment() + == other.getIsFragment()); + } + result = result && (hasCachedPackKey() == other.hasCachedPackKey()); + if (hasCachedPackKey()) { + result = result && getCachedPackKey() + .equals(other.getCachedPackKey()); + } + result = result && (hasObjectCounts() == other.hasObjectCounts()); + if (hasObjectCounts()) { + result = result && getObjectCounts() + .equals(other.getObjectCounts()); + } + result = result && (hasChunkSize() == other.hasChunkSize()); + if (hasChunkSize()) { + result = result && (getChunkSize() + == other.getChunkSize()); + } + result = result && (hasIndexSize() == other.hasIndexSize()); + if (hasIndexSize()) { + result = result && (getIndexSize() + == other.getIndexSize()); + } + result = result && (hasMetaSize() == other.hasMetaSize()); + if (hasMetaSize()) { + result = result && (getMetaSize() + == other.getMetaSize()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasSource()) { + hash = (37 * hash) + SOURCE_FIELD_NUMBER; + hash = (53 * hash) + hashEnum(getSource()); + } + if (hasObjectType()) { + hash = (37 * hash) + OBJECT_TYPE_FIELD_NUMBER; + hash = (53 * hash) + hashEnum(getObjectType()); + } + if (hasIsFragment()) { + hash = (37 * hash) + IS_FRAGMENT_FIELD_NUMBER; + hash = (53 * hash) + hashBoolean(getIsFragment()); + } + if (hasCachedPackKey()) { + hash = (37 * hash) + CACHED_PACK_KEY_FIELD_NUMBER; + hash = (53 * hash) + getCachedPackKey().hashCode(); + } + if (hasObjectCounts()) { + hash = (37 * hash) + OBJECT_COUNTS_FIELD_NUMBER; + hash = (53 * hash) + getObjectCounts().hashCode(); + } + if (hasChunkSize()) { + hash = (37 * hash) + CHUNK_SIZE_FIELD_NUMBER; + hash = (53 * hash) + getChunkSize(); + } + if (hasIndexSize()) { + hash = (37 * hash) + INDEX_SIZE_FIELD_NUMBER; + hash = (53 * hash) + getIndexSize(); + } + if (hasMetaSize()) { + hash = (37 * hash) + META_SIZE_FIELD_NUMBER; + hash = (53 * hash) + getMetaSize(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getObjectCountsFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + source_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source.RECEIVE; + bitField0_ = (bitField0_ & ~0x00000001); + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType.MIXED; + bitField0_ = (bitField0_ & ~0x00000002); + isFragment_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + cachedPackKey_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + if (objectCountsBuilder_ == null) { + objectCounts_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance(); + } else { + objectCountsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + chunkSize_ = 0; + bitField0_ = (bitField0_ & ~0x00000020); + indexSize_ = 0; + bitField0_ = (bitField0_ & ~0x00000040); + metaSize_ = 0; + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.source_ = source_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.objectType_ = objectType_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.isFragment_ = isFragment_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.cachedPackKey_ = cachedPackKey_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + if (objectCountsBuilder_ == null) { + result.objectCounts_ = objectCounts_; + } else { + result.objectCounts_ = objectCountsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.chunkSize_ = chunkSize_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.indexSize_ = indexSize_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.metaSize_ = metaSize_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.getDefaultInstance()) return this; + if (other.hasSource()) { + setSource(other.getSource()); + } + if (other.hasObjectType()) { + setObjectType(other.getObjectType()); + } + if (other.hasIsFragment()) { + setIsFragment(other.getIsFragment()); + } + if (other.hasCachedPackKey()) { + setCachedPackKey(other.getCachedPackKey()); + } + if (other.hasObjectCounts()) { + mergeObjectCounts(other.getObjectCounts()); + } + if (other.hasChunkSize()) { + setChunkSize(other.getChunkSize()); + } + if (other.hasIndexSize()) { + setIndexSize(other.getIndexSize()); + } + if (other.hasMetaSize()) { + setMetaSize(other.getMetaSize()); + } + this.mergeUnknownFields(other.getUnknownFields()); + 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 { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source value = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + source_ = value; + } + break; + } + case 16: { + int rawValue = input.readEnum(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType value = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + objectType_ = value; + } + break; + } + case 24: { + bitField0_ |= 0x00000004; + isFragment_ = input.readBool(); + break; + } + case 34: { + bitField0_ |= 0x00000008; + cachedPackKey_ = input.readBytes(); + break; + } + case 42: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.newBuilder(); + if (hasObjectCounts()) { + subBuilder.mergeFrom(getObjectCounts()); + } + input.readMessage(subBuilder, extensionRegistry); + setObjectCounts(subBuilder.buildPartial()); + break; + } + case 48: { + bitField0_ |= 0x00000020; + chunkSize_ = input.readInt32(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + indexSize_ = input.readInt32(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + metaSize_ = input.readInt32(); + break; + } + } + } + } + + private int bitField0_; + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.Source source = 1; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source source_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source.RECEIVE; + public boolean hasSource() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source getSource() { + return source_; + } + public Builder setSource(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + source_ = value; + onChanged(); + return this; + } + public Builder clearSource() { + bitField0_ = (bitField0_ & ~0x00000001); + source_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Source.RECEIVE; + onChanged(); + return this; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectType object_type = 2; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType.MIXED; + public boolean hasObjectType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType getObjectType() { + return objectType_; + } + public Builder setObjectType(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + objectType_ = value; + onChanged(); + return this; + } + public Builder clearObjectType() { + bitField0_ = (bitField0_ & ~0x00000002); + objectType_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectType.MIXED; + onChanged(); + return this; + } + + // optional bool is_fragment = 3; + private boolean isFragment_ ; + public boolean hasIsFragment() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public boolean getIsFragment() { + return isFragment_; + } + public Builder setIsFragment(boolean value) { + bitField0_ |= 0x00000004; + isFragment_ = value; + onChanged(); + return this; + } + public Builder clearIsFragment() { + bitField0_ = (bitField0_ & ~0x00000004); + isFragment_ = false; + onChanged(); + return this; + } + + // optional string cached_pack_key = 4; + private Object cachedPackKey_ = ""; + public boolean hasCachedPackKey() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public String getCachedPackKey() { + Object ref = cachedPackKey_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + cachedPackKey_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setCachedPackKey(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + cachedPackKey_ = value; + onChanged(); + return this; + } + public Builder clearCachedPackKey() { + bitField0_ = (bitField0_ & ~0x00000008); + cachedPackKey_ = getDefaultInstance().getCachedPackKey(); + onChanged(); + return this; + } + void setCachedPackKey(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000008; + cachedPackKey_ = value; + onChanged(); + } + + // optional .org.eclipse.jgit.storage.dht.ChunkInfo.ObjectCounts object_counts = 5; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts objectCounts_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder> objectCountsBuilder_; + public boolean hasObjectCounts() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts getObjectCounts() { + if (objectCountsBuilder_ == null) { + return objectCounts_; + } else { + return objectCountsBuilder_.getMessage(); + } + } + public Builder setObjectCounts(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts value) { + if (objectCountsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + objectCounts_ = value; + onChanged(); + } else { + objectCountsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + public Builder setObjectCounts( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder builderForValue) { + if (objectCountsBuilder_ == null) { + objectCounts_ = builderForValue.build(); + onChanged(); + } else { + objectCountsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + public Builder mergeObjectCounts(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts value) { + if (objectCountsBuilder_ == null) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + objectCounts_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance()) { + objectCounts_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.newBuilder(objectCounts_).mergeFrom(value).buildPartial(); + } else { + objectCounts_ = value; + } + onChanged(); + } else { + objectCountsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + public Builder clearObjectCounts() { + if (objectCountsBuilder_ == null) { + objectCounts_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.getDefaultInstance(); + onChanged(); + } else { + objectCountsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder getObjectCountsBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getObjectCountsFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder getObjectCountsOrBuilder() { + if (objectCountsBuilder_ != null) { + return objectCountsBuilder_.getMessageOrBuilder(); + } else { + return objectCounts_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder> + getObjectCountsFieldBuilder() { + if (objectCountsBuilder_ == null) { + objectCountsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCountsOrBuilder>( + objectCounts_, + getParentForChildren(), + isClean()); + objectCounts_ = null; + } + return objectCountsBuilder_; + } + + // optional int32 chunk_size = 6; + private int chunkSize_ ; + public boolean hasChunkSize() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public int getChunkSize() { + return chunkSize_; + } + public Builder setChunkSize(int value) { + bitField0_ |= 0x00000020; + chunkSize_ = value; + onChanged(); + return this; + } + public Builder clearChunkSize() { + bitField0_ = (bitField0_ & ~0x00000020); + chunkSize_ = 0; + onChanged(); + return this; + } + + // optional int32 index_size = 7; + private int indexSize_ ; + public boolean hasIndexSize() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + public int getIndexSize() { + return indexSize_; + } + public Builder setIndexSize(int value) { + bitField0_ |= 0x00000040; + indexSize_ = value; + onChanged(); + return this; + } + public Builder clearIndexSize() { + bitField0_ = (bitField0_ & ~0x00000040); + indexSize_ = 0; + onChanged(); + return this; + } + + // optional int32 meta_size = 8; + private int metaSize_ ; + public boolean hasMetaSize() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + public int getMetaSize() { + return metaSize_; + } + public Builder setMetaSize(int value) { + bitField0_ |= 0x00000080; + metaSize_ = value; + onChanged(); + return this; + } + public Builder clearMetaSize() { + bitField0_ = (bitField0_ & ~0x00000080); + metaSize_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ChunkInfo) + } + + static { + defaultInstance = new ChunkInfo(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ChunkInfo) + } + + public interface ChunkMetaOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated .org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk base_chunk = 1; + java.util.List + getBaseChunkList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk getBaseChunk(int index); + int getBaseChunkCount(); + java.util.List + getBaseChunkOrBuilderList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder getBaseChunkOrBuilder( + int index); + + // repeated string fragment = 2; + java.util.List getFragmentList(); + int getFragmentCount(); + String getFragment(int index); + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint commit_prefetch = 51; + boolean hasCommitPrefetch(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getCommitPrefetch(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getCommitPrefetchOrBuilder(); + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint tree_prefetch = 52; + boolean hasTreePrefetch(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getTreePrefetch(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getTreePrefetchOrBuilder(); + } + public static final class ChunkMeta extends + com.google.protobuf.GeneratedMessage + implements ChunkMetaOrBuilder { + // Use ChunkMeta.newBuilder() to construct. + private ChunkMeta(Builder builder) { + super(builder); + } + private ChunkMeta(boolean noInit) {} + + private static final ChunkMeta defaultInstance; + public static ChunkMeta getDefaultInstance() { + return defaultInstance; + } + + public ChunkMeta getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_fieldAccessorTable; + } + + public interface BaseChunkOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required int64 relative_start = 1; + boolean hasRelativeStart(); + long getRelativeStart(); + + // required string chunk_key = 2; + boolean hasChunkKey(); + String getChunkKey(); + } + public static final class BaseChunk extends + com.google.protobuf.GeneratedMessage + implements BaseChunkOrBuilder { + // Use BaseChunk.newBuilder() to construct. + private BaseChunk(Builder builder) { + super(builder); + } + private BaseChunk(boolean noInit) {} + + private static final BaseChunk defaultInstance; + public static BaseChunk getDefaultInstance() { + return defaultInstance; + } + + public BaseChunk getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_fieldAccessorTable; + } + + private int bitField0_; + // required int64 relative_start = 1; + public static final int RELATIVE_START_FIELD_NUMBER = 1; + private long relativeStart_; + public boolean hasRelativeStart() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public long getRelativeStart() { + return relativeStart_; + } + + // required string chunk_key = 2; + public static final int CHUNK_KEY_FIELD_NUMBER = 2; + private Object chunkKey_; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + chunkKey_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getChunkKeyBytes() { + Object ref = chunkKey_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + chunkKey_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + relativeStart_ = 0L; + chunkKey_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasRelativeStart()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasChunkKey()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt64(1, relativeStart_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getChunkKeyBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(1, relativeStart_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getChunkKeyBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk) obj; + + boolean result = true; + result = result && (hasRelativeStart() == other.hasRelativeStart()); + if (hasRelativeStart()) { + result = result && (getRelativeStart() + == other.getRelativeStart()); + } + result = result && (hasChunkKey() == other.hasChunkKey()); + if (hasChunkKey()) { + result = result && getChunkKey() + .equals(other.getChunkKey()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasRelativeStart()) { + hash = (37 * hash) + RELATIVE_START_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getRelativeStart()); + } + if (hasChunkKey()) { + hash = (37 * hash) + CHUNK_KEY_FIELD_NUMBER; + hash = (53 * hash) + getChunkKey().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + relativeStart_ = 0L; + bitField0_ = (bitField0_ & ~0x00000001); + chunkKey_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.relativeStart_ = relativeStart_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.chunkKey_ = chunkKey_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.getDefaultInstance()) return this; + if (other.hasRelativeStart()) { + setRelativeStart(other.getRelativeStart()); + } + if (other.hasChunkKey()) { + setChunkKey(other.getChunkKey()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasRelativeStart()) { + + return false; + } + if (!hasChunkKey()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + relativeStart_ = input.readInt64(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + chunkKey_ = input.readBytes(); + break; + } + } + } + } + + private int bitField0_; + + // required int64 relative_start = 1; + private long relativeStart_ ; + public boolean hasRelativeStart() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public long getRelativeStart() { + return relativeStart_; + } + public Builder setRelativeStart(long value) { + bitField0_ |= 0x00000001; + relativeStart_ = value; + onChanged(); + return this; + } + public Builder clearRelativeStart() { + bitField0_ = (bitField0_ & ~0x00000001); + relativeStart_ = 0L; + onChanged(); + return this; + } + + // required string chunk_key = 2; + private Object chunkKey_ = ""; + public boolean hasChunkKey() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getChunkKey() { + Object ref = chunkKey_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + chunkKey_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setChunkKey(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + chunkKey_ = value; + onChanged(); + return this; + } + public Builder clearChunkKey() { + bitField0_ = (bitField0_ & ~0x00000002); + chunkKey_ = getDefaultInstance().getChunkKey(); + onChanged(); + return this; + } + void setChunkKey(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000002; + chunkKey_ = value; + onChanged(); + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk) + } + + static { + defaultInstance = new BaseChunk(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk) + } + + public interface PrefetchHintOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated string edge = 1; + java.util.List getEdgeList(); + int getEdgeCount(); + String getEdge(int index); + + // repeated string sequential = 2; + java.util.List getSequentialList(); + int getSequentialCount(); + String getSequential(int index); + } + public static final class PrefetchHint extends + com.google.protobuf.GeneratedMessage + implements PrefetchHintOrBuilder { + // Use PrefetchHint.newBuilder() to construct. + private PrefetchHint(Builder builder) { + super(builder); + } + private PrefetchHint(boolean noInit) {} + + private static final PrefetchHint defaultInstance; + public static PrefetchHint getDefaultInstance() { + return defaultInstance; + } + + public PrefetchHint getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_fieldAccessorTable; + } + + // repeated string edge = 1; + public static final int EDGE_FIELD_NUMBER = 1; + private com.google.protobuf.LazyStringList edge_; + public java.util.List + getEdgeList() { + return edge_; + } + public int getEdgeCount() { + return edge_.size(); + } + public String getEdge(int index) { + return edge_.get(index); + } + + // repeated string sequential = 2; + public static final int SEQUENTIAL_FIELD_NUMBER = 2; + private com.google.protobuf.LazyStringList sequential_; + public java.util.List + getSequentialList() { + return sequential_; + } + public int getSequentialCount() { + return sequential_.size(); + } + public String getSequential(int index) { + return sequential_.get(index); + } + + private void initFields() { + edge_ = com.google.protobuf.LazyStringArrayList.EMPTY; + sequential_ = com.google.protobuf.LazyStringArrayList.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < edge_.size(); i++) { + output.writeBytes(1, edge_.getByteString(i)); + } + for (int i = 0; i < sequential_.size(); i++) { + output.writeBytes(2, sequential_.getByteString(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < edge_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(edge_.getByteString(i)); + } + size += dataSize; + size += 1 * getEdgeList().size(); + } + { + int dataSize = 0; + for (int i = 0; i < sequential_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(sequential_.getByteString(i)); + } + size += dataSize; + size += 1 * getSequentialList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint) obj; + + boolean result = true; + result = result && getEdgeList() + .equals(other.getEdgeList()); + result = result && getSequentialList() + .equals(other.getSequentialList()); + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getEdgeCount() > 0) { + hash = (37 * hash) + EDGE_FIELD_NUMBER; + hash = (53 * hash) + getEdgeList().hashCode(); + } + if (getSequentialCount() > 0) { + hash = (37 * hash) + SEQUENTIAL_FIELD_NUMBER; + hash = (53 * hash) + getSequentialList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + edge_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + sequential_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + edge_ = new com.google.protobuf.UnmodifiableLazyStringList( + edge_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.edge_ = edge_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + sequential_ = new com.google.protobuf.UnmodifiableLazyStringList( + sequential_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.sequential_ = sequential_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance()) return this; + if (!other.edge_.isEmpty()) { + if (edge_.isEmpty()) { + edge_ = other.edge_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureEdgeIsMutable(); + edge_.addAll(other.edge_); + } + onChanged(); + } + if (!other.sequential_.isEmpty()) { + if (sequential_.isEmpty()) { + sequential_ = other.sequential_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureSequentialIsMutable(); + sequential_.addAll(other.sequential_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + 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 { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + ensureEdgeIsMutable(); + edge_.add(input.readBytes()); + break; + } + case 18: { + ensureSequentialIsMutable(); + sequential_.add(input.readBytes()); + break; + } + } + } + } + + private int bitField0_; + + // repeated string edge = 1; + private com.google.protobuf.LazyStringList edge_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureEdgeIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + edge_ = new com.google.protobuf.LazyStringArrayList(edge_); + bitField0_ |= 0x00000001; + } + } + public java.util.List + getEdgeList() { + return java.util.Collections.unmodifiableList(edge_); + } + public int getEdgeCount() { + return edge_.size(); + } + public String getEdge(int index) { + return edge_.get(index); + } + public Builder setEdge( + int index, String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureEdgeIsMutable(); + edge_.set(index, value); + onChanged(); + return this; + } + public Builder addEdge(String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureEdgeIsMutable(); + edge_.add(value); + onChanged(); + return this; + } + public Builder addAllEdge( + java.lang.Iterable values) { + ensureEdgeIsMutable(); + super.addAll(values, edge_); + onChanged(); + return this; + } + public Builder clearEdge() { + edge_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + void addEdge(com.google.protobuf.ByteString value) { + ensureEdgeIsMutable(); + edge_.add(value); + onChanged(); + } + + // repeated string sequential = 2; + private com.google.protobuf.LazyStringList sequential_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureSequentialIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + sequential_ = new com.google.protobuf.LazyStringArrayList(sequential_); + bitField0_ |= 0x00000002; + } + } + public java.util.List + getSequentialList() { + return java.util.Collections.unmodifiableList(sequential_); + } + public int getSequentialCount() { + return sequential_.size(); + } + public String getSequential(int index) { + return sequential_.get(index); + } + public Builder setSequential( + int index, String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSequentialIsMutable(); + sequential_.set(index, value); + onChanged(); + return this; + } + public Builder addSequential(String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSequentialIsMutable(); + sequential_.add(value); + onChanged(); + return this; + } + public Builder addAllSequential( + java.lang.Iterable values) { + ensureSequentialIsMutable(); + super.addAll(values, sequential_); + onChanged(); + return this; + } + public Builder clearSequential() { + sequential_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + void addSequential(com.google.protobuf.ByteString value) { + ensureSequentialIsMutable(); + sequential_.add(value); + onChanged(); + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint) + } + + static { + defaultInstance = new PrefetchHint(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint) + } + + private int bitField0_; + // repeated .org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk base_chunk = 1; + public static final int BASE_CHUNK_FIELD_NUMBER = 1; + private java.util.List baseChunk_; + public java.util.List getBaseChunkList() { + return baseChunk_; + } + public java.util.List + getBaseChunkOrBuilderList() { + return baseChunk_; + } + public int getBaseChunkCount() { + return baseChunk_.size(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk getBaseChunk(int index) { + return baseChunk_.get(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder getBaseChunkOrBuilder( + int index) { + return baseChunk_.get(index); + } + + // repeated string fragment = 2; + public static final int FRAGMENT_FIELD_NUMBER = 2; + private com.google.protobuf.LazyStringList fragment_; + public java.util.List + getFragmentList() { + return fragment_; + } + public int getFragmentCount() { + return fragment_.size(); + } + public String getFragment(int index) { + return fragment_.get(index); + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint commit_prefetch = 51; + public static final int COMMIT_PREFETCH_FIELD_NUMBER = 51; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint commitPrefetch_; + public boolean hasCommitPrefetch() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getCommitPrefetch() { + return commitPrefetch_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getCommitPrefetchOrBuilder() { + return commitPrefetch_; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint tree_prefetch = 52; + public static final int TREE_PREFETCH_FIELD_NUMBER = 52; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint treePrefetch_; + public boolean hasTreePrefetch() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getTreePrefetch() { + return treePrefetch_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getTreePrefetchOrBuilder() { + return treePrefetch_; + } + + private void initFields() { + baseChunk_ = java.util.Collections.emptyList(); + fragment_ = com.google.protobuf.LazyStringArrayList.EMPTY; + commitPrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + treePrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + for (int i = 0; i < getBaseChunkCount(); i++) { + if (!getBaseChunk(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < baseChunk_.size(); i++) { + output.writeMessage(1, baseChunk_.get(i)); + } + for (int i = 0; i < fragment_.size(); i++) { + output.writeBytes(2, fragment_.getByteString(i)); + } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(51, commitPrefetch_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(52, treePrefetch_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < baseChunk_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, baseChunk_.get(i)); + } + { + int dataSize = 0; + for (int i = 0; i < fragment_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(fragment_.getByteString(i)); + } + size += dataSize; + size += 1 * getFragmentList().size(); + } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(51, commitPrefetch_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(52, treePrefetch_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta) obj; + + boolean result = true; + result = result && getBaseChunkList() + .equals(other.getBaseChunkList()); + result = result && getFragmentList() + .equals(other.getFragmentList()); + result = result && (hasCommitPrefetch() == other.hasCommitPrefetch()); + if (hasCommitPrefetch()) { + result = result && getCommitPrefetch() + .equals(other.getCommitPrefetch()); + } + result = result && (hasTreePrefetch() == other.hasTreePrefetch()); + if (hasTreePrefetch()) { + result = result && getTreePrefetch() + .equals(other.getTreePrefetch()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getBaseChunkCount() > 0) { + hash = (37 * hash) + BASE_CHUNK_FIELD_NUMBER; + hash = (53 * hash) + getBaseChunkList().hashCode(); + } + if (getFragmentCount() > 0) { + hash = (37 * hash) + FRAGMENT_FIELD_NUMBER; + hash = (53 * hash) + getFragmentList().hashCode(); + } + if (hasCommitPrefetch()) { + hash = (37 * hash) + COMMIT_PREFETCH_FIELD_NUMBER; + hash = (53 * hash) + getCommitPrefetch().hashCode(); + } + if (hasTreePrefetch()) { + hash = (37 * hash) + TREE_PREFETCH_FIELD_NUMBER; + hash = (53 * hash) + getTreePrefetch().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMetaOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getBaseChunkFieldBuilder(); + getCommitPrefetchFieldBuilder(); + getTreePrefetchFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (baseChunkBuilder_ == null) { + baseChunk_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + baseChunkBuilder_.clear(); + } + fragment_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + if (commitPrefetchBuilder_ == null) { + commitPrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + } else { + commitPrefetchBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (treePrefetchBuilder_ == null) { + treePrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + } else { + treePrefetchBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (baseChunkBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001)) { + baseChunk_ = java.util.Collections.unmodifiableList(baseChunk_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.baseChunk_ = baseChunk_; + } else { + result.baseChunk_ = baseChunkBuilder_.build(); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + fragment_ = new com.google.protobuf.UnmodifiableLazyStringList( + fragment_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.fragment_ = fragment_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000001; + } + if (commitPrefetchBuilder_ == null) { + result.commitPrefetch_ = commitPrefetch_; + } else { + result.commitPrefetch_ = commitPrefetchBuilder_.build(); + } + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000002; + } + if (treePrefetchBuilder_ == null) { + result.treePrefetch_ = treePrefetch_; + } else { + result.treePrefetch_ = treePrefetchBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.getDefaultInstance()) return this; + if (baseChunkBuilder_ == null) { + if (!other.baseChunk_.isEmpty()) { + if (baseChunk_.isEmpty()) { + baseChunk_ = other.baseChunk_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureBaseChunkIsMutable(); + baseChunk_.addAll(other.baseChunk_); + } + onChanged(); + } + } else { + if (!other.baseChunk_.isEmpty()) { + if (baseChunkBuilder_.isEmpty()) { + baseChunkBuilder_.dispose(); + baseChunkBuilder_ = null; + baseChunk_ = other.baseChunk_; + bitField0_ = (bitField0_ & ~0x00000001); + baseChunkBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getBaseChunkFieldBuilder() : null; + } else { + baseChunkBuilder_.addAllMessages(other.baseChunk_); + } + } + } + if (!other.fragment_.isEmpty()) { + if (fragment_.isEmpty()) { + fragment_ = other.fragment_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureFragmentIsMutable(); + fragment_.addAll(other.fragment_); + } + onChanged(); + } + if (other.hasCommitPrefetch()) { + mergeCommitPrefetch(other.getCommitPrefetch()); + } + if (other.hasTreePrefetch()) { + mergeTreePrefetch(other.getTreePrefetch()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getBaseChunkCount(); i++) { + if (!getBaseChunk(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.newBuilder(); + input.readMessage(subBuilder, extensionRegistry); + addBaseChunk(subBuilder.buildPartial()); + break; + } + case 18: { + ensureFragmentIsMutable(); + fragment_.add(input.readBytes()); + break; + } + case 410: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.newBuilder(); + if (hasCommitPrefetch()) { + subBuilder.mergeFrom(getCommitPrefetch()); + } + input.readMessage(subBuilder, extensionRegistry); + setCommitPrefetch(subBuilder.buildPartial()); + break; + } + case 418: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.newBuilder(); + if (hasTreePrefetch()) { + subBuilder.mergeFrom(getTreePrefetch()); + } + input.readMessage(subBuilder, extensionRegistry); + setTreePrefetch(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // repeated .org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk base_chunk = 1; + private java.util.List baseChunk_ = + java.util.Collections.emptyList(); + private void ensureBaseChunkIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + baseChunk_ = new java.util.ArrayList(baseChunk_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder> baseChunkBuilder_; + + public java.util.List getBaseChunkList() { + if (baseChunkBuilder_ == null) { + return java.util.Collections.unmodifiableList(baseChunk_); + } else { + return baseChunkBuilder_.getMessageList(); + } + } + public int getBaseChunkCount() { + if (baseChunkBuilder_ == null) { + return baseChunk_.size(); + } else { + return baseChunkBuilder_.getCount(); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk getBaseChunk(int index) { + if (baseChunkBuilder_ == null) { + return baseChunk_.get(index); + } else { + return baseChunkBuilder_.getMessage(index); + } + } + public Builder setBaseChunk( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk value) { + if (baseChunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBaseChunkIsMutable(); + baseChunk_.set(index, value); + onChanged(); + } else { + baseChunkBuilder_.setMessage(index, value); + } + return this; + } + public Builder setBaseChunk( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder builderForValue) { + if (baseChunkBuilder_ == null) { + ensureBaseChunkIsMutable(); + baseChunk_.set(index, builderForValue.build()); + onChanged(); + } else { + baseChunkBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + public Builder addBaseChunk(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk value) { + if (baseChunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBaseChunkIsMutable(); + baseChunk_.add(value); + onChanged(); + } else { + baseChunkBuilder_.addMessage(value); + } + return this; + } + public Builder addBaseChunk( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk value) { + if (baseChunkBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBaseChunkIsMutable(); + baseChunk_.add(index, value); + onChanged(); + } else { + baseChunkBuilder_.addMessage(index, value); + } + return this; + } + public Builder addBaseChunk( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder builderForValue) { + if (baseChunkBuilder_ == null) { + ensureBaseChunkIsMutable(); + baseChunk_.add(builderForValue.build()); + onChanged(); + } else { + baseChunkBuilder_.addMessage(builderForValue.build()); + } + return this; + } + public Builder addBaseChunk( + int index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder builderForValue) { + if (baseChunkBuilder_ == null) { + ensureBaseChunkIsMutable(); + baseChunk_.add(index, builderForValue.build()); + onChanged(); + } else { + baseChunkBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + public Builder addAllBaseChunk( + java.lang.Iterable values) { + if (baseChunkBuilder_ == null) { + ensureBaseChunkIsMutable(); + super.addAll(values, baseChunk_); + onChanged(); + } else { + baseChunkBuilder_.addAllMessages(values); + } + return this; + } + public Builder clearBaseChunk() { + if (baseChunkBuilder_ == null) { + baseChunk_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + baseChunkBuilder_.clear(); + } + return this; + } + public Builder removeBaseChunk(int index) { + if (baseChunkBuilder_ == null) { + ensureBaseChunkIsMutable(); + baseChunk_.remove(index); + onChanged(); + } else { + baseChunkBuilder_.remove(index); + } + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder getBaseChunkBuilder( + int index) { + return getBaseChunkFieldBuilder().getBuilder(index); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder getBaseChunkOrBuilder( + int index) { + if (baseChunkBuilder_ == null) { + return baseChunk_.get(index); } else { + return baseChunkBuilder_.getMessageOrBuilder(index); + } + } + public java.util.List + getBaseChunkOrBuilderList() { + if (baseChunkBuilder_ != null) { + return baseChunkBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(baseChunk_); + } + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder addBaseChunkBuilder() { + return getBaseChunkFieldBuilder().addBuilder( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.getDefaultInstance()); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder addBaseChunkBuilder( + int index) { + return getBaseChunkFieldBuilder().addBuilder( + index, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.getDefaultInstance()); + } + public java.util.List + getBaseChunkBuilderList() { + return getBaseChunkFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder> + getBaseChunkFieldBuilder() { + if (baseChunkBuilder_ == null) { + baseChunkBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder>( + baseChunk_, + ((bitField0_ & 0x00000001) == 0x00000001), + getParentForChildren(), + isClean()); + baseChunk_ = null; + } + return baseChunkBuilder_; + } + + // repeated string fragment = 2; + private com.google.protobuf.LazyStringList fragment_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureFragmentIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + fragment_ = new com.google.protobuf.LazyStringArrayList(fragment_); + bitField0_ |= 0x00000002; + } + } + public java.util.List + getFragmentList() { + return java.util.Collections.unmodifiableList(fragment_); + } + public int getFragmentCount() { + return fragment_.size(); + } + public String getFragment(int index) { + return fragment_.get(index); + } + public Builder setFragment( + int index, String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFragmentIsMutable(); + fragment_.set(index, value); + onChanged(); + return this; + } + public Builder addFragment(String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFragmentIsMutable(); + fragment_.add(value); + onChanged(); + return this; + } + public Builder addAllFragment( + java.lang.Iterable values) { + ensureFragmentIsMutable(); + super.addAll(values, fragment_); + onChanged(); + return this; + } + public Builder clearFragment() { + fragment_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + void addFragment(com.google.protobuf.ByteString value) { + ensureFragmentIsMutable(); + fragment_.add(value); + onChanged(); + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint commit_prefetch = 51; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint commitPrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder> commitPrefetchBuilder_; + public boolean hasCommitPrefetch() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getCommitPrefetch() { + if (commitPrefetchBuilder_ == null) { + return commitPrefetch_; + } else { + return commitPrefetchBuilder_.getMessage(); + } + } + public Builder setCommitPrefetch(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint value) { + if (commitPrefetchBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + commitPrefetch_ = value; + onChanged(); + } else { + commitPrefetchBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder setCommitPrefetch( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder builderForValue) { + if (commitPrefetchBuilder_ == null) { + commitPrefetch_ = builderForValue.build(); + onChanged(); + } else { + commitPrefetchBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder mergeCommitPrefetch(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint value) { + if (commitPrefetchBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + commitPrefetch_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance()) { + commitPrefetch_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.newBuilder(commitPrefetch_).mergeFrom(value).buildPartial(); + } else { + commitPrefetch_ = value; + } + onChanged(); + } else { + commitPrefetchBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder clearCommitPrefetch() { + if (commitPrefetchBuilder_ == null) { + commitPrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + onChanged(); + } else { + commitPrefetchBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder getCommitPrefetchBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCommitPrefetchFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getCommitPrefetchOrBuilder() { + if (commitPrefetchBuilder_ != null) { + return commitPrefetchBuilder_.getMessageOrBuilder(); + } else { + return commitPrefetch_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder> + getCommitPrefetchFieldBuilder() { + if (commitPrefetchBuilder_ == null) { + commitPrefetchBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder>( + commitPrefetch_, + getParentForChildren(), + isClean()); + commitPrefetch_ = null; + } + return commitPrefetchBuilder_; + } + + // optional .org.eclipse.jgit.storage.dht.ChunkMeta.PrefetchHint tree_prefetch = 52; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint treePrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder> treePrefetchBuilder_; + public boolean hasTreePrefetch() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint getTreePrefetch() { + if (treePrefetchBuilder_ == null) { + return treePrefetch_; + } else { + return treePrefetchBuilder_.getMessage(); + } + } + public Builder setTreePrefetch(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint value) { + if (treePrefetchBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + treePrefetch_ = value; + onChanged(); + } else { + treePrefetchBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder setTreePrefetch( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder builderForValue) { + if (treePrefetchBuilder_ == null) { + treePrefetch_ = builderForValue.build(); + onChanged(); + } else { + treePrefetchBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder mergeTreePrefetch(org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint value) { + if (treePrefetchBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + treePrefetch_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance()) { + treePrefetch_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.newBuilder(treePrefetch_).mergeFrom(value).buildPartial(); + } else { + treePrefetch_ = value; + } + onChanged(); + } else { + treePrefetchBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + public Builder clearTreePrefetch() { + if (treePrefetchBuilder_ == null) { + treePrefetch_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.getDefaultInstance(); + onChanged(); + } else { + treePrefetchBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder getTreePrefetchBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getTreePrefetchFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder getTreePrefetchOrBuilder() { + if (treePrefetchBuilder_ != null) { + return treePrefetchBuilder_.getMessageOrBuilder(); + } else { + return treePrefetch_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder> + getTreePrefetchFieldBuilder() { + if (treePrefetchBuilder_ == null) { + treePrefetchBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHintOrBuilder>( + treePrefetch_, + getParentForChildren(), + isClean()); + treePrefetch_ = null; + } + return treePrefetchBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.ChunkMeta) + } + + static { + defaultInstance = new ChunkMeta(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.ChunkMeta) + } + + public interface CachedPackInfoOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string name = 1; + boolean hasName(); + String getName(); + + // required string version = 2; + boolean hasVersion(); + String getVersion(); + + // required int64 objects_total = 3; + boolean hasObjectsTotal(); + long getObjectsTotal(); + + // optional int64 objects_delta = 4; + boolean hasObjectsDelta(); + long getObjectsDelta(); + + // optional int64 bytes_total = 5; + boolean hasBytesTotal(); + long getBytesTotal(); + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.TipObjectList tip_list = 6; + boolean hasTipList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList getTipList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder getTipListOrBuilder(); + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.ChunkList chunk_list = 7; + boolean hasChunkList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList getChunkList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder getChunkListOrBuilder(); + } + public static final class CachedPackInfo extends + com.google.protobuf.GeneratedMessage + implements CachedPackInfoOrBuilder { + // Use CachedPackInfo.newBuilder() to construct. + private CachedPackInfo(Builder builder) { + super(builder); + } + private CachedPackInfo(boolean noInit) {} + + private static final CachedPackInfo defaultInstance; + public static CachedPackInfo getDefaultInstance() { + return defaultInstance; + } + + public CachedPackInfo getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_fieldAccessorTable; + } + + public interface TipObjectListOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated string object_name = 1; + java.util.List getObjectNameList(); + int getObjectNameCount(); + String getObjectName(int index); + } + public static final class TipObjectList extends + com.google.protobuf.GeneratedMessage + implements TipObjectListOrBuilder { + // Use TipObjectList.newBuilder() to construct. + private TipObjectList(Builder builder) { + super(builder); + } + private TipObjectList(boolean noInit) {} + + private static final TipObjectList defaultInstance; + public static TipObjectList getDefaultInstance() { + return defaultInstance; + } + + public TipObjectList getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_fieldAccessorTable; + } + + // repeated string object_name = 1; + public static final int OBJECT_NAME_FIELD_NUMBER = 1; + private com.google.protobuf.LazyStringList objectName_; + public java.util.List + getObjectNameList() { + return objectName_; + } + public int getObjectNameCount() { + return objectName_.size(); + } + public String getObjectName(int index) { + return objectName_.get(index); + } + + private void initFields() { + objectName_ = com.google.protobuf.LazyStringArrayList.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < objectName_.size(); i++) { + output.writeBytes(1, objectName_.getByteString(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < objectName_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(objectName_.getByteString(i)); + } + size += dataSize; + size += 1 * getObjectNameList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList) obj; + + boolean result = true; + result = result && getObjectNameList() + .equals(other.getObjectNameList()); + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getObjectNameCount() > 0) { + hash = (37 * hash) + OBJECT_NAME_FIELD_NUMBER; + hash = (53 * hash) + getObjectNameList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + objectName_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + objectName_ = new com.google.protobuf.UnmodifiableLazyStringList( + objectName_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.objectName_ = objectName_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance()) return this; + if (!other.objectName_.isEmpty()) { + if (objectName_.isEmpty()) { + objectName_ = other.objectName_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureObjectNameIsMutable(); + objectName_.addAll(other.objectName_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + 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 { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + ensureObjectNameIsMutable(); + objectName_.add(input.readBytes()); + break; + } + } + } + } + + private int bitField0_; + + // repeated string object_name = 1; + private com.google.protobuf.LazyStringList objectName_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureObjectNameIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + objectName_ = new com.google.protobuf.LazyStringArrayList(objectName_); + bitField0_ |= 0x00000001; + } + } + public java.util.List + getObjectNameList() { + return java.util.Collections.unmodifiableList(objectName_); + } + public int getObjectNameCount() { + return objectName_.size(); + } + public String getObjectName(int index) { + return objectName_.get(index); + } + public Builder setObjectName( + int index, String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectNameIsMutable(); + objectName_.set(index, value); + onChanged(); + return this; + } + public Builder addObjectName(String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectNameIsMutable(); + objectName_.add(value); + onChanged(); + return this; + } + public Builder addAllObjectName( + java.lang.Iterable values) { + ensureObjectNameIsMutable(); + super.addAll(values, objectName_); + onChanged(); + return this; + } + public Builder clearObjectName() { + objectName_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + void addObjectName(com.google.protobuf.ByteString value) { + ensureObjectNameIsMutable(); + objectName_.add(value); + onChanged(); + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedPackInfo.TipObjectList) + } + + static { + defaultInstance = new TipObjectList(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedPackInfo.TipObjectList) + } + + public interface ChunkListOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // repeated string chunk_key = 1; + java.util.List getChunkKeyList(); + int getChunkKeyCount(); + String getChunkKey(int index); + } + public static final class ChunkList extends + com.google.protobuf.GeneratedMessage + implements ChunkListOrBuilder { + // Use ChunkList.newBuilder() to construct. + private ChunkList(Builder builder) { + super(builder); + } + private ChunkList(boolean noInit) {} + + private static final ChunkList defaultInstance; + public static ChunkList getDefaultInstance() { + return defaultInstance; + } + + public ChunkList getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_fieldAccessorTable; + } + + // repeated string chunk_key = 1; + public static final int CHUNK_KEY_FIELD_NUMBER = 1; + private com.google.protobuf.LazyStringList chunkKey_; + public java.util.List + getChunkKeyList() { + return chunkKey_; + } + public int getChunkKeyCount() { + return chunkKey_.size(); + } + public String getChunkKey(int index) { + return chunkKey_.get(index); + } + + private void initFields() { + chunkKey_ = com.google.protobuf.LazyStringArrayList.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < chunkKey_.size(); i++) { + output.writeBytes(1, chunkKey_.getByteString(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < chunkKey_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(chunkKey_.getByteString(i)); + } + size += dataSize; + size += 1 * getChunkKeyList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList) obj; + + boolean result = true; + result = result && getChunkKeyList() + .equals(other.getChunkKeyList()); + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (getChunkKeyCount() > 0) { + hash = (37 * hash) + CHUNK_KEY_FIELD_NUMBER; + hash = (53 * hash) + getChunkKeyList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + chunkKey_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + chunkKey_ = new com.google.protobuf.UnmodifiableLazyStringList( + chunkKey_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.chunkKey_ = chunkKey_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance()) return this; + if (!other.chunkKey_.isEmpty()) { + if (chunkKey_.isEmpty()) { + chunkKey_ = other.chunkKey_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureChunkKeyIsMutable(); + chunkKey_.addAll(other.chunkKey_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + 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 { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + ensureChunkKeyIsMutable(); + chunkKey_.add(input.readBytes()); + break; + } + } + } + } + + private int bitField0_; + + // repeated string chunk_key = 1; + private com.google.protobuf.LazyStringList chunkKey_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureChunkKeyIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + chunkKey_ = new com.google.protobuf.LazyStringArrayList(chunkKey_); + bitField0_ |= 0x00000001; + } + } + public java.util.List + getChunkKeyList() { + return java.util.Collections.unmodifiableList(chunkKey_); + } + public int getChunkKeyCount() { + return chunkKey_.size(); + } + public String getChunkKey(int index) { + return chunkKey_.get(index); + } + public Builder setChunkKey( + int index, String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureChunkKeyIsMutable(); + chunkKey_.set(index, value); + onChanged(); + return this; + } + public Builder addChunkKey(String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureChunkKeyIsMutable(); + chunkKey_.add(value); + onChanged(); + return this; + } + public Builder addAllChunkKey( + java.lang.Iterable values) { + ensureChunkKeyIsMutable(); + super.addAll(values, chunkKey_); + onChanged(); + return this; + } + public Builder clearChunkKey() { + chunkKey_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + void addChunkKey(com.google.protobuf.ByteString value) { + ensureChunkKeyIsMutable(); + chunkKey_.add(value); + onChanged(); + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedPackInfo.ChunkList) + } + + static { + defaultInstance = new ChunkList(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedPackInfo.ChunkList) + } + + private int bitField0_; + // required string name = 1; + public static final int NAME_FIELD_NUMBER = 1; + private Object name_; + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getName() { + Object ref = name_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + name_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getNameBytes() { + Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required string version = 2; + public static final int VERSION_FIELD_NUMBER = 2; + private Object version_; + public boolean hasVersion() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getVersion() { + Object ref = version_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + if (com.google.protobuf.Internal.isValidUtf8(bs)) { + version_ = s; + } + return s; + } + } + private com.google.protobuf.ByteString getVersionBytes() { + Object ref = version_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8((String) ref); + version_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int64 objects_total = 3; + public static final int OBJECTS_TOTAL_FIELD_NUMBER = 3; + private long objectsTotal_; + public boolean hasObjectsTotal() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getObjectsTotal() { + return objectsTotal_; + } + + // optional int64 objects_delta = 4; + public static final int OBJECTS_DELTA_FIELD_NUMBER = 4; + private long objectsDelta_; + public boolean hasObjectsDelta() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public long getObjectsDelta() { + return objectsDelta_; + } + + // optional int64 bytes_total = 5; + public static final int BYTES_TOTAL_FIELD_NUMBER = 5; + private long bytesTotal_; + public boolean hasBytesTotal() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public long getBytesTotal() { + return bytesTotal_; + } + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.TipObjectList tip_list = 6; + public static final int TIP_LIST_FIELD_NUMBER = 6; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList tipList_; + public boolean hasTipList() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList getTipList() { + return tipList_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder getTipListOrBuilder() { + return tipList_; + } + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.ChunkList chunk_list = 7; + public static final int CHUNK_LIST_FIELD_NUMBER = 7; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList chunkList_; + public boolean hasChunkList() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList getChunkList() { + return chunkList_; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder getChunkListOrBuilder() { + return chunkList_; + } + + private void initFields() { + name_ = ""; + version_ = ""; + objectsTotal_ = 0L; + objectsDelta_ = 0L; + bytesTotal_ = 0L; + tipList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance(); + chunkList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVersion()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasObjectsTotal()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasTipList()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasChunkList()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getVersionBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt64(3, objectsTotal_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt64(4, objectsDelta_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeInt64(5, bytesTotal_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeMessage(6, tipList_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeMessage(7, chunkList_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getVersionBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(3, objectsTotal_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(4, objectsDelta_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(5, bytesTotal_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, tipList_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, chunkList_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + @java.lang.Override + protected Object writeReplace() throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo)) { + return super.equals(obj); + } + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo other = (org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo) obj; + + boolean result = true; + result = result && (hasName() == other.hasName()); + if (hasName()) { + result = result && getName() + .equals(other.getName()); + } + result = result && (hasVersion() == other.hasVersion()); + if (hasVersion()) { + result = result && getVersion() + .equals(other.getVersion()); + } + result = result && (hasObjectsTotal() == other.hasObjectsTotal()); + if (hasObjectsTotal()) { + result = result && (getObjectsTotal() + == other.getObjectsTotal()); + } + result = result && (hasObjectsDelta() == other.hasObjectsDelta()); + if (hasObjectsDelta()) { + result = result && (getObjectsDelta() + == other.getObjectsDelta()); + } + result = result && (hasBytesTotal() == other.hasBytesTotal()); + if (hasBytesTotal()) { + result = result && (getBytesTotal() + == other.getBytesTotal()); + } + result = result && (hasTipList() == other.hasTipList()); + if (hasTipList()) { + result = result && getTipList() + .equals(other.getTipList()); + } + result = result && (hasChunkList() == other.hasChunkList()); + if (hasChunkList()) { + result = result && getChunkList() + .equals(other.getChunkList()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasVersion()) { + hash = (37 * hash) + VERSION_FIELD_NUMBER; + hash = (53 * hash) + getVersion().hashCode(); + } + if (hasObjectsTotal()) { + hash = (37 * hash) + OBJECTS_TOTAL_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getObjectsTotal()); + } + if (hasObjectsDelta()) { + hash = (37 * hash) + OBJECTS_DELTA_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getObjectsDelta()); + } + if (hasBytesTotal()) { + hash = (37 * hash) + BYTES_TOTAL_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getBytesTotal()); + } + if (hasTipList()) { + hash = (37 * hash) + TIP_LIST_FIELD_NUMBER; + hash = (53 * hash) + getTipList().hashCode(); + } + if (hasChunkList()) { + hash = (37 * hash) + CHUNK_LIST_FIELD_NUMBER; + hash = (53 * hash) + getChunkList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_fieldAccessorTable; + } + + // Construct using org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getTipListFieldBuilder(); + getChunkListFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + version_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + objectsTotal_ = 0L; + bitField0_ = (bitField0_ & ~0x00000004); + objectsDelta_ = 0L; + bitField0_ = (bitField0_ & ~0x00000008); + bytesTotal_ = 0L; + bitField0_ = (bitField0_ & ~0x00000010); + if (tipListBuilder_ == null) { + tipList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance(); + } else { + tipListBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + if (chunkListBuilder_ == null) { + chunkList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance(); + } else { + chunkListBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.getDescriptor(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo getDefaultInstanceForType() { + return org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.getDefaultInstance(); + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo build() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo buildPartial() { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo result = new org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.version_ = version_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.objectsTotal_ = objectsTotal_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.objectsDelta_ = objectsDelta_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.bytesTotal_ = bytesTotal_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + if (tipListBuilder_ == null) { + result.tipList_ = tipList_; + } else { + result.tipList_ = tipListBuilder_.build(); + } + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + if (chunkListBuilder_ == null) { + result.chunkList_ = chunkList_; + } else { + result.chunkList_ = chunkListBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo) { + return mergeFrom((org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo other) { + if (other == org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.getDefaultInstance()) return this; + if (other.hasName()) { + setName(other.getName()); + } + if (other.hasVersion()) { + setVersion(other.getVersion()); + } + if (other.hasObjectsTotal()) { + setObjectsTotal(other.getObjectsTotal()); + } + if (other.hasObjectsDelta()) { + setObjectsDelta(other.getObjectsDelta()); + } + if (other.hasBytesTotal()) { + setBytesTotal(other.getBytesTotal()); + } + if (other.hasTipList()) { + mergeTipList(other.getTipList()); + } + if (other.hasChunkList()) { + mergeChunkList(other.getChunkList()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasVersion()) { + + return false; + } + if (!hasObjectsTotal()) { + + return false; + } + if (!hasTipList()) { + + return false; + } + if (!hasChunkList()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + name_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + version_ = input.readBytes(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + objectsTotal_ = input.readInt64(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + objectsDelta_ = input.readInt64(); + break; + } + case 40: { + bitField0_ |= 0x00000010; + bytesTotal_ = input.readInt64(); + break; + } + case 50: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.newBuilder(); + if (hasTipList()) { + subBuilder.mergeFrom(getTipList()); + } + input.readMessage(subBuilder, extensionRegistry); + setTipList(subBuilder.buildPartial()); + break; + } + case 58: { + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder subBuilder = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.newBuilder(); + if (hasChunkList()) { + subBuilder.mergeFrom(getChunkList()); + } + input.readMessage(subBuilder, extensionRegistry); + setChunkList(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // required string name = 1; + private Object name_ = ""; + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public String getName() { + Object ref = name_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + name_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setName(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + void setName(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + } + + // required string version = 2; + private Object version_ = ""; + public boolean hasVersion() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public String getVersion() { + Object ref = version_; + if (!(ref instanceof String)) { + String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); + version_ = s; + return s; + } else { + return (String) ref; + } + } + public Builder setVersion(String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + version_ = value; + onChanged(); + return this; + } + public Builder clearVersion() { + bitField0_ = (bitField0_ & ~0x00000002); + version_ = getDefaultInstance().getVersion(); + onChanged(); + return this; + } + void setVersion(com.google.protobuf.ByteString value) { + bitField0_ |= 0x00000002; + version_ = value; + onChanged(); + } + + // required int64 objects_total = 3; + private long objectsTotal_ ; + public boolean hasObjectsTotal() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public long getObjectsTotal() { + return objectsTotal_; + } + public Builder setObjectsTotal(long value) { + bitField0_ |= 0x00000004; + objectsTotal_ = value; + onChanged(); + return this; + } + public Builder clearObjectsTotal() { + bitField0_ = (bitField0_ & ~0x00000004); + objectsTotal_ = 0L; + onChanged(); + return this; + } + + // optional int64 objects_delta = 4; + private long objectsDelta_ ; + public boolean hasObjectsDelta() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public long getObjectsDelta() { + return objectsDelta_; + } + public Builder setObjectsDelta(long value) { + bitField0_ |= 0x00000008; + objectsDelta_ = value; + onChanged(); + return this; + } + public Builder clearObjectsDelta() { + bitField0_ = (bitField0_ & ~0x00000008); + objectsDelta_ = 0L; + onChanged(); + return this; + } + + // optional int64 bytes_total = 5; + private long bytesTotal_ ; + public boolean hasBytesTotal() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public long getBytesTotal() { + return bytesTotal_; + } + public Builder setBytesTotal(long value) { + bitField0_ |= 0x00000010; + bytesTotal_ = value; + onChanged(); + return this; + } + public Builder clearBytesTotal() { + bitField0_ = (bitField0_ & ~0x00000010); + bytesTotal_ = 0L; + onChanged(); + return this; + } + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.TipObjectList tip_list = 6; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList tipList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder> tipListBuilder_; + public boolean hasTipList() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList getTipList() { + if (tipListBuilder_ == null) { + return tipList_; + } else { + return tipListBuilder_.getMessage(); + } + } + public Builder setTipList(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList value) { + if (tipListBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + tipList_ = value; + onChanged(); + } else { + tipListBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + public Builder setTipList( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder builderForValue) { + if (tipListBuilder_ == null) { + tipList_ = builderForValue.build(); + onChanged(); + } else { + tipListBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + public Builder mergeTipList(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList value) { + if (tipListBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + tipList_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance()) { + tipList_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.newBuilder(tipList_).mergeFrom(value).buildPartial(); + } else { + tipList_ = value; + } + onChanged(); + } else { + tipListBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + public Builder clearTipList() { + if (tipListBuilder_ == null) { + tipList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.getDefaultInstance(); + onChanged(); + } else { + tipListBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder getTipListBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getTipListFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder getTipListOrBuilder() { + if (tipListBuilder_ != null) { + return tipListBuilder_.getMessageOrBuilder(); + } else { + return tipList_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder> + getTipListFieldBuilder() { + if (tipListBuilder_ == null) { + tipListBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectListOrBuilder>( + tipList_, + getParentForChildren(), + isClean()); + tipList_ = null; + } + return tipListBuilder_; + } + + // required .org.eclipse.jgit.storage.dht.CachedPackInfo.ChunkList chunk_list = 7; + private org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList chunkList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder> chunkListBuilder_; + public boolean hasChunkList() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList getChunkList() { + if (chunkListBuilder_ == null) { + return chunkList_; + } else { + return chunkListBuilder_.getMessage(); + } + } + public Builder setChunkList(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList value) { + if (chunkListBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + chunkList_ = value; + onChanged(); + } else { + chunkListBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + return this; + } + public Builder setChunkList( + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder builderForValue) { + if (chunkListBuilder_ == null) { + chunkList_ = builderForValue.build(); + onChanged(); + } else { + chunkListBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + return this; + } + public Builder mergeChunkList(org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList value) { + if (chunkListBuilder_ == null) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + chunkList_ != org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance()) { + chunkList_ = + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.newBuilder(chunkList_).mergeFrom(value).buildPartial(); + } else { + chunkList_ = value; + } + onChanged(); + } else { + chunkListBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000040; + return this; + } + public Builder clearChunkList() { + if (chunkListBuilder_ == null) { + chunkList_ = org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.getDefaultInstance(); + onChanged(); + } else { + chunkListBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder getChunkListBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getChunkListFieldBuilder().getBuilder(); + } + public org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder getChunkListOrBuilder() { + if (chunkListBuilder_ != null) { + return chunkListBuilder_.getMessageOrBuilder(); + } else { + return chunkList_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder> + getChunkListFieldBuilder() { + if (chunkListBuilder_ == null) { + chunkListBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder, org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkListOrBuilder>( + chunkList_, + getParentForChildren(), + isClean()); + chunkList_ = null; + } + return chunkListBuilder_; + } + + // @@protoc_insertion_point(builder_scope:org.eclipse.jgit.storage.dht.CachedPackInfo) + } + + static { + defaultInstance = new CachedPackInfo(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.eclipse.jgit.storage.dht.CachedPackInfo) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_RefData_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_RefData_Id_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_RefData_Id_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_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,org/eclipse/jgit/storage/dht/git_store" + + ".proto\022\034org.eclipse.jgit.storage.dht\"\316\001\n" + + "\007RefData\022\016\n\006symref\030\001 \001(\t\0228\n\006target\030\002 \001(\013" + + "2(.org.eclipse.jgit.storage.dht.RefData." + + "Id\022\021\n\tis_peeled\030\003 \001(\010\0228\n\006peeled\030\004 \001(\0132(." + + "org.eclipse.jgit.storage.dht.RefData.Id\032" + + ",\n\002Id\022\023\n\013object_name\030\001 \002(\t\022\021\n\tchunk_key\030" + + "\002 \001(\t\"\364\001\n\nObjectInfo\022H\n\013object_type\030\001 \001(" + + "\01623.org.eclipse.jgit.storage.dht.ObjectI" + + "nfo.ObjectType\022\016\n\006offset\030\002 \002(\005\022\023\n\013packed", + "_size\030\003 \002(\003\022\025\n\rinflated_size\030\004 \002(\003\022\022\n\nde" + + "lta_base\030\005 \001(\014\022\025\n\ris_fragmented\030\006 \001(\010\"5\n" + + "\nObjectType\022\n\n\006COMMIT\020\001\022\010\n\004TREE\020\002\022\010\n\004BLO" + + "B\020\003\022\007\n\003TAG\020\004\"\217\004\n\tChunkInfo\022>\n\006source\030\001 \001" + + "(\0162..org.eclipse.jgit.storage.dht.ChunkI" + + "nfo.Source\022G\n\013object_type\030\002 \001(\01622.org.ec" + + "lipse.jgit.storage.dht.ChunkInfo.ObjectT" + + "ype\022\023\n\013is_fragment\030\003 \001(\010\022\027\n\017cached_pack_" + + "key\030\004 \001(\t\022K\n\robject_counts\030\005 \001(\01324.org.e" + + "clipse.jgit.storage.dht.ChunkInfo.Object", + "Counts\022\022\n\nchunk_size\030\006 \001(\005\022\022\n\nindex_size" + + "\030\007 \001(\005\022\021\n\tmeta_size\030\010 \001(\005\032R\n\014ObjectCount" + + "s\022\r\n\005total\030\001 \001(\005\022\r\n\005whole\030\002 \001(\005\022\021\n\tofs_d" + + "elta\030\003 \001(\005\022\021\n\tref_delta\030\004 \001(\005\"-\n\006Source\022" + + "\013\n\007RECEIVE\020\001\022\n\n\006INSERT\020\002\022\n\n\006REPACK\020\003\"@\n\n" + + "ObjectType\022\t\n\005MIXED\020\000\022\n\n\006COMMIT\020\001\022\010\n\004TRE" + + "E\020\002\022\010\n\004BLOB\020\003\022\007\n\003TAG\020\004\"\352\002\n\tChunkMeta\022E\n\n" + + "base_chunk\030\001 \003(\01321.org.eclipse.jgit.stor" + + "age.dht.ChunkMeta.BaseChunk\022\020\n\010fragment\030" + + "\002 \003(\t\022M\n\017commit_prefetch\0303 \001(\01324.org.ecl", + "ipse.jgit.storage.dht.ChunkMeta.Prefetch" + + "Hint\022K\n\rtree_prefetch\0304 \001(\01324.org.eclips" + + "e.jgit.storage.dht.ChunkMeta.PrefetchHin" + + "t\0326\n\tBaseChunk\022\026\n\016relative_start\030\001 \002(\003\022\021" + + "\n\tchunk_key\030\002 \002(\t\0320\n\014PrefetchHint\022\014\n\004edg" + + "e\030\001 \003(\t\022\022\n\nsequential\030\002 \003(\t\"\322\002\n\016CachedPa" + + "ckInfo\022\014\n\004name\030\001 \002(\t\022\017\n\007version\030\002 \002(\t\022\025\n" + + "\robjects_total\030\003 \002(\003\022\025\n\robjects_delta\030\004 " + + "\001(\003\022\023\n\013bytes_total\030\005 \001(\003\022L\n\010tip_list\030\006 \002" + + "(\0132:.org.eclipse.jgit.storage.dht.Cached", + "PackInfo.TipObjectList\022J\n\nchunk_list\030\007 \002" + + "(\01326.org.eclipse.jgit.storage.dht.Cached" + + "PackInfo.ChunkList\032$\n\rTipObjectList\022\023\n\013o" + + "bject_name\030\001 \003(\t\032\036\n\tChunkList\022\021\n\tchunk_k" + + "ey\030\001 \003(\tB1\n,org.eclipse.jgit.generated.s" + + "torage.dht.proto\240\001\001" + }; + 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; + internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_RefData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor, + new java.lang.String[] { "Symref", "Target", "IsPeeled", "Peeled", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_RefData_Id_descriptor = + internal_static_org_eclipse_jgit_storage_dht_RefData_descriptor.getNestedTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_RefData_Id_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_RefData_Id_descriptor, + new java.lang.String[] { "ObjectName", "ChunkKey", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData.Id.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ObjectInfo_descriptor, + new java.lang.String[] { "ObjectType", "Offset", "PackedSize", "InflatedSize", "DeltaBase", "IsFragmented", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor, + new java.lang.String[] { "Source", "ObjectType", "IsFragment", "CachedPackKey", "ObjectCounts", "ChunkSize", "IndexSize", "MetaSize", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_descriptor = + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_descriptor.getNestedTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ChunkInfo_ObjectCounts_descriptor, + new java.lang.String[] { "Total", "Whole", "OfsDelta", "RefDelta", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkInfo.ObjectCounts.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor, + new java.lang.String[] { "BaseChunk", "Fragment", "CommitPrefetch", "TreePrefetch", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_descriptor = + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor.getNestedTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_BaseChunk_descriptor, + new java.lang.String[] { "RelativeStart", "ChunkKey", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_descriptor = + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_descriptor.getNestedTypes().get(1); + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_ChunkMeta_PrefetchHint_descriptor, + new java.lang.String[] { "Edge", "Sequential", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.PrefetchHint.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor, + new java.lang.String[] { "Name", "Version", "ObjectsTotal", "ObjectsDelta", "BytesTotal", "TipList", "ChunkList", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_descriptor = + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor.getNestedTypes().get(0); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_TipObjectList_descriptor, + new java.lang.String[] { "ObjectName", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.TipObjectList.Builder.class); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_descriptor = + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_descriptor.getNestedTypes().get(1); + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_eclipse_jgit_storage_dht_CachedPackInfo_ChunkList_descriptor, + new java.lang.String[] { "ChunkKey", }, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.class, + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList.Builder.class); + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/org.eclipse.jgit.storage.dht/META-INF/MANIFEST.MF b/org.eclipse.jgit.storage.dht/META-INF/MANIFEST.MF index 10bc4867c..42a035a4f 100644 --- a/org.eclipse.jgit.storage.dht/META-INF/MANIFEST.MF +++ b/org.eclipse.jgit.storage.dht/META-INF/MANIFEST.MF @@ -12,7 +12,9 @@ Export-Package: org.eclipse.jgit.storage.dht;version="1.0.0", org.eclipse.jgit.storage.dht.spi.memory;version="1.0.0" Bundle-ActivationPolicy: lazy Bundle-RequiredExecutionEnvironment: J2SE-1.5 -Import-Package: org.eclipse.jgit.errors;version="[1.0.0,2.0.0)", +Import-Package: com.google.protobuf;version="[2.4.0,2.5.0)", + org.eclipse.jgit.errors;version="[1.0.0,2.0.0)", + org.eclipse.jgit.generated.storage.dht.proto;version="[1.0.0,2.0.0)", org.eclipse.jgit.lib;version="[1.0.0,2.0.0)", org.eclipse.jgit.nls;version="[1.0.0,2.0.0)", org.eclipse.jgit.revwalk;version="[1.0.0,2.0.0)", diff --git a/org.eclipse.jgit.storage.dht/pom.xml b/org.eclipse.jgit.storage.dht/pom.xml index c9fe599b5..e2340ab7a 100644 --- a/org.eclipse.jgit.storage.dht/pom.xml +++ b/org.eclipse.jgit.storage.dht/pom.xml @@ -70,6 +70,12 @@ org.eclipse.jgit ${project.version} + + + org.eclipse.jgit + org.eclipse.jgit.generated.storage.dht.proto + ${project.version} + diff --git a/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/DhtText.properties b/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/DhtText.properties index c004fda7a..d53147abf 100644 --- a/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/DhtText.properties +++ b/org.eclipse.jgit.storage.dht/resources/org/eclipse/jgit/storage/dht/DhtText.properties @@ -4,9 +4,12 @@ corruptCompressedObject=Corrupt deflate stream in {0} at {1} cycleInDeltaChain=Cycle in delta chain {0} offset {1} databaseRequired=Database is required expectedObjectSizeDuringCopyAsIs=Object {0} has size of 0 +invalidCachedPackInfo=Invalid CachedPackInfo on {0} {1} invalidChunkKey=Invalid ChunkKey {0} +invalidChunkMeta=Invalid ChunkMeta on {0} invalidObjectIndexKey=Invalid ObjectIndexKey {0} -invalidObjectInfo=Invalid ObjectInfo on {0} +invalidObjectInfo=Invalid ObjectInfo for {0} from {1} +invalidRefData=Invalid RefData on {0} missingChunk=Missing {0} missingLongOffsetBase=Missing base for offset -{1} in meta of {0} nameRequired=Name or key is required @@ -17,12 +20,6 @@ objectListCountingFrom=Counting objects in {0} objectTypeUnknown=unknown packParserInvalidPointer=Invalid pointer inside pack parser: {0}, chunk {1}, offset {2}. packParserRollbackFailed=DhtPackParser rollback failed -protobufNegativeValuesNotSupported=Negative values are not supported -protobufNoArray=bytes field requires ByteBuffer.hasArray to be true -protobufNotBooleanValue=bool field {0} has invalid value {1} -protobufUnsupportedFieldType=Unsupported protobuf field type {0} -protobufWrongFieldLength=Field {0} should have length of {1}, found {2} -protobufWrongFieldType=Field {0} is of type {1}, expected {2} recordingObjects=Recording objects repositoryAlreadyExists=Repository {0} already exists repositoryMustBeBare=Only bare repositories are supported diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackInfo.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackInfo.java deleted file mode 100644 index 95a5857f1..000000000 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackInfo.java +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright (C) 2011, Google Inc. - * and other copyright owners as documented in the project's IP log. - * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php - * - * 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 the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -package org.eclipse.jgit.storage.dht; - -import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.SortedSet; -import java.util.TreeSet; - -import org.eclipse.jgit.lib.ObjectId; - -/** - * Summary information about a cached pack owned by a repository. - */ -public class CachedPackInfo { - /** - * Parse info from the storage system. - * - * @param raw - * the raw encoding of the info. - * @return the info object. - */ - public static CachedPackInfo fromBytes(byte[] raw) { - return fromBytes(TinyProtobuf.decode(raw)); - } - - /** - * Parse info from the storage system. - * - * @param d - * decoder for the message buffer. - * @return the info object. - */ - public static CachedPackInfo fromBytes(TinyProtobuf.Decoder d) { - CachedPackInfo info = new CachedPackInfo(); - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - info.name = d.stringObjectId(); - continue; - case 2: - info.version = d.stringObjectId(); - continue; - case 3: - info.objectsTotal = d.int64(); - continue; - case 4: - info.objectsDelta = d.int64(); - continue; - case 5: - info.bytesTotal = d.int64(); - continue; - case 6: { - TinyProtobuf.Decoder m = d.message(); - for (;;) { - switch (m.next()) { - case 0: - continue PARSE; - case 1: - info.tips.add(m.stringObjectId()); - continue; - default: - m.skip(); - continue; - } - } - } - case 7: { - TinyProtobuf.Decoder m = d.message(); - for (;;) { - switch (m.next()) { - case 0: - continue PARSE; - case 1: - info.chunks.add(ChunkKey.fromBytes(m)); - continue; - default: - m.skip(); - continue; - } - } - } - default: - d.skip(); - continue; - } - } - return info; - } - - private static byte[] asBytes(CachedPackInfo info) { - int tipSize = (2 + OBJECT_ID_STRING_LENGTH) * info.tips.size(); - TinyProtobuf.Encoder tipList = TinyProtobuf.encode(tipSize); - for (ObjectId tip : info.tips) - tipList.string(1, tip); - - int chunkSize = (2 + ChunkKey.KEYLEN) * info.chunks.size(); - TinyProtobuf.Encoder chunkList = TinyProtobuf.encode(chunkSize); - for (ChunkKey key : info.chunks) - chunkList.bytes(1, key.asBytes()); - - TinyProtobuf.Encoder e = TinyProtobuf.encode(1024); - e.string(1, info.name); - e.string(2, info.version); - e.int64(3, info.objectsTotal); - e.int64IfNotZero(4, info.objectsDelta); - e.int64IfNotZero(5, info.bytesTotal); - e.message(6, tipList); - e.message(7, chunkList); - return e.asByteArray(); - } - - ObjectId name; - - ObjectId version; - - SortedSet tips = new TreeSet(); - - long objectsTotal; - - long objectsDelta; - - long bytesTotal; - - List chunks = new ArrayList(); - - /** @return name of the information object. */ - public CachedPackKey getRowKey() { - return new CachedPackKey(name, version); - } - - /** @return number of objects stored in the cached pack. */ - public long getObjectsTotal() { - return objectsTotal; - } - - /** @return number of objects stored in delta format. */ - public long getObjectsDelta() { - return objectsDelta; - } - - /** @return number of bytes in the cached pack. */ - public long getTotalBytes() { - return bytesTotal; - } - - /** @return list of all chunks that make up this pack, in order. */ - public List getChunkKeys() { - return Collections.unmodifiableList(chunks); - } - - /** - * Convert this information into a byte array for storage. - * - * @return the data, encoded as a byte array. This does not include the key, - * callers must store that separately. - */ - public byte[] asBytes() { - return asBytes(this); - } - - @Override - public String toString() { - return getRowKey().toString(); - } -} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackKey.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackKey.java index 0fc14f9e2..274cc68d8 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackKey.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/CachedPackKey.java @@ -47,6 +47,7 @@ import java.text.MessageFormat; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; import org.eclipse.jgit.lib.ObjectId; /** Unique identifier of a {@link CachedPackInfo} in the DHT. */ @@ -61,18 +62,6 @@ public static CachedPackKey fromBytes(byte[] key) { return fromBytes(key, 0, key.length); } - /** - * @param d - * decoder to read key from current field from. - * @return the key - */ - public static CachedPackKey fromBytes(TinyProtobuf.Decoder d) { - int len = d.bytesLength(); - int ptr = d.bytesOffset(); - byte[] buf = d.bytesArray(); - return fromBytes(buf, ptr, len); - } - /** * @param key * @param ptr @@ -100,6 +89,16 @@ public static CachedPackKey fromString(String key) { return new CachedPackKey(name, vers); } + /** + * @param info + * @return the key + */ + public static CachedPackKey fromInfo(CachedPackInfo info) { + ObjectId name = ObjectId.fromString(info.getName()); + ObjectId vers = ObjectId.fromString(info.getVersion()); + return new CachedPackKey(name, vers); + } + private final ObjectId name; private final ObjectId version; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkFormatter.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkFormatter.java index 27c520bc9..011cfb06e 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkFormatter.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkFormatter.java @@ -52,10 +52,13 @@ import java.util.Map; import java.util.zip.Deflater; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; -import org.eclipse.jgit.storage.dht.ChunkMeta.BaseChunk; import org.eclipse.jgit.storage.dht.spi.Database; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.transport.PackedObjectInfo; @@ -75,8 +78,6 @@ class ChunkFormatter { private final byte[] varIntBuf; - private final ChunkInfo info; - private final int maxObjects; private Map baseChunks; @@ -95,25 +96,35 @@ class ChunkFormatter { private PackChunk.Members builder; + private GitStore.ChunkInfo.Source source; + + private boolean fragment; + + private int objectType; + + private int objectsTotal, objectsWhole, objectsRefDelta, objectsOfsDelta; + + private ChunkInfo chunkInfo; + ChunkFormatter(RepositoryKey repo, DhtInserterOptions options) { this.repo = repo; this.options = options; this.varIntBuf = new byte[32]; - this.info = new ChunkInfo(); this.chunkData = new byte[options.getChunkSize()]; this.maxObjects = options.getMaxObjectCount(); + this.objectType = -1; } - void setSource(ChunkInfo.Source src) { - info.source = src; + void setSource(GitStore.ChunkInfo.Source src) { + source = src; } void setObjectType(int type) { - info.objectType = type; + objectType = type; } void setFragment() { - info.fragment = true; + fragment = true; } ChunkKey getChunkKey() { @@ -121,7 +132,7 @@ ChunkKey getChunkKey() { } ChunkInfo getChunkInfo() { - return info; + return chunkInfo; } ChunkMeta getChunkMeta() { @@ -150,37 +161,58 @@ ChunkKey end(MessageDigest md) { ptr += 4; md.update(chunkData, 0, ptr); - info.chunkKey = ChunkKey.create(repo, ObjectId.fromRaw(md.digest())); - info.chunkSize = chunkData.length; + ChunkKey key = ChunkKey.create(repo, ObjectId.fromRaw(md.digest())); + + GitStore.ChunkInfo.Builder info = GitStore.ChunkInfo.newBuilder(); + info.setSource(source); + info.setObjectType(GitStore.ChunkInfo.ObjectType.valueOf(objectType)); + if (fragment) + info.setIsFragment(true); + info.setChunkSize(chunkData.length); + + GitStore.ChunkInfo.ObjectCounts.Builder cnts = info.getObjectCountsBuilder(); + cnts.setTotal(objectsTotal); + if (objectsWhole > 0) + cnts.setWhole(objectsWhole); + if (objectsRefDelta > 0) + cnts.setRefDelta(objectsRefDelta); + if (objectsOfsDelta > 0) + cnts.setOfsDelta(objectsOfsDelta); builder = new PackChunk.Members(); - builder.setChunkKey(info.chunkKey); + builder.setChunkKey(key); builder.setChunkData(chunkData); - ChunkMeta meta = new ChunkMeta(info.chunkKey); if (baseChunks != null) { - meta.baseChunks = new ArrayList(baseChunks.size()); + List list = new ArrayList(baseChunks.size()); for (BaseChunkInfo b : baseChunks.values()) { - if (0 < b.useCount) - meta.baseChunks.add(new BaseChunk(b.relativeStart, b.key)); + if (0 < b.useCount) { + BaseChunk.Builder c = BaseChunk.newBuilder(); + c.setRelativeStart(b.relativeStart); + c.setChunkKey(b.key.asString()); + list.add(c.build()); + } } - Collections.sort(meta.baseChunks, new Comparator() { + Collections.sort(list, new Comparator() { public int compare(BaseChunk a, BaseChunk b) { - return Long.signum(a.relativeStart - b.relativeStart); + return Long.signum(a.getRelativeStart() + - b.getRelativeStart()); } }); - } - if (!meta.isEmpty()) { + ChunkMeta.Builder b = ChunkMeta.newBuilder(); + b.addAllBaseChunk(list); + ChunkMeta meta = b.build(); builder.setMeta(meta); - info.metaSize = meta.asBytes().length; + info.setMetaSize(meta.getSerializedSize()); } if (objectList != null && !objectList.isEmpty()) { byte[] index = ChunkIndex.create(objectList); builder.setChunkIndex(index); - info.indexSize = index.length; + info.setIndexSize(index.length); } + chunkInfo = new ChunkInfo(key, info.build()); return getChunkKey(); } @@ -198,7 +230,7 @@ public int compare(BaseChunk a, BaseChunk b) { void safePut(Database db, WriteBuffer dbWriteBuffer) throws DhtException { WriteBuffer chunkBuf = db.newWriteBuffer(); - db.repository().put(repo, info, chunkBuf); + db.repository().put(repo, getChunkInfo(), chunkBuf); chunkBuf.flush(); db.chunk().put(builder, chunkBuf); @@ -208,7 +240,7 @@ void safePut(Database db, WriteBuffer dbWriteBuffer) throws DhtException { } void unsafePut(Database db, WriteBuffer dbWriteBuffer) throws DhtException { - db.repository().put(repo, info, dbWriteBuffer); + db.repository().put(repo, getChunkInfo(), dbWriteBuffer); db.chunk().put(builder, dbWriteBuffer); linkObjects(db, dbWriteBuffer); } @@ -225,11 +257,11 @@ private void linkObjects(Database db, WriteBuffer dbWriteBuffer) boolean whole(Deflater def, int type, byte[] data, int off, final int size, ObjectId objId) { - if (free() < 10 || maxObjects <= info.objectsTotal) + if (free() < 10 || maxObjects <= objectsTotal) return false; header(type, size); - info.objectsWhole++; + objectsWhole++; currentObjectType = type; int endOfHeader = ptr; @@ -257,20 +289,20 @@ boolean whole(Deflater def, int type, byte[] data, int off, final int size, final int packedSize = ptr - endOfHeader; objectList.add(new StoredObject(objId, type, mark, packedSize, size)); - if (info.objectType < 0) - info.objectType = type; - else if (info.objectType != type) - info.objectType = ChunkInfo.OBJ_MIXED; + if (objectType < 0) + objectType = type; + else if (objectType != type) + objectType = ChunkInfo.OBJ_MIXED; return true; } boolean whole(int type, long inflatedSize) { - if (free() < 10 || maxObjects <= info.objectsTotal) + if (free() < 10 || maxObjects <= objectsTotal) return false; header(type, inflatedSize); - info.objectsWhole++; + objectsWhole++; currentObjectType = type; return true; } @@ -278,11 +310,11 @@ boolean whole(int type, long inflatedSize) { boolean ofsDelta(long inflatedSize, long negativeOffset) { final int ofsPtr = encodeVarInt(negativeOffset); final int ofsLen = varIntBuf.length - ofsPtr; - if (free() < 10 + ofsLen || maxObjects <= info.objectsTotal) + if (free() < 10 + ofsLen || maxObjects <= objectsTotal) return false; header(Constants.OBJ_OFS_DELTA, inflatedSize); - info.objectsOfsDelta++; + objectsOfsDelta++; currentObjectType = Constants.OBJ_OFS_DELTA; currentObjectBase = null; @@ -294,11 +326,11 @@ boolean ofsDelta(long inflatedSize, long negativeOffset) { } boolean refDelta(long inflatedSize, AnyObjectId baseId) { - if (free() < 30 || maxObjects <= info.objectsTotal) + if (free() < 30 || maxObjects <= objectsTotal) return false; header(Constants.OBJ_REF_DELTA, inflatedSize); - info.objectsRefDelta++; + objectsRefDelta++; currentObjectType = Constants.OBJ_REF_DELTA; baseId.copyRawTo(chunkData, ptr); @@ -345,7 +377,7 @@ boolean isEmpty() { } int getObjectCount() { - return info.objectsTotal; + return objectsTotal; } int position() { @@ -374,32 +406,32 @@ void rollback() { } void adjustObjectCount(int delta, int type) { - info.objectsTotal += delta; + objectsTotal += delta; switch (type) { case Constants.OBJ_COMMIT: case Constants.OBJ_TREE: case Constants.OBJ_BLOB: case Constants.OBJ_TAG: - info.objectsWhole += delta; + objectsWhole += delta; break; case Constants.OBJ_OFS_DELTA: - info.objectsOfsDelta += delta; + objectsOfsDelta += delta; if (currentObjectBase != null && --currentObjectBase.useCount == 0) baseChunks.remove(currentObjectBase.key); currentObjectBase = null; break; case Constants.OBJ_REF_DELTA: - info.objectsRefDelta += delta; + objectsRefDelta += delta; break; } } private void header(int type, long inflatedSize) { mark = ptr; - info.objectsTotal++; + objectsTotal++; long nextLength = inflatedSize >>> 4; chunkData[ptr++] = (byte) ((nextLength > 0 ? 0x80 : 0x00) | (type << 4) | (inflatedSize & 0x0F)); @@ -454,8 +486,12 @@ private static class StoredObject extends PackedObjectInfo { } ObjectInfo link(ChunkKey key) { - final int ptr = (int) getOffset(); - return new ObjectInfo(key, -1, type, ptr, packed, inflated, null, false); + GitStore.ObjectInfo.Builder b = GitStore.ObjectInfo.newBuilder(); + b.setObjectType(ObjectType.valueOf(type)); + b.setOffset((int) getOffset()); + b.setPackedSize(packed); + b.setInflatedSize(inflated); + return new ObjectInfo(key, b.build()); } } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkInfo.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkInfo.java index 5282a1d4e..2c156c8a6 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkInfo.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkInfo.java @@ -43,150 +43,32 @@ package org.eclipse.jgit.storage.dht; -import org.eclipse.jgit.lib.Constants; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; /** * Summary information about a chunk owned by a repository. */ public class ChunkInfo { - /** Source the chunk (what code path created it). */ - public static enum Source implements TinyProtobuf.Enum { - /** Came in over the network from an external source */ - RECEIVE(1), - /** Created in this repository (e.g. a merge). */ - INSERT(2), - /** Generated during a repack of this repository. */ - REPACK(3); - - private final int value; - - Source(int val) { - this.value = val; - } - - public int value() { - return value; - } - } - /** Mixed objects are stored in the chunk (instead of single type). */ public static final int OBJ_MIXED = 0; + private final ChunkKey chunkKey; + + private final GitStore.ChunkInfo data; + /** - * Parse info from the storage system. + * Wrap a ChunkInfo message. * - * @param chunkKey - * the chunk the link points to. - * @param raw - * the raw encoding of the info. - * @return the info object. + * @param key + * associated chunk key. + * @param data + * data. */ - public static ChunkInfo fromBytes(ChunkKey chunkKey, byte[] raw) { - ChunkInfo info = new ChunkInfo(); - info.chunkKey = chunkKey; - - TinyProtobuf.Decoder d = TinyProtobuf.decode(raw); - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - info.source = d.intEnum(Source.values()); - continue; - case 2: - info.objectType = d.int32(); - continue; - case 3: - info.fragment = d.bool(); - continue; - case 4: - info.cachedPack = CachedPackKey.fromBytes(d); - continue; - - case 5: { - TinyProtobuf.Decoder m = d.message(); - for (;;) { - switch (m.next()) { - case 0: - continue PARSE; - case 1: - info.objectsTotal = m.int32(); - continue; - case 2: - info.objectsWhole = m.int32(); - continue; - case 3: - info.objectsOfsDelta = m.int32(); - continue; - case 4: - info.objectsRefDelta = m.int32(); - continue; - default: - m.skip(); - continue; - } - } - } - case 6: - info.chunkSize = d.int32(); - continue; - case 7: - info.indexSize = d.int32(); - continue; - case 8: - info.metaSize = d.int32(); - continue; - default: - d.skip(); - continue; - } - } - return info; + public ChunkInfo(ChunkKey key, GitStore.ChunkInfo data) { + this.chunkKey = key; + this.data = data; } - private static byte[] asBytes(ChunkInfo info) { - TinyProtobuf.Encoder objects = TinyProtobuf.encode(48); - objects.int32IfNotZero(1, info.objectsTotal); - objects.int32IfNotZero(2, info.objectsWhole); - objects.int32IfNotZero(3, info.objectsOfsDelta); - objects.int32IfNotZero(4, info.objectsRefDelta); - - TinyProtobuf.Encoder e = TinyProtobuf.encode(128); - e.intEnum(1, info.source); - e.int32IfNotNegative(2, info.objectType); - e.boolIfTrue(3, info.fragment); - e.string(4, info.cachedPack); - e.message(5, objects); - e.int32IfNotZero(6, info.chunkSize); - e.int32IfNotZero(7, info.indexSize); - e.int32IfNotZero(8, info.metaSize); - return e.asByteArray(); - } - - ChunkKey chunkKey; - - Source source; - - int objectType = -1; - - boolean fragment; - - CachedPackKey cachedPack; - - int objectsTotal; - - int objectsWhole; - - int objectsOfsDelta; - - int objectsRefDelta; - - int chunkSize; - - int indexSize; - - int metaSize; - /** @return the repository that contains the chunk. */ public RepositoryKey getRepositoryKey() { return chunkKey.getRepositoryKey(); @@ -197,69 +79,9 @@ public ChunkKey getChunkKey() { return chunkKey; } - /** @return source of this chunk. */ - public Source getSource() { - return source; - } - - /** @return type of object in the chunk, or {@link #OBJ_MIXED}. */ - public int getObjectType() { - return objectType; - } - - /** @return true if this chunk is part of a large fragmented object. */ - public boolean isFragment() { - return fragment; - } - - /** @return cached pack this is a member of, or null. */ - public CachedPackKey getCachedPack() { - return cachedPack; - } - - /** @return size of the chunk's compressed data, in bytes. */ - public int getChunkSizeInBytes() { - return chunkSize; - } - - /** @return size of the chunk's index data, in bytes. */ - public int getIndexSizeInBytes() { - return indexSize; - } - - /** @return size of the chunk's meta data, in bytes. */ - public int getMetaSizeInBytes() { - return metaSize; - } - - /** @return number of objects stored in the chunk. */ - public int getObjectsTotal() { - return objectsTotal; - } - - /** @return number of whole objects stored in the chunk. */ - public int getObjectsWhole() { - return objectsWhole; - } - - /** @return number of OFS_DELTA objects stored in the chunk. */ - public int getObjectsOffsetDelta() { - return objectsOfsDelta; - } - - /** @return number of REF_DELTA objects stored in the chunk. */ - public int getObjectsReferenceDelta() { - return objectsRefDelta; - } - - /** - * Convert this link into a byte array for storage. - * - * @return the link data, encoded as a byte array. This does not include the - * ChunkKey, callers must store that separately. - */ - public byte[] asBytes() { - return asBytes(this); + /** @return the underlying message containing all data. */ + public GitStore.ChunkInfo getData() { + return data; } @Override @@ -267,20 +89,8 @@ public String toString() { StringBuilder b = new StringBuilder(); b.append("ChunkInfo:"); b.append(chunkKey); - b.append(" ["); - if (getSource() != null) - b.append(" ").append(getSource()); - if (isFragment()) - b.append(" fragment"); - if (getObjectType() != 0) - b.append(" ").append(Constants.typeString(getObjectType())); - if (0 < getObjectsTotal()) - b.append(" objects=").append(getObjectsTotal()); - if (0 < getChunkSizeInBytes()) - b.append(" chunk=").append(getChunkSizeInBytes()).append("B"); - if (0 < getIndexSizeInBytes()) - b.append(" index=").append(getIndexSizeInBytes()).append("B"); - b.append(" ]"); + b.append("\n"); + b.append(data); return b.toString(); } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkKey.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkKey.java index e136df268..272b5ea17 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkKey.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkKey.java @@ -73,18 +73,6 @@ public static ChunkKey fromBytes(byte[] key) { return fromBytes(key, 0, key.length); } - /** - * @param d - * decoder to read key from current field from. - * @return the key - */ - public static ChunkKey fromBytes(TinyProtobuf.Decoder d) { - int len = d.bytesLength(); - int ptr = d.bytesOffset(); - byte[] buf = d.bytesArray(); - return fromBytes(buf, ptr, len); - } - /** * @param key * @param ptr diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMeta.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMeta.java deleted file mode 100644 index a02382b5c..000000000 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMeta.java +++ /dev/null @@ -1,391 +0,0 @@ -/* - * Copyright (C) 2011, Google Inc. - * and other copyright owners as documented in the project's IP log. - * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php - * - * 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 the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -package org.eclipse.jgit.storage.dht; - -import java.text.MessageFormat; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -/** Metadata stored inline with each PackChunk. */ -public class ChunkMeta { - /** - * Convert from byte array. - * - * @param key - * the chunk key this meta object sits in. - * @param raw - * the raw byte array. - * @return the chunk meta. - */ - public static ChunkMeta fromBytes(ChunkKey key, byte[] raw) { - return fromBytes(key, TinyProtobuf.decode(raw)); - } - - /** - * Convert from byte array. - * - * @param key - * the chunk key this meta object sits in. - * @param d - * the message decoder. - * @return the chunk meta. - */ - public static ChunkMeta fromBytes(ChunkKey key, TinyProtobuf.Decoder d) { - List baseChunk = null; - List fragment = null; - PrefetchHint commit = null; - PrefetchHint tree = null; - - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - if (baseChunk == null) - baseChunk = new ArrayList(4); - baseChunk.add(BaseChunk.fromBytes(d.message())); - continue; - case 2: - if (fragment == null) - fragment = new ArrayList(4); - fragment.add(ChunkKey.fromBytes(d)); - continue; - case 51: - commit = PrefetchHint.fromBytes(d.message()); - continue; - case 52: - tree = PrefetchHint.fromBytes(d.message()); - continue; - default: - d.skip(); - continue; - } - } - - return new ChunkMeta(key, baseChunk, fragment, commit, tree); - } - - private final ChunkKey chunkKey; - - List baseChunks; - - List fragments; - - PrefetchHint commitPrefetch; - - PrefetchHint treePrefetch; - - ChunkMeta(ChunkKey key) { - this(key, null, null, null, null); - } - - ChunkMeta(ChunkKey chunkKey, List baseChunk, - List fragment, PrefetchHint commit, PrefetchHint tree) { - this.chunkKey = chunkKey; - this.baseChunks = baseChunk; - this.fragments = fragment; - this.commitPrefetch = commit; - this.treePrefetch = tree; - } - - /** @return key of the chunk this meta information is for. */ - public ChunkKey getChunkKey() { - return chunkKey; - } - - BaseChunk getBaseChunk(long position) throws DhtException { - // Chunks are sorted by ascending relative_start order. - // Thus for a pack sequence of: A B C, we have: - // - // -- C relative_start = 10,000 - // -- B relative_start = 20,000 - // -- A relative_start = 30,000 - // - // Indicating that chunk C starts 10,000 bytes before us, - // chunk B starts 20,000 bytes before us (and 10,000 before C), - // chunk A starts 30,000 bytes before us (and 10,000 before B), - // - // If position falls within: - // - // -- C (10k), then position is between 0..10,000 - // -- B (20k), then position is between 10,000 .. 20,000 - // -- A (30k), then position is between 20,000 .. 30,000 - - int high = baseChunks.size(); - int low = 0; - while (low < high) { - final int mid = (low + high) >>> 1; - final BaseChunk base = baseChunks.get(mid); - - if (position > base.relativeStart) { - low = mid + 1; - - } else if (mid == 0 || position == base.relativeStart) { - return base; - - } else if (baseChunks.get(mid - 1).relativeStart < position) { - return base; - - } else { - high = mid; - } - } - - throw new DhtException(MessageFormat.format( - DhtText.get().missingLongOffsetBase, chunkKey, - Long.valueOf(position))); - } - - /** @return number of fragment chunks that make up the object. */ - public int getFragmentCount() { - return fragments != null ? fragments.size() : 0; - } - - /** - * Get the nth fragment key. - * - * @param nth - * @return the key. - */ - public ChunkKey getFragmentKey(int nth) { - return fragments.get(nth); - } - - /** - * Find the key of the fragment that occurs after this chunk. - * - * @param currentKey - * the current chunk key. - * @return next chunk after this; null if there isn't one. - */ - public ChunkKey getNextFragment(ChunkKey currentKey) { - for (int i = 0; i < fragments.size() - 1; i++) { - if (fragments.get(i).equals(currentKey)) - return fragments.get(i + 1); - } - return null; - } - - /** @return chunks to visit. */ - public PrefetchHint getCommitPrefetch() { - return commitPrefetch; - } - - /** @return chunks to visit. */ - public PrefetchHint getTreePrefetch() { - return treePrefetch; - } - - /** @return true if there is no data in this object worth storing. */ - boolean isEmpty() { - if (baseChunks != null && !baseChunks.isEmpty()) - return false; - if (fragments != null && !fragments.isEmpty()) - return false; - if (commitPrefetch != null && !commitPrefetch.isEmpty()) - return false; - if (treePrefetch != null && !treePrefetch.isEmpty()) - return false; - return true; - } - - /** @return format as byte array for storage. */ - public byte[] asBytes() { - TinyProtobuf.Encoder e = TinyProtobuf.encode(256); - - if (baseChunks != null) { - for (BaseChunk base : baseChunks) - e.message(1, base.asBytes()); - } - - if (fragments != null) { - for (ChunkKey key : fragments) - e.bytes(2, key.asBytes()); - } - - if (commitPrefetch != null) - e.message(51, commitPrefetch.asBytes()); - if (treePrefetch != null) - e.message(52, treePrefetch.asBytes()); - - return e.asByteArray(); - } - - /** Describes other chunks that contain the bases for this chunk's deltas. */ - public static class BaseChunk { - final long relativeStart; - - private final ChunkKey chunk; - - BaseChunk(long relativeStart, ChunkKey chunk) { - this.relativeStart = relativeStart; - this.chunk = chunk; - } - - /** @return bytes backward from current chunk to start of base chunk. */ - public long getRelativeStart() { - return relativeStart; - } - - /** @return unique key of this chunk. */ - public ChunkKey getChunkKey() { - return chunk; - } - - TinyProtobuf.Encoder asBytes() { - int max = 11 + 2 + ChunkKey.KEYLEN; - TinyProtobuf.Encoder e = TinyProtobuf.encode(max); - e.int64(1, relativeStart); - e.bytes(2, chunk.asBytes()); - return e; - } - - static BaseChunk fromBytes(TinyProtobuf.Decoder d) { - long relativeStart = -1; - ChunkKey chunk = null; - - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - relativeStart = d.int64(); - continue; - case 2: - chunk = ChunkKey.fromBytes(d); - continue; - default: - d.skip(); - continue; - } - } - - return new BaseChunk(relativeStart, chunk); - } - } - - /** Describes the prefetching for a particular object type. */ - public static class PrefetchHint { - private final List edge; - - private final List sequential; - - PrefetchHint(List edge, List sequential) { - if (edge == null) - edge = Collections.emptyList(); - else - edge = Collections.unmodifiableList(edge); - - if (sequential == null) - sequential = Collections.emptyList(); - else - sequential = Collections.unmodifiableList(sequential); - - this.edge = edge; - this.sequential = sequential; - } - - /** @return chunks on the edge of this chunk. */ - public List getEdge() { - return edge; - } - - /** @return chunks according to sequential ordering. */ - public List getSequential() { - return sequential; - } - - boolean isEmpty() { - return edge.isEmpty() && sequential.isEmpty(); - } - - TinyProtobuf.Encoder asBytes() { - int max = 0; - - max += (2 + ChunkKey.KEYLEN) * edge.size(); - max += (2 + ChunkKey.KEYLEN) * sequential.size(); - - TinyProtobuf.Encoder e = TinyProtobuf.encode(max); - for (ChunkKey key : edge) - e.bytes(1, key.asBytes()); - for (ChunkKey key : sequential) - e.bytes(2, key.asBytes()); - return e; - } - - static PrefetchHint fromBytes(TinyProtobuf.Decoder d) { - ArrayList edge = null; - ArrayList sequential = null; - - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - if (edge == null) - edge = new ArrayList(16); - edge.add(ChunkKey.fromBytes(d)); - continue; - case 2: - if (sequential == null) - sequential = new ArrayList(16); - sequential.add(ChunkKey.fromBytes(d)); - continue; - default: - d.skip(); - continue; - } - } - - if (edge != null) - edge.trimToSize(); - - if (sequential != null) - sequential.trimToSize(); - - return new PrefetchHint(edge, sequential); - } - } -} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMetaUtil.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMetaUtil.java new file mode 100644 index 000000000..7bc643917 --- /dev/null +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ChunkMetaUtil.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2011, Google Inc. + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * 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 the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.eclipse.jgit.storage.dht; + +import java.text.MessageFormat; +import java.util.List; + +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk; + +class ChunkMetaUtil { + static BaseChunk getBaseChunk(ChunkKey chunkKey, ChunkMeta meta, + long position) throws DhtException { + // Chunks are sorted by ascending relative_start order. + // Thus for a pack sequence of: A B C, we have: + // + // -- C relative_start = 10,000 + // -- B relative_start = 20,000 + // -- A relative_start = 30,000 + // + // Indicating that chunk C starts 10,000 bytes before us, + // chunk B starts 20,000 bytes before us (and 10,000 before C), + // chunk A starts 30,000 bytes before us (and 10,000 before B), + // + // If position falls within: + // + // -- C (10k), then position is between 0..10,000 + // -- B (20k), then position is between 10,000 .. 20,000 + // -- A (30k), then position is between 20,000 .. 30,000 + + List baseChunks = meta.getBaseChunkList(); + int high = baseChunks.size(); + int low = 0; + while (low < high) { + final int mid = (low + high) >>> 1; + final BaseChunk base = baseChunks.get(mid); + + if (position > base.getRelativeStart()) { + low = mid + 1; + + } else if (mid == 0 || position == base.getRelativeStart()) { + return base; + + } else if (baseChunks.get(mid - 1).getRelativeStart() < position) { + return base; + + } else { + high = mid; + } + } + + throw new DhtException(MessageFormat.format( + DhtText.get().missingLongOffsetBase, chunkKey, + Long.valueOf(position))); + } + + static ChunkKey getNextFragment(ChunkMeta meta, ChunkKey chunkKey) { + int cnt = meta.getFragmentCount(); + for (int i = 0; i < cnt - 1; i++) { + ChunkKey key = ChunkKey.fromString(meta.getFragment(i)); + if (chunkKey.equals(key)) + return ChunkKey.fromString(meta.getFragment(i + 1)); + } + return null; + } + + private ChunkMetaUtil() { + // Static utilities only, do not create instances. + } +} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtCachedPack.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtCachedPack.java index 13af792e0..39a76463f 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtCachedPack.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtCachedPack.java @@ -45,12 +45,16 @@ import java.io.IOException; import java.text.MessageFormat; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.ChunkList; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.storage.pack.CachedPack; import org.eclipse.jgit.storage.pack.ObjectToPack; @@ -61,7 +65,11 @@ public class DhtCachedPack extends CachedPack { private final CachedPackInfo info; - private Set chunkKeySet; + private Set tips; + + private Set keySet; + + private ChunkKey[] keyList; DhtCachedPack(CachedPackInfo info) { this.info = info; @@ -69,7 +77,13 @@ public class DhtCachedPack extends CachedPack { @Override public Set getTips() { - return Collections.unmodifiableSet(info.tips); + if (tips == null) { + tips = new HashSet(); + for (String idString : info.getTipList().getObjectNameList()) + tips.add(ObjectId.fromString(idString)); + tips = Collections.unmodifiableSet(tips); + } + return tips; } @Override @@ -90,23 +104,37 @@ public CachedPackInfo getCachedPackInfo() { @Override public boolean hasObject(ObjectToPack obj, StoredObjectRepresentation rep) { DhtObjectRepresentation objrep = (DhtObjectRepresentation) rep; - if (chunkKeySet == null) - chunkKeySet = new HashSet(info.chunks); - return chunkKeySet.contains(objrep.getChunkKey()); + if (keySet == null) + init(); + return keySet.contains(objrep.getChunkKey()); + } + + private void init() { + ChunkList chunkList = info.getChunkList(); + int cnt = chunkList.getChunkKeyCount(); + keySet = new HashSet(); + keyList = new ChunkKey[cnt]; + for (int i = 0; i < cnt; i++) { + ChunkKey key = ChunkKey.fromString(chunkList.getChunkKey(i)); + keySet.add(key); + keyList[i] = key; + } } void copyAsIs(PackOutputStream out, boolean validate, DhtReader ctx) throws IOException { + if (keyList == null) + init(); Prefetcher p = new Prefetcher(ctx, 0); - p.push(info.chunks); - copyPack(out, ctx, p, validate); + p.push(Arrays.asList(keyList)); + copyPack(out, p, validate); } - private void copyPack(PackOutputStream out, DhtReader ctx, - Prefetcher prefetcher, boolean validate) throws DhtException, - DhtMissingChunkException, IOException { - Map startsAt = new HashMap(); - for (ChunkKey key : info.chunks) { + private void copyPack(PackOutputStream out, Prefetcher prefetcher, + boolean validate) throws DhtException, DhtMissingChunkException, + IOException { + Map startsAt = new HashMap(); + for (ChunkKey key : keyList) { PackChunk chunk = prefetcher.get(key); // The prefetcher should always produce the chunk for us, if not @@ -122,29 +150,34 @@ private void copyPack(PackOutputStream out, DhtReader ctx, // incorrectly created and would confuse the client. // long position = out.length(); - if (chunk.getMeta() != null && chunk.getMeta().baseChunks != null) { - for (ChunkMeta.BaseChunk base : chunk.getMeta().baseChunks) { + ChunkMeta meta = chunk.getMeta(); + if (meta != null && meta.getBaseChunkCount() != 0) { + for (ChunkMeta.BaseChunk base : meta.getBaseChunkList()) { Long act = startsAt.get(base.getChunkKey()); long exp = position - base.getRelativeStart(); if (act == null) { throw new DhtException(MessageFormat.format(DhtText - .get().wrongChunkPositionInCachedPack, info - .getRowKey(), base.getChunkKey(), - "[not written]", key, exp)); + .get().wrongChunkPositionInCachedPack, + rowKey(), base.getChunkKey(), + "[not written]", key, Long.valueOf(exp))); } if (act.longValue() != exp) { throw new DhtException(MessageFormat.format(DhtText - .get().wrongChunkPositionInCachedPack, info - .getRowKey(), base.getChunkKey(), // - act, key, exp)); + .get().wrongChunkPositionInCachedPack, + rowKey(), base.getChunkKey(), + act, key, Long.valueOf(exp))); } } } - startsAt.put(key, Long.valueOf(position)); + startsAt.put(key.asString(), Long.valueOf(position)); chunk.copyEntireChunkAsIs(out, null, validate); } } + + private String rowKey() { + return info.getName() + "." + info.getVersion(); + } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserter.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserter.java index 997f4b4d2..4ae4cf58e 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserter.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserter.java @@ -53,6 +53,9 @@ import java.util.LinkedList; import java.util.zip.Deflater; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ObjectInfo.ObjectType; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectInserter; @@ -174,8 +177,13 @@ private ObjectId insertStream(final int type, final long inflatedSize, ChunkKey key = chunk.end(chunkDigest); chunk.setChunkIndex(Collections.singletonList(oe)); chunk.safePut(db, dbBuffer()); - ObjectInfo info = new ObjectInfo(key, -1, type, position, - packedSize, inflatedSize, null, false); + + GitStore.ObjectInfo.Builder b = GitStore.ObjectInfo.newBuilder(); + b.setObjectType(ObjectType.valueOf(type)); + b.setOffset(position); + b.setPackedSize(packedSize); + b.setInflatedSize(inflatedSize); + ObjectInfo info = new ObjectInfo(key, b.build()); ObjectIndexKey objKey = ObjectIndexKey.create(repo, objId); db.objectIndex().add(objKey, info, dbBuffer()); return objId; @@ -188,12 +196,15 @@ private ObjectId insertStream(final int type, final long inflatedSize, chunk = null; ChunkKey firstChunkKey = fragmentList.get(0); + + ChunkMeta.Builder metaBuilder = ChunkMeta.newBuilder(); + for (ChunkKey k : fragmentList) + metaBuilder.addFragment(k.asString()); + ChunkMeta meta = metaBuilder.build(); + for (ChunkKey key : fragmentList) { PackChunk.Members builder = new PackChunk.Members(); builder.setChunkKey(key); - - ChunkMeta meta = new ChunkMeta(key); - meta.fragments = fragmentList; builder.setMeta(meta); if (firstChunkKey.equals(key)) @@ -202,8 +213,12 @@ private ObjectId insertStream(final int type, final long inflatedSize, db.chunk().put(builder, dbBuffer()); } - ObjectInfo info = new ObjectInfo(firstChunkKey, -1, type, position, - packedSize, inflatedSize, null, true); + GitStore.ObjectInfo.Builder b = GitStore.ObjectInfo.newBuilder(); + b.setObjectType(ObjectType.valueOf(type)); + b.setOffset(position); + b.setPackedSize(packedSize); + b.setInflatedSize(inflatedSize); + ObjectInfo info = new ObjectInfo(firstChunkKey, b.build()); ObjectIndexKey objKey = ObjectIndexKey.create(repo, objId); db.objectIndex().add(objKey, info, dbBuffer()); @@ -234,12 +249,13 @@ public ObjectId insert(int type, byte[] data, int off, int len) // TODO Allow more than one chunk pending at a time, this would // permit batching puts of the ChunkInfo records. - activeChunk.end(digest()); - activeChunk.safePut(db, dbBuffer()); - activeChunk = newChunk(); - - if (activeChunk.whole(deflater(), type, data, off, len, objId)) - return objId; + if (!activeChunk.isEmpty()) { + activeChunk.end(digest()); + activeChunk.safePut(db, dbBuffer()); + activeChunk = newChunk(); + if (activeChunk.whole(deflater(), type, data, off, len, objId)) + return objId; + } return insertStream(type, len, asStream(data, off, len)); } @@ -295,7 +311,7 @@ private ChunkFormatter newChunk() { ChunkFormatter fmt; fmt = new ChunkFormatter(repo, options); - fmt.setSource(ChunkInfo.Source.INSERT); + fmt.setSource(GitStore.ChunkInfo.Source.INSERT); return fmt; } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserterOptions.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserterOptions.java index b1b1b5c5f..56b323bd2 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserterOptions.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtInserterOptions.java @@ -49,6 +49,7 @@ import java.security.SecureRandom; import java.util.zip.Deflater; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.Config; import org.eclipse.jgit.lib.CoreConfig; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtObjectRepresentation.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtObjectRepresentation.java index a5499254e..f6d55c1a4 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtObjectRepresentation.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtObjectRepresentation.java @@ -76,7 +76,7 @@ public ObjectId getDeltaBase() { @Override public int getFormat() { - if (info.getDeltaBase() != null) + if (info.isDelta()) return PACK_DELTA; return PACK_WHOLE; } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtPackParser.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtPackParser.java index 86078335d..fdc143621 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtPackParser.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtPackParser.java @@ -67,10 +67,13 @@ import java.util.List; import java.util.ListIterator; import java.util.Map; -import java.util.Set; import java.util.Map.Entry; +import java.util.Set; import java.util.concurrent.TimeoutException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.MutableObjectId; @@ -86,6 +89,8 @@ import org.eclipse.jgit.treewalk.CanonicalTreeParser; import org.eclipse.jgit.util.LongList; +import com.google.protobuf.ByteString; + /** Parses the pack stream into chunks, and indexes the chunks for lookup. */ public class DhtPackParser extends PackParser { private final DhtObjDatabase objdb; @@ -112,7 +117,7 @@ public class DhtPackParser extends PackParser { private Edges[] openEdges; /** Prior chunks that were written, keyed by object type code. */ - private List[] infoByOrder; + private List[] chunkByOrder; /** Information on chunks already written out. */ private Map infoByKey; @@ -199,7 +204,7 @@ public class DhtPackParser extends PackParser { dbWriteBuffer = db.newWriteBuffer(); openChunks = new ChunkFormatter[5]; openEdges = new Edges[5]; - infoByOrder = newListArray(5); + chunkByOrder = newListArray(5); infoByKey = new HashMap(); dirtyMeta = new HashMap(); chunkMeta = new HashMap(); @@ -306,7 +311,7 @@ public PackLock parse(ProgressMonitor receiving, ProgressMonitor resolving) if (!success) rollback(); - infoByOrder = null; + chunkByOrder = null; objectListByName = null; objectListByChunk = null; linkIterators = null; @@ -332,54 +337,74 @@ public int compare(PackedObjectInfo o1, PackedObjectInfo o2) { } private void putCachedPack() throws DhtException { - CachedPackInfo info = new CachedPackInfo(); + CachedPackInfo.Builder info = CachedPackInfo.newBuilder(); for (DhtInfo obj : objectMap) { if (!obj.isInPack()) return; if (!obj.isReferenced()) - info.tips.add(obj.copy()); + info.getTipListBuilder().addObjectName(obj.name()); } MessageDigest version = Constants.newMessageDigest(); - addChunkList(info, version, infoByOrder[OBJ_TAG]); - addChunkList(info, version, infoByOrder[OBJ_COMMIT]); - addChunkList(info, version, infoByOrder[OBJ_TREE]); - addChunkList(info, version, infoByOrder[OBJ_BLOB]); + addChunkList(info, version, chunkByOrder[OBJ_TAG]); + addChunkList(info, version, chunkByOrder[OBJ_COMMIT]); + addChunkList(info, version, chunkByOrder[OBJ_TREE]); + addChunkList(info, version, chunkByOrder[OBJ_BLOB]); - info.name = computePackName(); - info.version = ObjectId.fromRaw(version.digest()); + info.setName(computePackName().name()); + info.setVersion(ObjectId.fromRaw(version.digest()).name()); - cachedPackKey = info.getRowKey(); - for (List list : infoByOrder) { + cachedPackKey = CachedPackKey.fromInfo(info.build()); + for (List list : chunkByOrder) { if (list == null) continue; - for (ChunkInfo c : list) { - c.cachedPack = cachedPackKey; - if (c.isFragment()) - db.repository().put(repo, info, dbWriteBuffer); + for (ChunkKey key : list) { + ChunkInfo oldInfo = infoByKey.get(key); + GitStore.ChunkInfo.Builder b = + GitStore.ChunkInfo.newBuilder(oldInfo.getData()); + b.setCachedPackKey(cachedPackKey.asString()); + ChunkInfo newInfo = new ChunkInfo(key, b.build()); + infoByKey.put(key, newInfo); + + // A fragment was already put, and has to be re-put. + // Non-fragments will put later and do not put now. + if (newInfo.getData().getIsFragment()) + db.repository().put(repo, newInfo, dbWriteBuffer); } } - db.repository().put(repo, info, dbWriteBuffer); + db.repository().put(repo, info.build(), dbWriteBuffer); } - private void addChunkList(CachedPackInfo info, MessageDigest version, - List list) { + private void addChunkList(CachedPackInfo.Builder info, + MessageDigest version, List list) { if (list == null) return; + + long bytesTotal = info.getBytesTotal(); + long objectsTotal = info.getObjectsTotal(); + long objectsDelta = info.getObjectsDelta(); + byte[] buf = new byte[Constants.OBJECT_ID_LENGTH]; - for (ChunkInfo c : list) { - int len = c.chunkSize - ChunkFormatter.TRAILER_SIZE; - info.bytesTotal += len; - info.objectsTotal += c.objectsTotal; - info.objectsDelta += c.objectsOfsDelta; - info.objectsDelta += c.objectsRefDelta; - info.chunks.add(c.getChunkKey()); - c.getChunkKey().getChunkHash().copyRawTo(buf, 0); + for (ChunkKey key : list) { + ChunkInfo chunkInfo = infoByKey.get(key); + GitStore.ChunkInfo c = chunkInfo.getData(); + int len = c.getChunkSize() - ChunkFormatter.TRAILER_SIZE; + bytesTotal += len; + objectsTotal += c.getObjectCounts().getTotal(); + objectsDelta += c.getObjectCounts().getOfsDelta(); + objectsDelta += c.getObjectCounts().getRefDelta(); + info.getChunkListBuilder().addChunkKey( + chunkInfo.getChunkKey().asString()); + chunkInfo.getChunkKey().getChunkHash().copyRawTo(buf, 0); version.update(buf); } + + info.setBytesTotal(bytesTotal); + info.setObjectsTotal(objectsTotal); + info.setObjectsDelta(objectsDelta); } private ObjectId computePackName() { @@ -420,10 +445,10 @@ private void rollback() throws DhtException { } } - deleteChunks(infoByOrder[OBJ_COMMIT]); - deleteChunks(infoByOrder[OBJ_TREE]); - deleteChunks(infoByOrder[OBJ_BLOB]); - deleteChunks(infoByOrder[OBJ_TAG]); + deleteChunks(chunkByOrder[OBJ_COMMIT]); + deleteChunks(chunkByOrder[OBJ_TREE]); + deleteChunks(chunkByOrder[OBJ_BLOB]); + deleteChunks(chunkByOrder[OBJ_TAG]); dbWriteBuffer.flush(); } catch (Throwable err) { @@ -431,10 +456,9 @@ private void rollback() throws DhtException { } } - private void deleteChunks(List list) throws DhtException { + private void deleteChunks(List list) throws DhtException { if (list != null) { - for (ChunkInfo info : list) { - ChunkKey key = info.getChunkKey(); + for (ChunkKey key : list) { db.chunk().remove(key, dbWriteBuffer); db.repository().remove(repo, key, dbWriteBuffer); } @@ -605,60 +629,77 @@ private void putChunkIndexes() throws DhtException { private void putChunkIndex(List objectList, ChunkKey key, int type) throws DhtException { - ChunkInfo info = infoByKey.get(key); - info.objectsTotal = objectList.size(); - info.objectType = type; + ChunkInfo oldInfo = infoByKey.get(key); + GitStore.ChunkInfo.Builder info + = GitStore.ChunkInfo.newBuilder(oldInfo.getData()); PackChunk.Members builder = new PackChunk.Members(); builder.setChunkKey(key); byte[] index = ChunkIndex.create(objectList); - info.indexSize = index.length; + info.setIndexSize(index.length); builder.setChunkIndex(index); ChunkMeta meta = dirtyMeta.remove(key); if (meta == null) meta = chunkMeta.get(key); - if (meta == null) - meta = new ChunkMeta(key); switch (type) { case OBJ_COMMIT: { Edges edges = chunkEdges.get(key); - if (edges != null) { - List e = edges.commitEdges; - List s = sequentialHint(key, OBJ_COMMIT); - meta.commitPrefetch = new ChunkMeta.PrefetchHint(e, s); + List e = edges != null ? edges.commitEdges : null; + List s = sequentialHint(key, OBJ_COMMIT); + if (e == null) + e = Collections.emptyList(); + if (s == null) + s = Collections.emptyList(); + if (!e.isEmpty() || !s.isEmpty()) { + ChunkMeta.Builder m = edit(meta); + ChunkMeta.PrefetchHint.Builder h = m.getCommitPrefetchBuilder(); + for (ChunkKey k : e) + h.addEdge(k.asString()); + for (ChunkKey k : s) + h.addSequential(k.asString()); + meta = m.build(); } break; } case OBJ_TREE: { List s = sequentialHint(key, OBJ_TREE); - meta.treePrefetch = new ChunkMeta.PrefetchHint(null, s); + if (s == null) + s = Collections.emptyList(); + if (!s.isEmpty()) { + ChunkMeta.Builder m = edit(meta); + ChunkMeta.PrefetchHint.Builder h = m.getTreePrefetchBuilder(); + for (ChunkKey k : s) + h.addSequential(k.asString()); + meta = m.build(); + } break; } } - if (meta.isEmpty()) { - info.metaSize = 0; - } else { - info.metaSize = meta.asBytes().length; + if (meta != null) { + info.setMetaSize(meta.getSerializedSize()); builder.setMeta(meta); } - db.repository().put(repo, info, dbWriteBuffer); + ChunkInfo newInfo = new ChunkInfo(key, info.build()); + infoByKey.put(key, newInfo); + db.repository().put(repo, newInfo, dbWriteBuffer); db.chunk().put(builder, dbWriteBuffer); } + private static ChunkMeta.Builder edit(ChunkMeta meta) { + if (meta != null) + return ChunkMeta.newBuilder(meta); + return ChunkMeta.newBuilder(); + } + private List sequentialHint(ChunkKey key, int typeCode) { - List infoList = infoByOrder[typeCode]; - if (infoList == null) + List all = chunkByOrder[typeCode]; + if (all == null) return null; - - List all = new ArrayList(infoList.size()); - for (ChunkInfo info : infoList) - all.add(info.getChunkKey()); - int idx = all.indexOf(key); if (0 <= idx) { int max = options.getPrefetchDepth(); @@ -669,10 +710,10 @@ private List sequentialHint(ChunkKey key, int typeCode) { } private void putDirtyMeta() throws DhtException { - for (ChunkMeta meta : dirtyMeta.values()) { + for (Map.Entry meta : dirtyMeta.entrySet()) { PackChunk.Members builder = new PackChunk.Members(); - builder.setChunkKey(meta.getChunkKey()); - builder.setMeta(meta); + builder.setChunkKey(meta.getKey()); + builder.setMeta(meta.getValue()); db.chunk().put(builder, dbWriteBuffer); } } @@ -892,15 +933,15 @@ protected void onObjectData(Source src, byte[] raw, int pos, int len) private boolean longOfsDelta(ChunkFormatter w, long infSize, long basePtr) { final int type = typeOf(basePtr); - final List infoList = infoByOrder[type]; + final List infoList = chunkByOrder[type]; final int baseIdx = chunkIdx(basePtr); - final ChunkInfo baseInfo = infoList.get(baseIdx); + final ChunkInfo baseInfo = infoByKey.get(infoList.get(baseIdx)); // Go backwards to the start of the base's chunk. long relativeChunkStart = 0; for (int i = infoList.size() - 1; baseIdx <= i; i--) { - ChunkInfo info = infoList.get(i); - int packSize = info.chunkSize - ChunkFormatter.TRAILER_SIZE; + GitStore.ChunkInfo info = infoByKey.get(infoList.get(i)).getData(); + int packSize = info.getChunkSize() - ChunkFormatter.TRAILER_SIZE; relativeChunkStart += packSize; } @@ -940,14 +981,24 @@ private void endFragmentedObject() throws DhtException { if (lastKey != null) currFragments.add(lastKey); + ChunkMeta.Builder protoBuilder = ChunkMeta.newBuilder(); + for (ChunkKey key : currFragments) + protoBuilder.addFragment(key.asString()); + ChunkMeta protoMeta = protoBuilder.build(); + for (ChunkKey key : currFragments) { - ChunkMeta meta = chunkMeta.get(key); - if (meta == null) { - meta = new ChunkMeta(key); + ChunkMeta oldMeta = chunkMeta.get(key); + if (oldMeta != null) { + ChunkMeta.Builder newMeta = ChunkMeta.newBuilder(oldMeta); + newMeta.clearFragment(); + newMeta.mergeFrom(protoMeta); + ChunkMeta meta = newMeta.build(); + dirtyMeta.put(key, meta); chunkMeta.put(key, meta); + } else { + dirtyMeta.put(key, protoMeta); + chunkMeta.put(key, protoMeta); } - meta.fragments = currFragments; - dirtyMeta.put(key, meta); } currFragments = null; } @@ -1093,7 +1144,7 @@ protected int readDatabase(byte[] dst, int pos, int cnt) throws IOException { if (meta == null) return 0; - ChunkKey next = meta.getNextFragment(dbChunk.getChunkKey()); + ChunkKey next = ChunkMetaUtil.getNextFragment(meta, dbChunk.getChunkKey()); if (next == null) return 0; @@ -1200,7 +1251,7 @@ private ChunkFormatter openChunk(int typeCode) throws DhtException { ChunkFormatter w = openChunks[typeCode]; if (w == null) { w = new ChunkFormatter(repo, options); - w.setSource(ChunkInfo.Source.RECEIVE); + w.setSource(GitStore.ChunkInfo.Source.RECEIVE); w.setObjectType(typeCode); openChunks[typeCode] = w; } @@ -1221,9 +1272,9 @@ private ChunkKey endChunk(int typeCode) throws DhtException { ChunkKey key = w.end(chunkKeyDigest); ChunkInfo info = w.getChunkInfo(); - if (infoByOrder[typeCode] == null) - infoByOrder[typeCode] = new ArrayList(); - infoByOrder[typeCode].add(info); + if (chunkByOrder[typeCode] == null) + chunkByOrder[typeCode] = new ArrayList(); + chunkByOrder[typeCode].add(key); infoByKey.put(key, info); if (w.getChunkMeta() != null) @@ -1260,7 +1311,7 @@ else if (streamPosition == pos) } private long makeObjectPointer(ChunkFormatter w, int typeCode) { - List list = infoByOrder[typeCode]; + List list = chunkByOrder[typeCode]; int idx = list == null ? 0 : list.size(); int ptr = w.position(); return (((long) typeCode) << 61) | (((long) idx) << 32) | ptr; @@ -1279,14 +1330,14 @@ private static int offsetOf(long objectPtr) { } private boolean isInCurrentChunk(long objectPtr) { - List list = infoByOrder[typeOf(objectPtr)]; + List list = chunkByOrder[typeOf(objectPtr)]; if (list == null) return chunkIdx(objectPtr) == 0; return chunkIdx(objectPtr) == list.size(); } private ChunkKey chunkOf(long objectPtr) throws DhtException { - List list = infoByOrder[typeOf(objectPtr)]; + List list = chunkByOrder[typeOf(objectPtr)]; int idx = chunkIdx(objectPtr); if (list == null || list.size() <= idx) { throw new DhtException(MessageFormat.format( @@ -1295,7 +1346,7 @@ private ChunkKey chunkOf(long objectPtr) throws DhtException { Integer.valueOf(idx), // Integer.valueOf(offsetOf(objectPtr)))); } - return list.get(idx).getChunkKey(); + return list.get(idx); } private static DhtException panicCannotInsert() { @@ -1349,8 +1400,19 @@ void setType(int type) { } ObjectInfo info(ChunkKey chunkKey) { - return new ObjectInfo(chunkKey, -1, getType(), offsetOf(chunkPtr), - packedSize, inflatedSize, base, isFragmented()); + GitStore.ObjectInfo.Builder b = GitStore.ObjectInfo.newBuilder(); + b.setObjectType(GitStore.ObjectInfo.ObjectType.valueOf(getType())); + b.setOffset(offsetOf(chunkPtr)); + b.setPackedSize(packedSize); + b.setInflatedSize(inflatedSize); + if (base != null) { + byte[] t = new byte[Constants.OBJECT_ID_LENGTH]; + base.copyRawTo(t, 0); + b.setDeltaBase(ByteString.copyFrom(t)); + } + if (isFragmented()) + b.setIsFragmented(true); + return new ObjectInfo(chunkKey, b.build()); } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtReader.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtReader.java index 05438ab8d..f9288b9e2 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtReader.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtReader.java @@ -63,6 +63,7 @@ import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.StoredObjectRepresentationNotAvailableException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; import org.eclipse.jgit.lib.AbbreviatedObjectId; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.AsyncObjectLoaderQueue; @@ -76,7 +77,6 @@ import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevObject; import org.eclipse.jgit.revwalk.RevWalk; -import org.eclipse.jgit.storage.dht.RefData.IdWithChunk; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.Database; import org.eclipse.jgit.storage.dht.spi.ObjectIndexTable; @@ -186,7 +186,7 @@ public ObjectReader newReader() { @Override public boolean has(AnyObjectId objId, int typeHint) throws IOException { - if (objId instanceof RefData.IdWithChunk) + if (objId instanceof RefDataUtil.IdWithChunk) return true; if (recentChunks.has(repo, objId)) @@ -283,8 +283,8 @@ ChunkAndOffset getChunk(AnyObjectId objId, int typeHint, boolean checkRecent) } ChunkKey key; - if (objId instanceof RefData.IdWithChunk) - key = ((RefData.IdWithChunk) objId).getChunkKey(); + if (objId instanceof RefDataUtil.IdWithChunk) + key = ((RefDataUtil.IdWithChunk) objId).getChunkKey(); else key = repository.getRefDatabase().findChunk(objId); @@ -331,8 +331,8 @@ ChunkAndOffset getChunk(AnyObjectId objId, int typeHint, boolean checkRecent) } ChunkKey findChunk(AnyObjectId objId) throws DhtException { - if (objId instanceof IdWithChunk) - return ((IdWithChunk) objId).getChunkKey(); + if (objId instanceof RefDataUtil.IdWithChunk) + return ((RefDataUtil.IdWithChunk) objId).getChunkKey(); ChunkKey key = repository.getRefDatabase().findChunk(objId); if (key != null) diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefDatabase.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefDatabase.java index 22569b91e..ef6123a53 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefDatabase.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefDatabase.java @@ -55,6 +55,7 @@ import java.util.concurrent.atomic.AtomicReference; import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectIdRef.PeeledNonTag; @@ -68,6 +69,7 @@ import org.eclipse.jgit.revwalk.RevObject; import org.eclipse.jgit.revwalk.RevTag; import org.eclipse.jgit.revwalk.RevWalk; +import org.eclipse.jgit.storage.dht.RefDataUtil.IdWithChunk; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.Database; import org.eclipse.jgit.util.RefList; @@ -94,7 +96,7 @@ DhtRepository getRepository() { ChunkKey findChunk(AnyObjectId id) { RefCache c = cache.get(); if (c != null) { - RefData.IdWithChunk i = c.hints.get(id); + IdWithChunk i = c.hints.get(id); if (i != null) return i.getChunkKey(); } @@ -190,8 +192,8 @@ private void cachePeeledState(Ref oldLeaf, Ref newLeaf) { try { RepositoryKey repo = repository.getRepositoryKey(); RefKey key = RefKey.create(repo, newLeaf.getName()); - RefData oldData = RefData.fromRef(oldLeaf); - RefData newData = RefData.fromRef(newLeaf); + RefData oldData = RefDataUtil.fromRef(oldLeaf); + RefData newData = RefDataUtil.fromRef(newLeaf); db.ref().compareAndPut(key, oldData, newData); } catch (TimeoutException e) { // Ignore a timeout here, we were only trying to update @@ -214,13 +216,12 @@ private Ref doPeel(final Ref leaf) throws MissingObjectException, ChunkKey key = ctx.findChunk(oId); if (key != null) - oId = new RefData.IdWithChunk(oId, key); + oId = new IdWithChunk(oId, key); if (obj instanceof RevTag) { ObjectId pId = rw.peel(obj); key = ctx.findChunk(pId); - pId = key != null ? new RefData.IdWithChunk(pId, key) : pId - .copy(); + pId = key != null ? new IdWithChunk(pId, key) : pId.copy(); return new PeeledTag(leaf.getStorage(), name, oId, pId); } else { return new PeeledNonTag(leaf.getStorage(), name, oId); @@ -353,7 +354,7 @@ private RefCache readRefs() throws DhtException { private RefCache read() throws DhtException, TimeoutException { RefList.Builder id = new RefList.Builder(); RefList.Builder sym = new RefList.Builder(); - ObjectIdSubclassMap hints = new ObjectIdSubclassMap(); + ObjectIdSubclassMap hints = new ObjectIdSubclassMap(); for (Map.Entry e : scan()) { Ref ref = fromData(e.getKey().getName(), e.getValue()); @@ -362,12 +363,12 @@ private RefCache read() throws DhtException, TimeoutException { sym.add(ref); id.add(ref); - if (ref.getObjectId() instanceof RefData.IdWithChunk + if (ref.getObjectId() instanceof IdWithChunk && !hints.contains(ref.getObjectId())) - hints.add((RefData.IdWithChunk) ref.getObjectId()); - if (ref.getPeeledObjectId() instanceof RefData.IdWithChunk + hints.add((IdWithChunk) ref.getObjectId()); + if (ref.getPeeledObjectId() instanceof IdWithChunk && !hints.contains(ref.getPeeledObjectId())) - hints.add((RefData.IdWithChunk) ref.getPeeledObjectId()); + hints.add((IdWithChunk) ref.getPeeledObjectId()); } id.sort(); @@ -377,40 +378,20 @@ private RefCache read() throws DhtException, TimeoutException { } private static Ref fromData(String name, RefData data) { - ObjectId oId = null; - boolean peeled = false; - ObjectId pId = null; - - TinyProtobuf.Decoder d = data.decode(); - DECODE: for (;;) { - switch (d.next()) { - case 0: - break DECODE; - - case RefData.TAG_SYMREF: { - String symref = d.string(); - Ref leaf = new Unpeeled(NEW, symref, null); - return new SymbolicRef(name, leaf); - } - - case RefData.TAG_TARGET: - oId = RefData.IdWithChunk.decode(d.message()); - continue; - case RefData.TAG_IS_PEELED: - peeled = d.bool(); - continue; - case RefData.TAG_PEELED: - pId = RefData.IdWithChunk.decode(d.message()); - continue; - default: - d.skip(); - continue; - } + if (data.hasSymref()) { + Ref leaf = new Unpeeled(NEW, data.getSymref(), null); + return new SymbolicRef(name, leaf); } - if (peeled && pId != null) + if (!data.hasTarget()) + return new Unpeeled(LOOSE, name, null); + + ObjectId oId = IdWithChunk.create(data.getTarget()); + if (data.getIsPeeled() && data.hasPeeled()) { + ObjectId pId = IdWithChunk.create(data.getPeeled()); return new PeeledTag(LOOSE, name, oId, pId); - if (peeled) + } + if (data.getIsPeeled()) return new PeeledNonTag(LOOSE, name, oId); return new Unpeeled(LOOSE, name, oId); } @@ -427,10 +408,10 @@ private static class RefCache { final RefList sym; - final ObjectIdSubclassMap hints; + final ObjectIdSubclassMap hints; RefCache(RefList ids, RefList sym, - ObjectIdSubclassMap hints) { + ObjectIdSubclassMap hints) { this.ids = ids; this.sym = sym; this.hints = hints; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefUpdate.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefUpdate.java index 158b7cf49..f131e2d74 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefUpdate.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtRefUpdate.java @@ -47,6 +47,7 @@ import java.util.concurrent.TimeoutException; import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefUpdate; @@ -106,7 +107,7 @@ protected boolean tryLock(boolean deref) throws IOException { dstRef = dstRef.getLeaf(); refKey = RefKey.create(repo, dstRef.getName()); - oldData = RefData.fromRef(dstRef); + oldData = RefDataUtil.fromRef(dstRef); if (dstRef.isSymbolic()) setOldObjectId(null); @@ -157,7 +158,7 @@ protected Result doDelete(Result desiredResult) throws IOException { @Override protected Result doLink(String target) throws IOException { try { - newData = RefData.symbolic(target); + newData = RefDataUtil.symbolic(target); boolean r = db.ref().compareAndPut(refKey, oldData, newData); if (r) { getRefDatabase().stored(dstRef.getName(), newData); @@ -181,19 +182,19 @@ private RefData newData() throws IOException { ChunkKey key = ctx.findChunk(newId); if (key != null) - newId = new RefData.IdWithChunk(newId, key); + newId = new RefDataUtil.IdWithChunk(newId, key); if (obj instanceof RevTag) { ObjectId pId = rw.peel(obj); key = ctx.findChunk(pId); - pId = key != null ? new RefData.IdWithChunk(pId, key) : pId; - return RefData.peeled(newId, pId); + pId = key != null ? new RefDataUtil.IdWithChunk(pId, key) : pId; + return RefDataUtil.peeled(newId, pId); } else if (obj != null) - return RefData.peeled(newId, null); + return RefDataUtil.peeled(newId, null); else - return RefData.id(newId); + return RefDataUtil.id(newId); } catch (MissingObjectException e) { - return RefData.id(newId); + return RefDataUtil.id(newId); } } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtText.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtText.java index 3c35ad6df..4fb520be1 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtText.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/DhtText.java @@ -59,9 +59,12 @@ public static DhtText get() { /***/ public String cycleInDeltaChain; /***/ public String databaseRequired; /***/ public String expectedObjectSizeDuringCopyAsIs; + /***/ public String invalidCachedPackInfo; /***/ public String invalidChunkKey; + /***/ public String invalidChunkMeta; /***/ public String invalidObjectIndexKey; /***/ public String invalidObjectInfo; + /***/ public String invalidRefData; /***/ public String missingChunk; /***/ public String missingLongOffsetBase; /***/ public String nameRequired; @@ -72,12 +75,6 @@ public static DhtText get() { /***/ public String objectTypeUnknown; /***/ public String packParserInvalidPointer; /***/ public String packParserRollbackFailed; - /***/ public String protobufNegativeValuesNotSupported; - /***/ public String protobufNoArray; - /***/ public String protobufNotBooleanValue; - /***/ public String protobufUnsupportedFieldType; - /***/ public String protobufWrongFieldLength; - /***/ public String protobufWrongFieldType; /***/ public String recordingObjects; /***/ public String repositoryAlreadyExists; /***/ public String repositoryMustBeBare; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/LargeNonDeltaObject.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/LargeNonDeltaObject.java index aaef431c7..e6afd731f 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/LargeNonDeltaObject.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/LargeNonDeltaObject.java @@ -50,6 +50,7 @@ import org.eclipse.jgit.errors.LargeObjectException; import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.ObjectLoader; import org.eclipse.jgit.lib.ObjectStream; @@ -102,7 +103,7 @@ public ObjectStream openStream() throws MissingObjectException, IOException { if (pc != null) firstChunk = null; else - pc = ctx.getChunk(meta.getFragmentKey(0)); + pc = ctx.getChunk(ChunkKey.fromString(meta.getFragment(0))); InputStream in = new ChunkInputStream(meta, ctx, pos, pc); in = new BufferedInputStream(new InflaterInputStream(in), 8192); @@ -138,7 +139,8 @@ public int read(byte[] dstbuf, int dstptr, int dstlen) if (fragment == meta.getFragmentCount()) return -1; - pc = ctx.getChunk(meta.getFragmentKey(++fragment)); + pc = ctx.getChunk(ChunkKey.fromString( + meta.getFragment(++fragment))); ptr = 0; n = pc.read(ptr, dstbuf, dstptr, dstlen); if (n == 0) diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectInfo.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectInfo.java index 941ed6a6d..9123a8be8 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectInfo.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectInfo.java @@ -43,13 +43,12 @@ package org.eclipse.jgit.storage.dht; -import java.text.MessageFormat; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.List; -import org.eclipse.jgit.lib.Constants; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; import org.eclipse.jgit.lib.ObjectId; /** Connects an object to the chunk it is stored in. */ @@ -71,106 +70,40 @@ public static void sort(List toSort) { Collections.sort(toSort, BY_TIME); } + private final ChunkKey chunk; + + private final long time; + + private final GitStore.ObjectInfo data; + /** - * Parse an ObjectInfo from the storage system. + * Wrap an ObjectInfo from the storage system. * * @param chunkKey * the chunk the object points to. * @param data * the data of the ObjectInfo. - * @param time - * timestamp of the ObjectInfo. If the implementation does not - * store timestamp data, supply a negative value. - * @return the object's information. */ - public static ObjectInfo fromBytes(ChunkKey chunkKey, byte[] data, long time) { - return fromBytes(chunkKey, TinyProtobuf.decode(data), time); + public ObjectInfo(ChunkKey chunkKey, GitStore.ObjectInfo data) { + this.chunk = chunkKey; + this.time = 0; + this.data = data; } /** - * Parse an ObjectInfo from the storage system. + * Wrap an ObjectInfo from the storage system. * * @param chunkKey * the chunk the object points to. - * @param d - * the data of the ObjectInfo. * @param time - * timestamp of the ObjectInfo. If the implementation does not - * store timestamp data, supply a negative value. - * @return the object's information. + * timestamp of the ObjectInfo. + * @param data + * the data of the ObjectInfo. */ - public static ObjectInfo fromBytes(ChunkKey chunkKey, - TinyProtobuf.Decoder d, long time) { - int typeCode = -1; - int offset = -1; - long packedSize = -1; - long inflatedSize = -1; - ObjectId deltaBase = null; - boolean fragmented = false; - - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - typeCode = d.int32(); - continue; - case 2: - offset = d.int32(); - continue; - case 3: - packedSize = d.int64(); - continue; - case 4: - inflatedSize = d.int64(); - continue; - case 5: - deltaBase = d.bytesObjectId(); - continue; - case 6: - fragmented = d.bool(); - continue; - default: - d.skip(); - continue; - } - } - - if (typeCode < 0 || offset < 0 || packedSize < 0 || inflatedSize < 0) - throw new IllegalArgumentException(MessageFormat.format( - DhtText.get().invalidObjectInfo, chunkKey)); - - return new ObjectInfo(chunkKey, time, typeCode, offset, // - packedSize, inflatedSize, deltaBase, fragmented); - } - - private final ChunkKey chunk; - - private final long time; - - private final int typeCode; - - private final int offset; - - private final long packedSize; - - private final long inflatedSize; - - private final ObjectId deltaBase; - - private final boolean fragmented; - - ObjectInfo(ChunkKey chunk, long time, int typeCode, int offset, - long packedSize, long inflatedSize, ObjectId base, - boolean fragmented) { - this.chunk = chunk; + public ObjectInfo(ChunkKey chunkKey, long time, GitStore.ObjectInfo data) { + this.chunk = chunkKey; this.time = time < 0 ? 0 : time; - this.typeCode = typeCode; - this.offset = offset; - this.packedSize = packedSize; - this.inflatedSize = inflatedSize; - this.deltaBase = base; - this.fragmented = fragmented; + this.data = data; } /** @return the chunk this link points to. */ @@ -183,54 +116,43 @@ public long getTime() { return time; } + /** @return GitStore.ObjectInfo to embed in the database. */ + public GitStore.ObjectInfo getData() { + return data; + } + /** @return type of the object, in OBJ_* constants. */ public int getType() { - return typeCode; + return data.getObjectType().getNumber(); } /** @return size of the object when fully inflated. */ public long getSize() { - return inflatedSize; + return data.getInflatedSize(); } /** @return true if the object storage uses delta compression. */ public boolean isDelta() { - return getDeltaBase() != null; + return data.hasDeltaBase(); } /** @return true if the object has been fragmented across chunks. */ public boolean isFragmented() { - return fragmented; + return data.getIsFragmented(); } int getOffset() { - return offset; + return data.getOffset(); } long getPackedSize() { - return packedSize; + return data.getPackedSize(); } ObjectId getDeltaBase() { - return deltaBase; - } - - /** - * Convert this ObjectInfo into a byte array for storage. - * - * @return the ObjectInfo data, encoded as a byte array. This does not - * include the ChunkKey, callers must store that separately. - */ - public byte[] asBytes() { - TinyProtobuf.Encoder e = TinyProtobuf.encode(256); - e.int32(1, typeCode); - e.int32(2, offset); - e.int64(3, packedSize); - e.int64(4, inflatedSize); - e.bytes(5, deltaBase); - if (fragmented) - e.bool(6, fragmented); - return e.asByteArray(); + if (data.hasDeltaBase()) + return ObjectId.fromRaw(data.getDeltaBase().toByteArray(), 0); + return null; } @Override @@ -238,18 +160,10 @@ public String toString() { StringBuilder b = new StringBuilder(); b.append("ObjectInfo:"); b.append(chunk); - b.append(" ["); if (0 < time) - b.append(" time=").append(new Date(time)); - b.append(" type=").append(Constants.typeString(typeCode)); - b.append(" offset=").append(offset); - b.append(" packedSize=").append(packedSize); - b.append(" inflatedSize=").append(inflatedSize); - if (deltaBase != null) - b.append(" deltaBase=").append(deltaBase.name()); - if (fragmented) - b.append(" fragmented"); - b.append(" ]"); + b.append(" @ ").append(new Date(time)); + b.append("\n"); + b.append(data.toString()); return b.toString(); } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectWriter.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectWriter.java index 17e36ab99..d36b03bdb 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectWriter.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/ObjectWriter.java @@ -43,7 +43,6 @@ package org.eclipse.jgit.storage.dht; -import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; @@ -55,6 +54,7 @@ import java.util.concurrent.Semaphore; import java.util.concurrent.atomic.AtomicReference; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.util.BlockList; @@ -136,7 +136,7 @@ void plan(List list) throws DhtException { ChunkMeta meta = allMeta.remove(key); if (meta != null) { for (int i = 1; i < meta.getFragmentCount(); i++) - keys.add(meta.getFragmentKey(i)); + keys.add(ChunkKey.fromString(meta.getFragment(i))); } } order = keys; @@ -221,7 +221,7 @@ private void awaitPendingBatches() throws InterruptedException, throw metaError.get(); } - private class MetaLoader implements AsyncCallback> { + private class MetaLoader implements AsyncCallback> { private final Context context; private final Set keys; @@ -231,13 +231,11 @@ private class MetaLoader implements AsyncCallback> { this.keys = keys; } - public void onSuccess(Collection result) { + public void onSuccess(Map result) { try { synchronized (allMeta) { - for (ChunkMeta meta : result) { - allMeta.put(meta.getChunkKey(), meta); - keys.remove(meta.getChunkKey()); - } + allMeta.putAll(result); + keys.removeAll(result.keySet()); } if (context == Context.FAST_MISSING_OK && !keys.isEmpty()) { synchronized (metaMissing) { diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/PackChunk.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/PackChunk.java index c3bedc4ae..c0684022f 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/PackChunk.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/PackChunk.java @@ -63,6 +63,7 @@ import org.eclipse.jgit.errors.CorruptObjectException; import org.eclipse.jgit.errors.LargeObjectException; import org.eclipse.jgit.errors.StoredObjectRepresentationNotAvailableException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectLoader; @@ -251,8 +252,6 @@ public PackChunk build() throws DhtException { private volatile Boolean valid; - private volatile ChunkKey nextFragment; - PackChunk(ChunkKey key, byte[] dataBuf, int dataPtr, int dataLen, ChunkIndex index, ChunkMeta meta) { this.key = key; @@ -400,9 +399,12 @@ private static ObjectLoader read1(PackChunk pc, int pos, base = base - pos; ChunkMeta.BaseChunk baseChunk; - baseChunk = pc.meta.getBaseChunk(base); - baseChunkKey = baseChunk.getChunkKey(); - basePosInChunk = (int) (baseChunk.relativeStart - base); + baseChunk = ChunkMetaUtil.getBaseChunk( + pc.key, + pc.meta, + base); + baseChunkKey = ChunkKey.fromString(baseChunk.getChunkKey()); + basePosInChunk = (int) (baseChunk.getRelativeStart() - base); } delta = new Delta(delta, // @@ -559,7 +561,8 @@ private static byte[] inflateFragment(long sz, PackChunk pc, final int pos, if (inf.needsInput()) { if (meta.getFragmentCount() <= nextChunk) break; - pc = reader.getChunk(meta.getFragmentKey(nextChunk++)); + pc = reader.getChunk(ChunkKey.fromString( + meta.getFragment(nextChunk++))); if (meta.getFragmentCount() == nextChunk) bs = pc.dataLen; // Include trailer on last chunk. else @@ -575,7 +578,7 @@ private static byte[] inflateFragment(long sz, PackChunk pc, final int pos, if (dstoff != sz) { throw new DataFormatException(MessageFormat.format( DhtText.get().shortCompressedObject, - meta.getChunkKey(), + ChunkKey.fromString(meta.getFragment(0)), Integer.valueOf(pos))); } return dstbuf; @@ -683,7 +686,8 @@ else if (-1 == obj.size) if (isFragment()) { int cnt = meta.getFragmentCount(); for (int fragId = 1; fragId < cnt; fragId++) { - PackChunk pc = ctx.getChunk(meta.getFragmentKey(fragId)); + PackChunk pc = ctx.getChunk(ChunkKey.fromString( + meta.getFragment(fragId))); pc.copyEntireChunkAsIs(out, obj, validate); } } @@ -728,18 +732,6 @@ int getTotalSize() { return sz; } - ChunkKey getNextFragment() { - if (meta == null) - return null; - - ChunkKey next = nextFragment; - if (next == null) { - next = meta.getNextFragment(getChunkKey()); - nextFragment = next; - } - return next; - } - private static class Delta { /** Child that applies onto this object. */ final Delta next; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/Prefetcher.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/Prefetcher.java index b7463db3f..743f1f594 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/Prefetcher.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/Prefetcher.java @@ -59,6 +59,7 @@ import java.util.concurrent.TimeoutException; import org.eclipse.jgit.errors.MissingObjectException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevTree; @@ -218,14 +219,21 @@ void push(ChunkMeta meta) { if (hint != null) { synchronized (this) { - if (followEdgeHints && !hint.getEdge().isEmpty()) - push(hint.getEdge()); + if (followEdgeHints && 0 < hint.getEdgeCount()) + push(hint.getEdgeList()); else - push(hint.getSequential()); + push(hint.getSequentialList()); } } } + private void push(List list) { + List keys = new ArrayList(list.size()); + for (String keyString : list) + keys.add(ChunkKey.fromString(keyString)); + push(keys); + } + void push(Iterable list) { synchronized (this) { for (ChunkKey key : list) { diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/QueueObjectLookup.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/QueueObjectLookup.java index 482caf891..9cf513d26 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/QueueObjectLookup.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/QueueObjectLookup.java @@ -55,7 +55,6 @@ import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.lib.AsyncOperation; import org.eclipse.jgit.lib.ObjectId; -import org.eclipse.jgit.storage.dht.RefData.IdWithChunk; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.Database; @@ -119,8 +118,8 @@ private Iterable lookInCache(Iterable objects) { RecentInfoCache infoCache = reader.getRecentInfoCache(); List missing = null; for (T obj : objects) { - if (needChunkOnly && obj instanceof IdWithChunk) { - push(obj, ((IdWithChunk) obj).getChunkKey()); + if (needChunkOnly && obj instanceof RefDataUtil.IdWithChunk) { + push(obj, ((RefDataUtil.IdWithChunk) obj).getChunkKey()); continue; } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RecentChunks.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RecentChunks.java index f704c1daf..f75e3bdc8 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RecentChunks.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RecentChunks.java @@ -48,7 +48,7 @@ import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.ObjectLoader; import org.eclipse.jgit.storage.dht.DhtReader.ChunkAndOffset; -import org.eclipse.jgit.storage.dht.RefData.IdWithChunk; +import org.eclipse.jgit.storage.dht.RefDataUtil.IdWithChunk; final class RecentChunks { private final DhtReader reader; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefData.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefData.java deleted file mode 100644 index e34e9d1c3..000000000 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefData.java +++ /dev/null @@ -1,235 +0,0 @@ -/* - * Copyright (C) 2011, Google Inc. - * and other copyright owners as documented in the project's IP log. - * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php - * - * 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 the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -package org.eclipse.jgit.storage.dht; - -import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH; -import static org.eclipse.jgit.storage.dht.TinyProtobuf.encode; - -import java.util.Arrays; - -import org.eclipse.jgit.lib.AnyObjectId; -import org.eclipse.jgit.lib.ObjectId; -import org.eclipse.jgit.lib.Ref; -import org.eclipse.jgit.storage.dht.TinyProtobuf.Encoder; - -/** - * Describes the current state of a Git reference. - *

- * The reference state contains not just the SHA-1 object name that a reference - * points to, but the state also caches its peeled value if its a tag, and the - * {@link ChunkKey} the object was observed in when the reference was last - * updated. This cached data reduces latency when initially starting to work - * with a repository. - */ -public class RefData { - /** Magic constant meaning does not exist. */ - public static final RefData NONE = new RefData(new byte[0]); - - static final int TAG_SYMREF = 1; - - static final int TAG_TARGET = 2; - - static final int TAG_IS_PEELED = 3; - - static final int TAG_PEELED = 4; - - /** - * @param data - * @return the content - */ - public static RefData fromBytes(byte[] data) { - return new RefData(data); - } - - static RefData symbolic(String target) { - Encoder e = encode(2 + target.length()); - e.string(TAG_SYMREF, target); - return new RefData(e.asByteArray()); - } - - static RefData id(AnyObjectId id) { - Encoder e = encode(4 + OBJECT_ID_STRING_LENGTH + ChunkKey.KEYLEN); - e.message(TAG_TARGET, IdWithChunk.encode(id)); - return new RefData(e.asByteArray()); - } - - static RefData fromRef(Ref ref) { - if (ref.isSymbolic()) - return symbolic(ref.getTarget().getName()); - - if (ref.getObjectId() == null) - return RefData.NONE; - - int max = 8 + 2 * OBJECT_ID_STRING_LENGTH + 2 * ChunkKey.KEYLEN; - Encoder e = encode(max); - e.message(TAG_TARGET, IdWithChunk.encode(ref.getObjectId())); - if (ref.isPeeled()) { - e.bool(TAG_IS_PEELED, true); - if (ref.getPeeledObjectId() != null) - e.message(TAG_PEELED, - IdWithChunk.encode(ref.getPeeledObjectId())); - } - return new RefData(e.asByteArray()); - } - - static RefData peeled(ObjectId targetId, ObjectId peeledId) { - int max = 8 + 2 * OBJECT_ID_STRING_LENGTH + 2 * ChunkKey.KEYLEN; - Encoder e = encode(max); - e.message(TAG_TARGET, IdWithChunk.encode(targetId)); - e.bool(TAG_IS_PEELED, true); - if (peeledId != null) - e.message(TAG_PEELED, IdWithChunk.encode(peeledId)); - return new RefData(e.asByteArray()); - } - - private final byte[] data; - - RefData(byte[] data) { - this.data = data; - } - - TinyProtobuf.Decoder decode() { - return TinyProtobuf.decode(data); - } - - /** @return the contents, encoded as a byte array for storage. */ - public byte[] asBytes() { - return data; - } - - @Override - public int hashCode() { - int hash = 5381; - for (int ptr = 0; ptr < data.length; ptr++) - hash = ((hash << 5) + hash) + (data[ptr] & 0xff); - return hash; - } - - @Override - public boolean equals(Object other) { - if (other instanceof RefData) - return Arrays.equals(data, ((RefData) other).data); - return false; - } - - @Override - public String toString() { - StringBuilder b = new StringBuilder(); - TinyProtobuf.Decoder d = decode(); - for (;;) { - switch (d.next()) { - case 0: - return b.toString().substring(1); - case TAG_SYMREF: - b.append("\nsymref: ").append(d.string()); - continue; - case TAG_TARGET: - b.append("\ntarget: ").append(IdWithChunk.decode(d.message())); - continue; - case TAG_IS_PEELED: - b.append("\nis_peeled: ").append(d.bool()); - continue; - case TAG_PEELED: - b.append("\npeeled: ").append(IdWithChunk.decode(d.message())); - continue; - default: - d.skip(); - continue; - } - } - } - - static class IdWithChunk extends ObjectId { - static ObjectId decode(TinyProtobuf.Decoder d) { - ObjectId id = null; - ChunkKey key = null; - DECODE: for (;;) { - switch (d.next()) { - case 0: - break DECODE; - case 1: - id = d.stringObjectId(); - continue; - case 2: - key = ChunkKey.fromBytes(d); - continue; - default: - d.skip(); - } - } - return key != null ? new IdWithChunk(id, key) : id; - } - - static TinyProtobuf.Encoder encode(AnyObjectId id) { - if (id instanceof IdWithChunk) { - int max = 4 + OBJECT_ID_STRING_LENGTH + ChunkKey.KEYLEN; - TinyProtobuf.Encoder e = TinyProtobuf.encode(max); - e.string(1, id); - e.string(2, ((IdWithChunk) id).chunkKey); - return e; - } else { - int max = 2 + OBJECT_ID_STRING_LENGTH; - TinyProtobuf.Encoder e = TinyProtobuf.encode(max); - e.string(1, id); - return e; - } - } - - private final ChunkKey chunkKey; - - IdWithChunk(AnyObjectId id, ChunkKey key) { - super(id); - this.chunkKey = key; - } - - ChunkKey getChunkKey() { - return chunkKey; - } - - @Override - public String toString() { - return name() + "->" + chunkKey; - } - } -} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefDataUtil.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefDataUtil.java new file mode 100644 index 000000000..7c5d9e0b8 --- /dev/null +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/RefDataUtil.java @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2011, Google Inc. + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * 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 the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.eclipse.jgit.storage.dht; + +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; +import org.eclipse.jgit.lib.AnyObjectId; +import org.eclipse.jgit.lib.ObjectId; +import org.eclipse.jgit.lib.Ref; + +/** Tools to work with {@link RefData}. */ +public class RefDataUtil { + /** Magic constant meaning does not exist. */ + public static final RefData NONE = RefData.newBuilder().build(); + + static RefData symbolic(String target) { + RefData.Builder b = RefData.newBuilder(); + b.setSymref(target); + return b.build(); + } + + static RefData id(AnyObjectId id) { + RefData.Builder b = RefData.newBuilder(); + b.setTarget(toRefData(id)); + return b.build(); + } + + static RefData fromRef(Ref ref) { + if (ref.isSymbolic()) + return symbolic(ref.getTarget().getName()); + + if (ref.getObjectId() == null) + return NONE; + + RefData.Builder b = RefData.newBuilder(); + b.setTarget(toRefData(ref.getObjectId())); + if (ref.isPeeled()) { + b.setIsPeeled(true); + if (ref.getPeeledObjectId() != null) + b.setPeeled(toRefData(ref.getPeeledObjectId())); + } + return b.build(); + } + + static RefData peeled(ObjectId targetId, ObjectId peeledId) { + RefData.Builder b = RefData.newBuilder(); + b.setTarget(toRefData(targetId)); + b.setIsPeeled(true); + if (peeledId != null) + b.setPeeled(toRefData(peeledId)); + return b.build(); + } + + private static RefData.Id toRefData(AnyObjectId id) { + RefData.Id.Builder r = RefData.Id.newBuilder(); + r.setObjectName(id.name()); + if (id instanceof IdWithChunk) + r.setChunkKey(((IdWithChunk) id).getChunkKey().asString()); + return r.build(); + } + + static class IdWithChunk extends ObjectId { + static ObjectId create(RefData.Id src) { + if (src.hasChunkKey()) { + return new IdWithChunk( + ObjectId.fromString(src.getObjectName()), + ChunkKey.fromString(src.getChunkKey())); + } + return ObjectId.fromString(src.getObjectName()); + } + + private final ChunkKey chunkKey; + + IdWithChunk(AnyObjectId id, ChunkKey key) { + super(id); + this.chunkKey = key; + } + + ChunkKey getChunkKey() { + return chunkKey; + } + + @Override + public String toString() { + return name() + "->" + chunkKey; + } + } + + private RefDataUtil() { + // Utility class, do not create instances. + } +} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/TinyProtobuf.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/TinyProtobuf.java deleted file mode 100644 index dcf3dfb17..000000000 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/TinyProtobuf.java +++ /dev/null @@ -1,755 +0,0 @@ -/* - * Copyright (C) 2011, Google Inc. - * and other copyright owners as documented in the project's IP log. - * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php - * - * 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 the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -package org.eclipse.jgit.storage.dht; - -import static org.eclipse.jgit.lib.Constants.OBJECT_ID_LENGTH; -import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH; - -import java.nio.ByteBuffer; -import java.text.MessageFormat; - -import org.eclipse.jgit.lib.AnyObjectId; -import org.eclipse.jgit.lib.Constants; -import org.eclipse.jgit.lib.ObjectId; -import org.eclipse.jgit.util.RawParseUtils; - -/** - * A tiny implementation of a subset of the Google Protocol Buffers format. - *

- * For more information on the network format, see the canonical documentation - * at Google Protocol Buffers. - */ -public class TinyProtobuf { - private static final int WIRE_VARINT = 0; - - private static final int WIRE_FIXED_64 = 1; - - private static final int WIRE_LEN_DELIM = 2; - - private static final int WIRE_FIXED_32 = 5; - - /** - * Create a new encoder. - * - * @param estimatedSize - * estimated size of the message. If the size is accurate, - * copying of the result can be avoided during - * {@link Encoder#asByteArray()}. If the size is too small, the - * buffer will grow dynamically. - * @return a new encoder. - */ - public static Encoder encode(int estimatedSize) { - return new Encoder(new byte[estimatedSize]); - } - - /** - * Create an encoder that estimates size. - * - * @return a new encoder. - */ - public static Encoder size() { - return new Encoder(null); - } - - /** - * Decode a buffer. - * - * @param buf - * the buffer to read. - * @return a new decoder. - */ - public static Decoder decode(byte[] buf) { - return decode(buf, 0, buf.length); - } - - /** - * Decode a buffer. - * - * @param buf - * the buffer to read. - * @param off - * offset to begin reading from {@code buf}. - * @param len - * total number of bytes to read from {@code buf}. - * @return a new decoder. - */ - public static Decoder decode(byte[] buf, int off, int len) { - return new Decoder(buf, off, len); - } - - /** An enumerated value that encodes/decodes as int32. */ - public static interface Enum { - /** @return the wire value. */ - public int value(); - } - - /** Decode fields from a binary protocol buffer. */ - public static class Decoder { - private final byte[] buf; - - private final int end; - - private int ptr; - - private int field; - - private int type; - - private int length; - - private Decoder(byte[] buf, int off, int len) { - this.buf = buf; - this.ptr = off; - this.end = off + len; - } - - /** @return get the field tag number, 0 on end of buffer. */ - public int next() { - if (ptr == end) - return 0; - - int fieldAndType = varint32(); - field = fieldAndType >>> 3; - type = fieldAndType & 7; - return field; - } - - /** Skip the current field's value. */ - public void skip() { - switch (type) { - case WIRE_VARINT: - varint64(); - break; - case WIRE_FIXED_64: - ptr += 8; - break; - case WIRE_LEN_DELIM: - ptr += varint32(); - break; - case WIRE_FIXED_32: - ptr += 4; - break; - default: - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufUnsupportedFieldType, Integer - .valueOf(type))); - } - } - - /** @return decode the current field as an int32. */ - public int int32() { - checkFieldType(WIRE_VARINT); - return varint32(); - } - - /** @return decode the current field as an int64. */ - public long int64() { - checkFieldType(WIRE_VARINT); - return varint64(); - } - - /** - * @param - * the type of enumeration. - * @param all - * all of the supported values. - * @return decode the current field as an enumerated value. - */ - public T intEnum(T[] all) { - checkFieldType(WIRE_VARINT); - int value = varint32(); - for (T t : all) { - if (t.value() == value) - return t; - } - throw new IllegalStateException(MessageFormat.format( - DhtText.get().protobufWrongFieldType, Integer - .valueOf(field), Integer.valueOf(type), all[0] - .getClass().getSimpleName())); - } - - /** @return decode the current field as a bool. */ - public boolean bool() { - checkFieldType(WIRE_VARINT); - int val = varint32(); - switch (val) { - case 0: - return false; - case 1: - return true; - default: - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufNotBooleanValue, Integer.valueOf(field), - Integer.valueOf(val))); - } - } - - /** @return decode a fixed 64 bit value. */ - public long fixed64() { - checkFieldType(WIRE_FIXED_64); - long val = buf[ptr + 0] & 0xff; - val |= ((long) (buf[ptr + 1] & 0xff)) << (1 * 8); - val |= ((long) (buf[ptr + 2] & 0xff)) << (2 * 8); - val |= ((long) (buf[ptr + 3] & 0xff)) << (3 * 8); - val |= ((long) (buf[ptr + 4] & 0xff)) << (4 * 8); - val |= ((long) (buf[ptr + 5] & 0xff)) << (5 * 8); - val |= ((long) (buf[ptr + 6] & 0xff)) << (6 * 8); - val |= ((long) (buf[ptr + 7] & 0xff)) << (7 * 8); - ptr += 8; - return val; - } - - /** @return decode the current field as a string. */ - public String string() { - checkFieldType(WIRE_LEN_DELIM); - int len = varint32(); - String s = RawParseUtils.decode(buf, ptr, ptr + len); - ptr += len; - return s; - } - - /** @return decode the current hex string to an ObjectId. */ - public ObjectId stringObjectId() { - checkFieldType(WIRE_LEN_DELIM); - int len = varint32(); - if (len != OBJECT_ID_STRING_LENGTH) - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufWrongFieldLength, - Integer.valueOf(field), Integer - .valueOf(OBJECT_ID_STRING_LENGTH), Integer - .valueOf(len))); - - ObjectId id = ObjectId.fromString(buf, ptr); - ptr += OBJECT_ID_STRING_LENGTH; - return id; - } - - /** @return decode a string from 8 hex digits. */ - public int stringHex32() { - checkFieldType(WIRE_LEN_DELIM); - int len = varint32(); - if (len != 8) - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufWrongFieldLength, - Integer.valueOf(field), Integer.valueOf(8), Integer - .valueOf(len))); - int val = KeyUtils.parse32(buf, ptr); - ptr += 8; - return val; - } - - /** @return decode the current field as an array of bytes. */ - public byte[] bytes() { - checkFieldType(WIRE_LEN_DELIM); - byte[] r = new byte[varint32()]; - System.arraycopy(buf, ptr, r, 0, r.length); - ptr += r.length; - return r; - } - - /** @return backing array of the current field. */ - public byte[] bytesArray() { - return buf; - } - - /** @return length of field, call before {@link #bytesOffset}. */ - public int bytesLength() { - checkFieldType(WIRE_LEN_DELIM); - length = varint32(); - return length; - } - - /** @return starting offset of the field, after {@link #bytesLength()}. */ - public int bytesOffset() { - int start = ptr; - ptr += length; - return start; - } - - /** @return decode the current raw bytes to an ObjectId. */ - public ObjectId bytesObjectId() { - checkFieldType(WIRE_LEN_DELIM); - int len = varint32(); - if (len != OBJECT_ID_LENGTH) - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufWrongFieldLength, - Integer.valueOf(field), Integer - .valueOf(OBJECT_ID_LENGTH), Integer - .valueOf(len))); - - ObjectId id = ObjectId.fromRaw(buf, ptr); - ptr += OBJECT_ID_LENGTH; - return id; - } - - /** @return decode the current field as a nested message. */ - public Decoder message() { - checkFieldType(WIRE_LEN_DELIM); - int len = varint32(); - Decoder msg = decode(buf, ptr, len); - ptr += len; - return msg; - } - - private int varint32() { - long v = varint64(); - if (Integer.MAX_VALUE < v) - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufWrongFieldType, Integer.valueOf(field), - "int64", "int32")); - return (int) v; - } - - private long varint64() { - int c = buf[ptr++]; - long r = c & 0x7f; - int shift = 7; - while ((c & 0x80) != 0) { - c = buf[ptr++]; - r |= ((long) (c & 0x7f)) << shift; - shift += 7; - } - return r; - } - - private void checkFieldType(int expected) { - if (type != expected) - throw new IllegalStateException(MessageFormat.format(DhtText - .get().protobufWrongFieldType, Integer.valueOf(field), - Integer.valueOf(type), Integer.valueOf(expected))); - } - } - - /** Encode values into a binary protocol buffer. */ - public static class Encoder { - private byte[] buf; - - private int ptr; - - private Encoder(byte[] buf) { - this.buf = buf; - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store. Must be >= 0. - */ - public void int32(int field, int value) { - int64(field, value); - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store; omitted if 0. - */ - public void int32IfNotZero(int field, int value) { - int64IfNotZero(field, value); - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store; omitted if negative. - */ - public void int32IfNotNegative(int field, int value) { - int64IfNotNegative(field, value); - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store. Must be >= 0. - */ - public void int64(int field, long value) { - if (value < 0) - throw new IllegalArgumentException( - DhtText.get().protobufNegativeValuesNotSupported); - - field(field, WIRE_VARINT); - varint(value); - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store; omitted if 0. - */ - public void int64IfNotZero(int field, long value) { - if (0 != value) - int64(field, value); - } - - /** - * Encode a variable length positive integer. - * - * @param field - * field tag number. - * @param value - * the value to store; omitted if negative. - */ - public void int64IfNotNegative(int field, long value) { - if (0 <= value) - int64(field, value); - } - - /** - * Encode an enumerated value. - * - * @param - * type of the enumerated values. - * @param field - * field tag number. - * @param value - * value to store; if null the field is omitted. - */ - public void intEnum(int field, T value) { - if (value != null) { - field(field, WIRE_VARINT); - varint(value.value()); - } - } - - /** - * Encode a boolean value. - * - * @param field - * field tag number. - * @param value - * the value to store. - */ - public void bool(int field, boolean value) { - field(field, WIRE_VARINT); - varint(value ? 1 : 0); - } - - /** - * Encode a boolean value, only if true. - * - * @param field - * field tag number. - * @param value - * the value to store. - */ - public void boolIfTrue(int field, boolean value) { - if (value) - bool(field, value); - } - - /** - * Encode a fixed 64 value. - * - * @param field - * field tag number. - * @param value - * the value to store. - */ - public void fixed64(int field, long value) { - field(field, WIRE_FIXED_64); - if (buf != null) { - ensureSpace(8); - - buf[ptr + 0] = (byte) value; - value >>>= 8; - - buf[ptr + 1] = (byte) value; - value >>>= 8; - - buf[ptr + 3] = (byte) value; - value >>>= 8; - - buf[ptr + 3] = (byte) value; - value >>>= 8; - - buf[ptr + 4] = (byte) value; - value >>>= 8; - - buf[ptr + 5] = (byte) value; - value >>>= 8; - - buf[ptr + 6] = (byte) value; - value >>>= 8; - - buf[ptr + 7] = (byte) value; - } - ptr += 8; - } - - /** - * Encode a length delimited bytes field. - * - * @param field - * field tag number. - * @param value - * the value to store; if null the field is omitted. - */ - public void bytes(int field, byte[] value) { - if (value != null) - bytes(field, value, 0, value.length); - } - - /** - * Encode a length delimited bytes field. - * - * @param field - * field tag number. - * @param value - * the value to store; if null the field is omitted. - */ - public void bytes(int field, ByteBuffer value) { - if (value != null) { - if (!value.hasArray()) - throw new IllegalArgumentException(DhtText.get().protobufNoArray); - byte[] valBuf = value.array(); - int valPtr = value.arrayOffset() + value.position(); - int valLen = value.limit() - value.position(); - bytes(field, valBuf, valPtr, valLen); - } - } - - /** - * Encode a length delimited bytes field. - * - * @param field - * field tag number. - * @param value - * the value to store; if null the field is omitted. - * @param off - * position to copy from. - * @param len - * number of bytes to copy. - */ - public void bytes(int field, byte[] value, int off, int len) { - if (value != null) { - field(field, WIRE_LEN_DELIM); - varint(len); - copy(value, off, len); - } - } - - /** - * Encode an ObjectId as a bytes (in raw binary format). - * - * @param field - * field tag number. - * @param value - * the value to store, as a raw binary; if null the field is - * omitted. - */ - public void bytes(int field, AnyObjectId value) { - if (value != null) { - field(field, WIRE_LEN_DELIM); - varint(OBJECT_ID_LENGTH); - if (buf != null) { - ensureSpace(OBJECT_ID_LENGTH); - value.copyRawTo(buf, ptr); - } - ptr += OBJECT_ID_LENGTH; - } - } - - /** - * Encode an ObjectId as a string (in hex format). - * - * @param field - * field tag number. - * @param value - * the value to store, as a hex string; if null the field is - * omitted. - */ - public void string(int field, AnyObjectId value) { - if (value != null) { - field(field, WIRE_LEN_DELIM); - varint(OBJECT_ID_STRING_LENGTH); - if (buf != null) { - ensureSpace(OBJECT_ID_STRING_LENGTH); - value.copyTo(buf, ptr); - } - ptr += OBJECT_ID_STRING_LENGTH; - } - } - - /** - * Encode a plain Java string. - * - * @param field - * field tag number. - * @param value - * the value to store; if null the field is omitted. - */ - public void string(int field, String value) { - if (value != null) - bytes(field, Constants.encode(value)); - } - - /** - * Encode a row key as a string. - * - * @param field - * field tag number. - * @param key - * the row key to store as a string; if null the field is - * omitted. - */ - public void string(int field, RowKey key) { - if (key != null) - bytes(field, key.asBytes()); - } - - /** - * Encode an integer as an 8 byte hex string. - * - * @param field - * field tag number. - * @param value - * value to encode. - */ - public void stringHex32(int field, int value) { - field(field, WIRE_LEN_DELIM); - varint(8); - if (buf != null) { - ensureSpace(8); - KeyUtils.format32(buf, ptr, value); - } - ptr += 8; - } - - /** - * Encode a nested message. - * - * @param field - * field tag number. - * @param msg - * message to store; if null or empty the field is omitted. - */ - public void message(int field, Encoder msg) { - if (msg != null && msg.ptr > 0) - bytes(field, msg.buf, 0, msg.ptr); - } - - private void field(int field, int type) { - varint((field << 3) | type); - } - - private void varint(long value) { - if (buf != null) { - if (buf.length - ptr < 10) - ensureSpace(varintSize(value)); - - do { - byte b = (byte) (value & 0x7f); - value >>>= 7; - if (value != 0) - b |= 0x80; - buf[ptr++] = b; - } while (value != 0); - } else { - ptr += varintSize(value); - } - } - - private static int varintSize(long value) { - value >>>= 7; - int need = 1; - for (; value != 0; value >>>= 7) - need++; - return need; - } - - private void copy(byte[] src, int off, int cnt) { - if (buf != null) { - ensureSpace(cnt); - System.arraycopy(src, off, buf, ptr, cnt); - } - ptr += cnt; - } - - private void ensureSpace(int need) { - if (buf.length - ptr < need) { - byte[] n = new byte[Math.max(ptr + need, buf.length * 2)]; - System.arraycopy(buf, 0, n, 0, ptr); - buf = n; - } - } - - /** @return size of the protocol buffer message, in bytes. */ - public int size() { - return ptr; - } - - /** @return the current buffer, as a byte array. */ - public byte[] asByteArray() { - if (ptr == buf.length) - return buf; - byte[] r = new byte[ptr]; - System.arraycopy(buf, 0, r, 0, ptr); - return r; - } - - /** @return the current buffer. */ - public ByteBuffer asByteBuffer() { - return ByteBuffer.wrap(buf, 0, ptr); - } - } - - private TinyProtobuf() { - // Don't make instances. - } -} diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/ChunkTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/ChunkTable.java index d5c5cc9ff..db0fded3f 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/ChunkTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/ChunkTable.java @@ -44,11 +44,12 @@ package org.eclipse.jgit.storage.dht.spi; import java.util.Collection; +import java.util.Map; import java.util.Set; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.storage.dht.AsyncCallback; import org.eclipse.jgit.storage.dht.ChunkKey; -import org.eclipse.jgit.storage.dht.ChunkMeta; import org.eclipse.jgit.storage.dht.DhtException; import org.eclipse.jgit.storage.dht.PackChunk; import org.eclipse.jgit.storage.dht.StreamingCallback; @@ -113,7 +114,7 @@ public void get(Context options, Set keys, * results early. */ public void getMeta(Context options, Set keys, - AsyncCallback> callback); + AsyncCallback> callback); /** * Put some (or all) of a single chunk. diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RefTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RefTable.java index 48171265c..b46ca0b5a 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RefTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RefTable.java @@ -46,8 +46,9 @@ import java.util.Map; import java.util.concurrent.TimeoutException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; import org.eclipse.jgit.storage.dht.DhtException; -import org.eclipse.jgit.storage.dht.RefData; +import org.eclipse.jgit.storage.dht.RefDataUtil; import org.eclipse.jgit.storage.dht.RefKey; import org.eclipse.jgit.storage.dht.RepositoryKey; @@ -100,8 +101,8 @@ public boolean compareAndRemove(RefKey refKey, RefData oldData) * @param oldData * the old data for the reference. The put only occurs if the * value is still equal to {@code oldData}. Use - * {@link RefData#NONE} if the reference should not exist and is - * being created. + * {@link RefDataUtil#NONE} if the reference should not exist and + * is being created. * @param newData * new value to store. * @return true if the put was successful; false if the current value does diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RepositoryTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RepositoryTable.java index 5921ca95c..8f2dab83e 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RepositoryTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/RepositoryTable.java @@ -46,7 +46,7 @@ import java.util.Collection; import java.util.concurrent.TimeoutException; -import org.eclipse.jgit.storage.dht.CachedPackInfo; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; import org.eclipse.jgit.storage.dht.CachedPackKey; import org.eclipse.jgit.storage.dht.ChunkInfo; import org.eclipse.jgit.storage.dht.ChunkKey; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheChunkTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheChunkTable.java index 22989cb93..b7f94fd6c 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheChunkTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheChunkTable.java @@ -44,29 +44,36 @@ package org.eclipse.jgit.storage.dht.spi.cache; import static java.util.Collections.singleton; +import static java.util.Collections.singletonMap; +import java.io.IOException; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Collection; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutorService; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.storage.dht.AsyncCallback; import org.eclipse.jgit.storage.dht.ChunkKey; -import org.eclipse.jgit.storage.dht.ChunkMeta; import org.eclipse.jgit.storage.dht.DhtException; import org.eclipse.jgit.storage.dht.PackChunk; import org.eclipse.jgit.storage.dht.StreamingCallback; import org.eclipse.jgit.storage.dht.Sync; -import org.eclipse.jgit.storage.dht.TinyProtobuf; import org.eclipse.jgit.storage.dht.spi.ChunkTable; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.cache.CacheService.Change; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.WireFormat; + /** Cache wrapper around ChunkTable. */ public class CacheChunkTable implements ChunkTable { private final ChunkTable db; @@ -105,7 +112,7 @@ public void get(Context options, Set keys, } public void getMeta(Context options, Set keys, - AsyncCallback> callback) { + AsyncCallback> callback) { List toFind = new ArrayList(keys.size()); for (ChunkKey k : keys) toFind.add(nsMeta.key(k)); @@ -118,8 +125,10 @@ public void put(PackChunk.Members chunk, WriteBuffer buffer) db.put(chunk, buf.getWriteBuffer()); // Only store fragmented meta. This is all callers should ask for. - if (chunk.hasMeta() && chunk.getMeta().getFragmentCount() != 0) - buf.put(nsMeta.key(chunk.getChunkKey()), chunk.getMeta().asBytes()); + if (chunk.hasMeta() && chunk.getMeta().getFragmentCount() != 0) { + buf.put(nsMeta.key(chunk.getChunkKey()), + chunk.getMeta().toByteArray()); + } if (chunk.hasChunkData()) buf.put(nsChunk.key(chunk.getChunkKey()), encode(chunk)); @@ -135,57 +144,99 @@ public void remove(ChunkKey key, WriteBuffer buffer) throws DhtException { } private static byte[] encode(PackChunk.Members members) { - final byte[] meta; - if (members.hasMeta()) - meta = members.getMeta().asBytes(); - else - meta = null; + // Its too slow to encode ByteBuffer through the standard code. + // Since the message is only 3 fields, do it by hand. + ByteBuffer data = members.getChunkDataAsByteBuffer(); + ByteBuffer index = members.getChunkIndexAsByteBuffer(); + ChunkMeta meta = members.getMeta(); - ByteBuffer chunkData = members.getChunkDataAsByteBuffer(); - ByteBuffer chunkIndex = members.getChunkIndexAsByteBuffer(); + int sz = 0; + if (data != null) + sz += computeByteBufferSize(1, data); + if (index != null) + sz += computeByteBufferSize(2, index); + if (meta != null) + sz += CodedOutputStream.computeMessageSize(3, meta); - TinyProtobuf.Encoder sizer = TinyProtobuf.size(); - TinyProtobuf.Encoder e = sizer; - do { - e.bytes(1, chunkData); - e.bytes(2, chunkIndex); - e.bytes(3, meta); - if (e == sizer) - e = TinyProtobuf.encode(e.size()); - else - return e.asByteArray(); - } while (true); + byte[] r = new byte[sz]; + CodedOutputStream out = CodedOutputStream.newInstance(r); + try { + if (data != null) + writeByteBuffer(out, 1, data); + if (index != null) + writeByteBuffer(out, 2, index); + if (meta != null) + out.writeMessage(3, meta); + } catch (IOException err) { + throw new RuntimeException("Cannot buffer chunk", err); + } + return r; + } + + private static int computeByteBufferSize(int fieldNumber, ByteBuffer data) { + int n = data.remaining(); + return CodedOutputStream.computeTagSize(fieldNumber) + + CodedOutputStream.computeRawVarint32Size(n) + + n; + } + + private static void writeByteBuffer(CodedOutputStream out, int fieldNumber, + ByteBuffer data) throws IOException { + byte[] d = data.array(); + int p = data.arrayOffset() + data.position(); + int n = data.remaining(); + out.writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); + out.writeRawVarint32(n); + out.writeRawBytes(d, p, n); } private static PackChunk.Members decode(ChunkKey key, byte[] raw) { PackChunk.Members members = new PackChunk.Members(); members.setChunkKey(key); - TinyProtobuf.Decoder d = TinyProtobuf.decode(raw); - for (;;) { - switch (d.next()) { - case 0: - return members; - case 1: { - int cnt = d.bytesLength(); - int ptr = d.bytesOffset(); - byte[] buf = d.bytesArray(); - members.setChunkData(buf, ptr, cnt); - continue; - } - case 2: { - int cnt = d.bytesLength(); - int ptr = d.bytesOffset(); - byte[] buf = d.bytesArray(); - members.setChunkIndex(buf, ptr, cnt); - continue; - } - case 3: - members.setMeta(ChunkMeta.fromBytes(key, d.message())); - continue; - default: - d.skip(); + // Its too slow to convert using the standard code, as copies + // are made. Instead find offsets in the stream and use that. + CodedInputStream in = CodedInputStream.newInstance(raw); + try { + int tag = in.readTag(); + for (;;) { + switch (WireFormat.getTagFieldNumber(tag)) { + case 0: + return members; + case 1: { + int cnt = in.readRawVarint32(); + int ptr = in.getTotalBytesRead(); + members.setChunkData(raw, ptr, cnt); + in.skipRawBytes(cnt); + tag = in.readTag(); + if (WireFormat.getTagFieldNumber(tag) != 2) + continue; + } + //$FALL-THROUGH$ + case 2: { + int cnt = in.readRawVarint32(); + int ptr = in.getTotalBytesRead(); + members.setChunkIndex(raw, ptr, cnt); + in.skipRawBytes(cnt); + tag = in.readTag(); + if (WireFormat.getTagFieldNumber(tag) != 3) + continue; + } + //$FALL-THROUGH$ + case 3: { + int cnt = in.readRawVarint32(); + int oldLimit = in.pushLimit(cnt); + members.setMeta(ChunkMeta.parseFrom(in)); + in.popLimit(oldLimit); + tag = in.readTag(); + continue; + } + default: + in.skipField(tag); + } } + } catch (IOException err) { + throw new RuntimeException("Cannot decode chunk", err); } } @@ -329,41 +380,49 @@ private class MetaFromCache implements private final Set remaining; - private final AsyncCallback> normalCallback; + private final AsyncCallback> normalCallback; - private final StreamingCallback> streamingCallback; + private final StreamingCallback> streamingCallback; - private final List all; + private final Map all; MetaFromCache(Context options, Set keys, - AsyncCallback> callback) { + AsyncCallback> callback) { this.options = options; this.remaining = new HashSet(keys); this.normalCallback = callback; if (callback instanceof StreamingCallback) { - streamingCallback = (StreamingCallback>) callback; + streamingCallback = (StreamingCallback>) callback; all = null; } else { streamingCallback = null; - all = new ArrayList(keys.size()); + all = new HashMap(); } } public void onPartialResult(Map result) { for (Map.Entry ent : result.entrySet()) { ChunkKey key = ChunkKey.fromBytes(ent.getKey().getBytes()); - ChunkMeta meta = ChunkMeta.fromBytes(key, ent.getValue()); + ChunkMeta meta; + try { + meta = ChunkMeta.parseFrom(ent.getValue()); + } catch (InvalidProtocolBufferException e) { + // Invalid meta message, remove the cell from cache. + client.modify(singleton(Change.remove(ent.getKey())), + Sync. none()); + continue; + } if (streamingCallback != null) { - streamingCallback.onPartialResult(singleton(meta)); + streamingCallback.onPartialResult(singletonMap(key, meta)); synchronized (lock) { remaining.remove(key); } } else { synchronized (lock) { - all.add(meta); + all.put(key, meta); remaining.remove(key); } } @@ -391,31 +450,31 @@ public void onFailure(DhtException error) { } private class MetaFromDatabase implements - StreamingCallback> { + StreamingCallback> { private final Object lock = new Object(); - private final List all; + private final Map all; - private final AsyncCallback> normalCallback; + private final AsyncCallback> normalCallback; - private final StreamingCallback> streamingCallback; + private final StreamingCallback> streamingCallback; - MetaFromDatabase(List all, - AsyncCallback> normalCallback, - StreamingCallback> streamingCallback) { + MetaFromDatabase(Map all, + AsyncCallback> normalCallback, + StreamingCallback> streamingCallback) { this.all = all; this.normalCallback = normalCallback; this.streamingCallback = streamingCallback; } - public void onPartialResult(Collection result) { - final List toPutIntoCache = copy(result); + public void onPartialResult(Map result) { + final Map toPutIntoCache = copy(result); if (streamingCallback != null) streamingCallback.onPartialResult(result); else { synchronized (lock) { - all.addAll(result); + all.putAll(result); } } @@ -425,20 +484,22 @@ public void onPartialResult(Collection result) { // executor.submit(new Runnable() { public void run() { - for (ChunkMeta meta : toPutIntoCache) { - ChunkKey key = meta.getChunkKey(); - Change op = Change.put(nsMeta.key(key), meta.asBytes()); + for (Map.Entry ent + : toPutIntoCache.entrySet()) { + ChunkKey key = ent.getKey(); + Change op = Change.put(nsMeta.key(key), + ent.getValue().toByteArray()); client.modify(singleton(op), none); } } }); } - private List copy(Collection result) { - return new ArrayList(result); + private Map copy(Map result) { + return new HashMap(result); } - public void onSuccess(Collection result) { + public void onSuccess(Map result) { if (result != null && !result.isEmpty()) onPartialResult(result); diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheObjectIndexTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheObjectIndexTable.java index 0438dc09e..0cd3549e0 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheObjectIndexTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheObjectIndexTable.java @@ -44,7 +44,9 @@ package org.eclipse.jgit.storage.dht.spi.cache; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -52,6 +54,7 @@ import java.util.Set; import java.util.concurrent.ExecutorService; +import org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex; import org.eclipse.jgit.storage.dht.AsyncCallback; import org.eclipse.jgit.storage.dht.ChunkKey; import org.eclipse.jgit.storage.dht.DhtException; @@ -59,12 +62,13 @@ import org.eclipse.jgit.storage.dht.ObjectInfo; import org.eclipse.jgit.storage.dht.StreamingCallback; import org.eclipse.jgit.storage.dht.Sync; -import org.eclipse.jgit.storage.dht.TinyProtobuf; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.ObjectIndexTable; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.cache.CacheService.Change; +import com.google.protobuf.InvalidProtocolBufferException; + /** Cache wrapper around ObjectIndexTable. */ public class CacheObjectIndexTable implements ObjectIndexTable { private final ObjectIndexTable db; @@ -125,58 +129,6 @@ public void remove(ObjectIndexKey objId, ChunkKey chunk, WriteBuffer buffer) buf.remove(ns.key(objId)); } - private static byte[] encode(Collection list) { - TinyProtobuf.Encoder e = TinyProtobuf.encode(128); - for (ObjectInfo info : list) { - TinyProtobuf.Encoder m = TinyProtobuf.encode(128); - m.bytes(1, info.getChunkKey().asBytes()); - m.bytes(2, info.asBytes()); - m.fixed64(3, info.getTime()); - e.message(1, m); - } - return e.asByteArray(); - } - - private static ObjectInfo decodeItem(TinyProtobuf.Decoder m) { - ChunkKey key = null; - TinyProtobuf.Decoder data = null; - long time = -1; - - for (;;) { - switch (m.next()) { - case 0: - return ObjectInfo.fromBytes(key, data, time); - case 1: - key = ChunkKey.fromBytes(m); - continue; - case 2: - data = m.message(); - continue; - case 3: - time = m.fixed64(); - continue; - default: - m.skip(); - } - } - } - - private static Collection decode(byte[] raw) { - List res = new ArrayList(1); - TinyProtobuf.Decoder d = TinyProtobuf.decode(raw); - for (;;) { - switch (d.next()) { - case 0: - return res; - case 1: - res.add(decodeItem(d.message())); - continue; - default: - d.skip(); - } - } - } - private class LoaderFromCache implements StreamingCallback> { private final Object lock = new Object(); @@ -217,7 +169,15 @@ public void onPartialResult(Map result) { for (Map.Entry e : result.entrySet()) { ObjectIndexKey objKey; - Collection list = decode(e.getValue()); + Collection list; + try { + list = decode(e.getValue()); + } catch (InvalidProtocolBufferException badCell) { + client.modify( + Collections.singleton(Change.remove(e.getKey())), + Sync. none()); + continue; + } objKey = ObjectIndexKey.fromBytes(e.getKey().getBytes()); if (tmp != null) @@ -238,6 +198,21 @@ public void onPartialResult(Map result) { } } + private Collection decode(byte[] value) + throws InvalidProtocolBufferException { + CachedObjectIndex cacheEntry = CachedObjectIndex.parseFrom(value); + int sz = cacheEntry.getItemCount(); + ObjectInfo[] r = new ObjectInfo[sz]; + for (int i = 0; i < sz; i++) { + CachedObjectIndex.Item item = cacheEntry.getItem(i); + r[i] = new ObjectInfo( + ChunkKey.fromString(item.getChunkKey()), + item.getTime(), + item.getObjectInfo()); + } + return Arrays.asList(r); + } + public void onSuccess(Map result) { if (result != null && !result.isEmpty()) onPartialResult(result); @@ -305,6 +280,19 @@ public void run() { client.modify(ops, Sync. none()); } + + private byte[] encode(List items) { + CachedObjectIndex.Builder b; + b = CachedObjectIndex.newBuilder(); + for (ObjectInfo info : items) { + CachedObjectIndex.Item.Builder i = b.addItemBuilder(); + i.setChunkKey(info.getChunkKey().asString()); + i.setObjectInfo(info.getData()); + if (0 < info.getTime()) + i.setTime(info.getTime()); + } + return b.build().toByteArray(); + } }); } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRefTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRefTable.java index 5edb49edd..2b6c8dac3 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRefTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRefTable.java @@ -46,8 +46,8 @@ import java.util.Map; import java.util.concurrent.TimeoutException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; import org.eclipse.jgit.storage.dht.DhtException; -import org.eclipse.jgit.storage.dht.RefData; import org.eclipse.jgit.storage.dht.RefKey; import org.eclipse.jgit.storage.dht.RepositoryKey; import org.eclipse.jgit.storage.dht.spi.Context; diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRepositoryTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRepositoryTable.java index b71c24262..a378e0a8b 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRepositoryTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/cache/CacheRepositoryTable.java @@ -46,24 +46,24 @@ import static java.util.Collections.emptyMap; import static java.util.Collections.singleton; -import java.util.ArrayList; import java.util.Collection; -import java.util.List; import java.util.Map; import java.util.concurrent.TimeoutException; -import org.eclipse.jgit.storage.dht.CachedPackInfo; +import org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedPackInfoList; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; import org.eclipse.jgit.storage.dht.CachedPackKey; import org.eclipse.jgit.storage.dht.ChunkInfo; import org.eclipse.jgit.storage.dht.ChunkKey; import org.eclipse.jgit.storage.dht.DhtException; import org.eclipse.jgit.storage.dht.RepositoryKey; import org.eclipse.jgit.storage.dht.Sync; -import org.eclipse.jgit.storage.dht.TinyProtobuf; import org.eclipse.jgit.storage.dht.spi.RepositoryTable; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.cache.CacheService.Change; +import com.google.protobuf.InvalidProtocolBufferException; + /** Cache wrapper around RepositoryTable. */ public class CacheRepositoryTable implements RepositoryTable { private final RepositoryTable db; @@ -126,26 +126,20 @@ public Collection getCachedPacks(RepositoryKey repo) byte[] data = result.get(memKey); if (data != null) { - List r = new ArrayList(); - TinyProtobuf.Decoder d = TinyProtobuf.decode(data); - for (;;) { - switch (d.next()) { - case 0: - return r; - case 1: - r.add(CachedPackInfo.fromBytes(d.message())); - continue; - default: - d.skip(); - } + try { + return CachedPackInfoList.parseFrom(data).getPackList(); + } catch (InvalidProtocolBufferException e) { + // Invalidate the cache entry and fall through. + client.modify(singleton(Change.remove(memKey)), none); } } Collection r = db.getCachedPacks(repo); - TinyProtobuf.Encoder e = TinyProtobuf.encode(1024); - for (CachedPackInfo info : r) - e.bytes(1, info.asBytes()); - client.modify(singleton(Change.put(memKey, e.asByteArray())), none); + CachedPackInfoList.Builder list = CachedPackInfoList.newBuilder(); + list.addAllPack(r); + client.modify( + singleton(Change.put(memKey, list.build().toByteArray())), + none); return r; } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemChunkTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemChunkTable.java index 8a04dbb6d..277b2b83a 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemChunkTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemChunkTable.java @@ -43,21 +43,27 @@ package org.eclipse.jgit.storage.dht.spi.memory; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Set; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta; import org.eclipse.jgit.storage.dht.AsyncCallback; import org.eclipse.jgit.storage.dht.ChunkKey; -import org.eclipse.jgit.storage.dht.ChunkMeta; import org.eclipse.jgit.storage.dht.DhtException; +import org.eclipse.jgit.storage.dht.DhtText; import org.eclipse.jgit.storage.dht.PackChunk; import org.eclipse.jgit.storage.dht.spi.ChunkTable; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.util.ColumnMatcher; +import com.google.protobuf.InvalidProtocolBufferException; + final class MemChunkTable implements ChunkTable { private final MemTable table = new MemTable(); @@ -89,8 +95,15 @@ public void get(Context options, Set keys, m.setChunkIndex(cell.getValue()); cell = table.get(row, colMeta.name()); - if (cell != null) - m.setMeta(ChunkMeta.fromBytes(chunk, cell.getValue())); + if (cell != null) { + try { + m.setMeta(ChunkMeta.parseFrom(cell.getValue())); + } catch (InvalidProtocolBufferException err) { + callback.onFailure(new DhtException(MessageFormat.format( + DhtText.get().invalidChunkMeta, chunk), err)); + return; + } + } out.add(m); } @@ -99,15 +112,21 @@ public void get(Context options, Set keys, } public void getMeta(Context options, Set keys, - AsyncCallback> callback) { - int cnt = keys.size(); - List out = new ArrayList(cnt); + AsyncCallback> callback) { + Map out = new HashMap(); for (ChunkKey chunk : keys) { byte[] row = chunk.asBytes(); MemTable.Cell cell = table.get(row, colMeta.name()); - if (cell != null) - out.add(ChunkMeta.fromBytes(chunk, cell.getValue())); + if (cell != null) { + try { + out.put(chunk, ChunkMeta.parseFrom(cell.getValue())); + } catch (InvalidProtocolBufferException err) { + callback.onFailure(new DhtException(MessageFormat.format( + DhtText.get().invalidChunkMeta, chunk), err)); + return; + } + } } callback.onSuccess(out); @@ -124,7 +143,7 @@ public void put(PackChunk.Members chunk, WriteBuffer buffer) table.put(row, colIndex.name(), chunk.getChunkIndex()); if (chunk.hasMeta()) - table.put(row, colMeta.name(), chunk.getMeta().asBytes()); + table.put(row, colMeta.name(), chunk.getMeta().toByteArray()); } public void remove(ChunkKey key, WriteBuffer buffer) throws DhtException { diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemObjectIndexTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemObjectIndexTable.java index e6f4f7aca..e3bb7fdd1 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemObjectIndexTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemObjectIndexTable.java @@ -43,15 +43,18 @@ package org.eclipse.jgit.storage.dht.spi.memory; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore; import org.eclipse.jgit.storage.dht.AsyncCallback; import org.eclipse.jgit.storage.dht.ChunkKey; import org.eclipse.jgit.storage.dht.DhtException; +import org.eclipse.jgit.storage.dht.DhtText; import org.eclipse.jgit.storage.dht.ObjectIndexKey; import org.eclipse.jgit.storage.dht.ObjectInfo; import org.eclipse.jgit.storage.dht.spi.Context; @@ -59,6 +62,8 @@ import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.util.ColumnMatcher; +import com.google.protobuf.InvalidProtocolBufferException; + final class MemObjectIndexTable implements ObjectIndexTable { private final MemTable table = new MemTable(); @@ -70,17 +75,25 @@ public void get(Context options, Set objects, for (ObjectIndexKey objId : objects) { for (MemTable.Cell cell : table.scanFamily(objId.asBytes(), colInfo)) { - Collection info = out.get(objId); - if (info == null) { - info = new ArrayList(4); - out.put(objId, info); + Collection chunks = out.get(objId); + ChunkKey chunkKey; + if (chunks == null) { + chunks = new ArrayList(4); + out.put(objId, chunks); } - ChunkKey chunk = ChunkKey.fromBytes( - colInfo.suffix(cell.getName())); - byte[] value = cell.getValue(); - long time = cell.getTimestamp(); - info.add(ObjectInfo.fromBytes(chunk, value, time)); + chunkKey = ChunkKey.fromBytes(colInfo.suffix(cell.getName())); + try { + chunks.add(new ObjectInfo( + chunkKey, + cell.getTimestamp(), + GitStore.ObjectInfo.parseFrom(cell.getValue()))); + } catch (InvalidProtocolBufferException badCell) { + callback.onFailure(new DhtException(MessageFormat.format( + DhtText.get().invalidObjectInfo, objId, chunkKey), + badCell)); + return; + } } } @@ -91,7 +104,7 @@ public void add(ObjectIndexKey objId, ObjectInfo info, WriteBuffer buffer) throws DhtException { ChunkKey chunk = info.getChunkKey(); table.put(objId.asBytes(), colInfo.append(chunk.asBytes()), - info.asBytes()); + info.getData().toByteArray()); } public void remove(ObjectIndexKey objId, ChunkKey chunk, WriteBuffer buffer) diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRefTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRefTable.java index 6c41f20c4..595e3fdd7 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRefTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRefTable.java @@ -43,18 +43,23 @@ package org.eclipse.jgit.storage.dht.spi.memory; +import java.text.MessageFormat; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeoutException; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.RefData; import org.eclipse.jgit.storage.dht.DhtException; -import org.eclipse.jgit.storage.dht.RefData; +import org.eclipse.jgit.storage.dht.DhtText; +import org.eclipse.jgit.storage.dht.RefDataUtil; import org.eclipse.jgit.storage.dht.RefKey; import org.eclipse.jgit.storage.dht.RepositoryKey; import org.eclipse.jgit.storage.dht.spi.Context; import org.eclipse.jgit.storage.dht.spi.RefTable; import org.eclipse.jgit.storage.dht.spi.util.ColumnMatcher; +import com.google.protobuf.InvalidProtocolBufferException; + final class MemRefTable implements RefTable { private final MemTable table = new MemTable(); @@ -65,8 +70,12 @@ public Map getAll(Context options, RepositoryKey repository) Map out = new HashMap(); for (MemTable.Cell cell : table.scanFamily(repository.asBytes(), colRef)) { RefKey ref = RefKey.fromBytes(colRef.suffix(cell.getName())); - RefData val = RefData.fromBytes(cell.getValue()); - out.put(ref, val); + try { + out.put(ref, RefData.parseFrom(cell.getValue())); + } catch (InvalidProtocolBufferException badCell) { + throw new DhtException(MessageFormat.format( + DhtText.get().invalidRefData, ref), badCell); + } } return out; } @@ -77,8 +86,8 @@ public boolean compareAndPut(RefKey refKey, RefData oldData, RefData newData) return table.compareAndSet( // repo.asBytes(), // colRef.append(refKey.asBytes()), // - oldData != RefData.NONE ? oldData.asBytes() : null, // - newData.asBytes()); + oldData != RefDataUtil.NONE ? oldData.toByteArray() : null, // + newData.toByteArray()); } public boolean compareAndRemove(RefKey refKey, RefData oldData) @@ -87,7 +96,7 @@ public boolean compareAndRemove(RefKey refKey, RefData oldData) return table.compareAndSet( // repo.asBytes(), // colRef.append(refKey.asBytes()), // - oldData != RefData.NONE ? oldData.asBytes() : null, // + oldData != RefDataUtil.NONE ? oldData.toByteArray() : null, // null); } } diff --git a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRepositoryTable.java b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRepositoryTable.java index 01e90de3b..d393934a2 100644 --- a/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRepositoryTable.java +++ b/org.eclipse.jgit.storage.dht/src/org/eclipse/jgit/storage/dht/spi/memory/MemRepositoryTable.java @@ -43,22 +43,26 @@ package org.eclipse.jgit.storage.dht.spi.memory; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicInteger; -import org.eclipse.jgit.storage.dht.CachedPackInfo; +import org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo; import org.eclipse.jgit.storage.dht.CachedPackKey; import org.eclipse.jgit.storage.dht.ChunkInfo; import org.eclipse.jgit.storage.dht.ChunkKey; import org.eclipse.jgit.storage.dht.DhtException; +import org.eclipse.jgit.storage.dht.DhtText; import org.eclipse.jgit.storage.dht.RepositoryKey; import org.eclipse.jgit.storage.dht.spi.RepositoryTable; import org.eclipse.jgit.storage.dht.spi.WriteBuffer; import org.eclipse.jgit.storage.dht.spi.util.ColumnMatcher; +import com.google.protobuf.InvalidProtocolBufferException; + final class MemRepositoryTable implements RepositoryTable { private final AtomicInteger nextId = new AtomicInteger(); @@ -76,7 +80,7 @@ public void put(RepositoryKey repo, ChunkInfo info, WriteBuffer buffer) throws DhtException { table.put(repo.asBytes(), colChunkInfo.append(info.getChunkKey().asBytes()), - info.asBytes()); + info.getData().toByteArray()); } public void remove(RepositoryKey repo, ChunkKey chunk, WriteBuffer buffer) @@ -87,16 +91,24 @@ public void remove(RepositoryKey repo, ChunkKey chunk, WriteBuffer buffer) public Collection getCachedPacks(RepositoryKey repo) throws DhtException, TimeoutException { List out = new ArrayList(4); - for (MemTable.Cell cell : table.scanFamily(repo.asBytes(), colCachedPack)) - out.add(CachedPackInfo.fromBytes(cell.getValue())); + for (MemTable.Cell cell : table.scanFamily(repo.asBytes(), colCachedPack)) { + try { + out.add(CachedPackInfo.parseFrom(cell.getValue())); + } catch (InvalidProtocolBufferException e) { + throw new DhtException(MessageFormat.format( + DhtText.get().invalidCachedPackInfo, repo, + CachedPackKey.fromBytes(cell.getName())), e); + } + } return out; } public void put(RepositoryKey repo, CachedPackInfo info, WriteBuffer buffer) throws DhtException { + CachedPackKey key = CachedPackKey.fromInfo(info); table.put(repo.asBytes(), - colCachedPack.append(info.getRowKey().asBytes()), - info.asBytes()); + colCachedPack.append(key.asBytes()), + info.toByteArray()); } public void remove(RepositoryKey repo, CachedPackKey key, WriteBuffer buffer) diff --git a/pom.xml b/pom.xml index 76c0dbe4a..7717c66e7 100644 --- a/pom.xml +++ b/pom.xml @@ -135,6 +135,7 @@ 2.0.12 2.5 7.1.6.v20100715 + 2.4.0a @@ -348,6 +349,12 @@ jetty-servlet ${jetty-version} + + + com.google.protobuf + protobuf-java + ${protobuf-version} + @@ -392,6 +399,7 @@ org.eclipse.jgit + org.eclipse.jgit.generated.storage.dht.proto org.eclipse.jgit.storage.dht org.eclipse.jgit.ant org.eclipse.jgit.ui