diff options
58 files changed, 12217 insertions, 2406 deletions
diff --git a/.eclipse_iplog b/.eclipse_iplog index 2f518e1235..8707214f73 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 0000000000..304e86186a --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.classpath @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="src"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> + <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/> + <classpathentry kind="output" path="bin"/> +</classpath> 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 0000000000..934e0e06ff --- /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 0000000000..22e79eede9 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/.project @@ -0,0 +1,28 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>org.eclipse.jgit.generated.storage.dht.proto</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.ManifestBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.SchemaBuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + <nature>org.eclipse.pde.PluginNature</nature> + </natures> +</projectDescription> 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 0000000000..66ac15c47c --- /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/<project>=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 0000000000..006e07ede5 --- /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 0000000000..5bf6764486 --- /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 0000000000..7b2cdca106 --- /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=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><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 0000000000..f3d2266c6f --- /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 0000000000..aa1a008269 --- /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 0000000000..f80989503f --- /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 0000000000..a9959ca8fa --- /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 0000000000..60942d4341 --- /dev/null +++ b/org.eclipse.jgit.generated.storage.dht.proto/pom.xml @@ -0,0 +1,120 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + 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. +--> + +<project xmlns="http://maven.apache.org/POM/4.0.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.eclipse.jgit</groupId> + <artifactId>org.eclipse.jgit-parent</artifactId> + <version>1.0.0-SNAPSHOT</version> + </parent> + + <artifactId>org.eclipse.jgit.generated.storage.dht.proto</artifactId> + <name>JGit - DHT Storage Protocol Buffer Messages</name> + + <description> + Compiled protocol buffer messages for DHT storage + </description> + + <properties> + <translate-qualifier/> + </properties> + + <dependencies> + <dependency> + <groupId>com.google.protobuf</groupId> + <artifactId>protobuf-java</artifactId> + </dependency> + </dependencies> + + <build> + <sourceDirectory>src/</sourceDirectory> + + <resources> + <resource> + <directory>.</directory> + <includes> + <include>plugin.properties</include> + </includes> + </resource> + <resource> + <directory>resources/</directory> + </resource> + </resources> + + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-source-plugin</artifactId> + <inherited>true</inherited> + <executions> + <execution> + <id>attach-sources</id> + <phase>process-classes</phase> + <goals> + <goal>jar</goal> + </goals> + <configuration> + <archive> + <manifestFile>${source-bundle-manifest}</manifestFile> + </archive> + </configuration> + </execution> + </executions> + </plugin> + + <plugin> + <artifactId>maven-jar-plugin</artifactId> + <configuration> + <archive> + <manifestFile>${bundle-manifest}</manifestFile> + </archive> + </configuration> + </plugin> + </plugins> + </build> +</project> 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 0000000000..40a2efd433 --- /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 index d6674055a1..78ad4f2bb9 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 0000000000..d9bba52e31 --- /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<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> + getItemList(); + org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item getItem(int index); + int getItemCount(); + java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder> + 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<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<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> item_; + public java.util.List<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> getItemList() { + return item_; + } + public java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder> + 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<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<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> item_ = + java.util.Collections.emptyList(); + private void ensureItemIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + item_ = new java.util.ArrayList<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item>(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<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.ItemOrBuilder> + 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<org.eclipse.jgit.generated.storage.dht.proto.GitCache.CachedObjectIndex.Item.Builder> + 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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> + getPackList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo getPack(int index); + int getPackCount(); + java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder> + 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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> pack_; + public java.util.List<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> getPackList() { + return pack_; + } + public java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder> + 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<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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> pack_ = + java.util.Collections.emptyList(); + private void ensurePackIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + pack_ = new java.util.ArrayList<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo>(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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfoOrBuilder> + 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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.CachedPackInfo.Builder> + 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<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 0000000000..86a2ffc0ed --- /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<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<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<ObjectType> + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap<ObjectType> + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<ObjectType>() { + 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<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<Source> + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap<Source> + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<Source>() { + 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<ObjectType> + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap<ObjectType> + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap<ObjectType>() { + 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<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<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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> + getBaseChunkList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk getBaseChunk(int index); + int getBaseChunkCount(); + java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder> + getBaseChunkOrBuilderList(); + org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder getBaseChunkOrBuilder( + int index); + + // repeated string fragment = 2; + java.util.List<String> 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<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<String> getEdgeList(); + int getEdgeCount(); + String getEdge(int index); + + // repeated string sequential = 2; + java.util.List<String> 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<String> + 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<String> + 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<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<String> + 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<String> 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<String> + 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<String> 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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> baseChunk_; + public java.util.List<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> getBaseChunkList() { + return baseChunk_; + } + public java.util.List<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder> + 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<String> + 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<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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> baseChunk_ = + java.util.Collections.emptyList(); + private void ensureBaseChunkIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + baseChunk_ = new java.util.ArrayList<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk>(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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk> 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<? extends org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunkOrBuilder> + 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<org.eclipse.jgit.generated.storage.dht.proto.GitStore.ChunkMeta.BaseChunk.Builder> + 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<String> + 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<String> 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<String> 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<String> + 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<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<String> + 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<String> 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<String> 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<String> + 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<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<String> + 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<String> 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<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 10bc4867c6..42a035a4f6 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 c9fe599b50..e2340ab7a7 100644 --- a/org.eclipse.jgit.storage.dht/pom.xml +++ b/org.eclipse.jgit.storage.dht/pom.xml @@ -70,6 +70,12 @@ <artifactId>org.eclipse.jgit</artifactId> <version>${project.version}</version> </dependency> + + <dependency> + <groupId>org.eclipse.jgit</groupId> + <artifactId>org.eclipse.jgit.generated.storage.dht.proto</artifactId> + <version>${project.version}</version> + </dependency> </dependencies> <build> 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 c004fda7ac..d53147abf6 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 95a5857f1a..0000000000 --- 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<ObjectId> tips = new TreeSet<ObjectId>(); - - long objectsTotal; - - long objectsDelta; - - long bytesTotal; - - List<ChunkKey> chunks = new ArrayList<ChunkKey>(); - - /** @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<ChunkKey> 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 0fc14f9e23..274cc68d87 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 static org.eclipse.jgit.util.RawParseUtils.decode; 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. */ @@ -62,18 +63,6 @@ public final class CachedPackKey implements RowKey { } /** - * @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 * @param len @@ -100,6 +89,16 @@ public final class CachedPackKey implements RowKey { 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 27c520bc9c..011cfb06ec 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.List; 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<ChunkKey, BaseChunkInfo> 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 @@ class ChunkFormatter { } ChunkInfo getChunkInfo() { - return info; + return chunkInfo; } ChunkMeta getChunkMeta() { @@ -150,37 +161,58 @@ class ChunkFormatter { 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<BaseChunk>(baseChunks.size()); + List<BaseChunk> list = new ArrayList<BaseChunk>(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<BaseChunk>() { + Collections.sort(list, new Comparator<BaseChunk>() { 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 @@ class ChunkFormatter { 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 @@ class ChunkFormatter { } 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 @@ class ChunkFormatter { 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 @@ class ChunkFormatter { 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 @@ class ChunkFormatter { 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 @@ class ChunkFormatter { } 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 @@ class ChunkFormatter { } int getObjectCount() { - return info.objectsTotal; + return objectsTotal; } int position() { @@ -374,32 +406,32 @@ class ChunkFormatter { } 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 @@ class ChunkFormatter { } 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 5282a1d4ee..2c156c8a68 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; - } - - 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(); + public ChunkInfo(ChunkKey key, GitStore.ChunkInfo data) { + this.chunkKey = key; + this.data = data; } - 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 class ChunkInfo { 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 class ChunkInfo { 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 e136df268a..272b5ea173 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 @@ -74,18 +74,6 @@ public final class ChunkKey implements RowKey { } /** - * @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 * @param len 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 a02382b5c0..0000000000 --- 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> baseChunk = null; - List<ChunkKey> 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<BaseChunk>(4); - baseChunk.add(BaseChunk.fromBytes(d.message())); - continue; - case 2: - if (fragment == null) - fragment = new ArrayList<ChunkKey>(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<BaseChunk> baseChunks; - - List<ChunkKey> fragments; - - PrefetchHint commitPrefetch; - - PrefetchHint treePrefetch; - - ChunkMeta(ChunkKey key) { - this(key, null, null, null, null); - } - - ChunkMeta(ChunkKey chunkKey, List<BaseChunk> baseChunk, - List<ChunkKey> 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<ChunkKey> edge; - - private final List<ChunkKey> sequential; - - PrefetchHint(List<ChunkKey> edge, List<ChunkKey> 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<ChunkKey> getEdge() { - return edge; - } - - /** @return chunks according to sequential ordering. */ - public List<ChunkKey> 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<ChunkKey> edge = null; - ArrayList<ChunkKey> sequential = null; - - PARSE: for (;;) { - switch (d.next()) { - case 0: - break PARSE; - case 1: - if (edge == null) - edge = new ArrayList<ChunkKey>(16); - edge.add(ChunkKey.fromBytes(d)); - continue; - case 2: - if (sequential == null) - sequential = new ArrayList<ChunkKey>(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 0000000000..7bc6439172 --- /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<BaseChunk> 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 13af792e0e..39a76463fb 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 @@ package org.eclipse.jgit.storage.dht; 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 @@ import org.eclipse.jgit.storage.pack.StoredObjectRepresentation; public class DhtCachedPack extends CachedPack { private final CachedPackInfo info; - private Set<ChunkKey> chunkKeySet; + private Set<ObjectId> tips; + + private Set<ChunkKey> keySet; + + private ChunkKey[] keyList; DhtCachedPack(CachedPackInfo info) { this.info = info; @@ -69,7 +77,13 @@ public class DhtCachedPack extends CachedPack { @Override public Set<ObjectId> getTips() { - return Collections.unmodifiableSet(info.tips); + if (tips == null) { + tips = new HashSet<ObjectId>(); + for (String idString : info.getTipList().getObjectNameList()) + tips.add(ObjectId.fromString(idString)); + tips = Collections.unmodifiableSet(tips); + } + return tips; } @Override @@ -90,23 +104,37 @@ public class DhtCachedPack extends CachedPack { @Override public boolean hasObject(ObjectToPack obj, StoredObjectRepresentation rep) { DhtObjectRepresentation objrep = (DhtObjectRepresentation) rep; - if (chunkKeySet == null) - chunkKeySet = new HashSet<ChunkKey>(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<ChunkKey>(); + 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<ChunkKey, Long> startsAt = new HashMap<ChunkKey, Long>(); - for (ChunkKey key : info.chunks) { + private void copyPack(PackOutputStream out, Prefetcher prefetcher, + boolean validate) throws DhtException, DhtMissingChunkException, + IOException { + Map<String, Long> startsAt = new HashMap<String, Long>(); + for (ChunkKey key : keyList) { PackChunk chunk = prefetcher.get(key); // The prefetcher should always produce the chunk for us, if not @@ -122,29 +150,34 @@ public class DhtCachedPack extends CachedPack { // 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 997f4b4d21..4ae4cf58ed 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.Collections; 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 @@ class DhtInserter extends ObjectInserter { 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 @@ class DhtInserter extends ObjectInserter { 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 @@ class DhtInserter extends ObjectInserter { 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 @@ class DhtInserter extends ObjectInserter { // 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 @@ class DhtInserter extends ObjectInserter { 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 b1b1b5c5f8..56b323bd2b 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 static org.eclipse.jgit.lib.Constants.OBJECT_ID_LENGTH; 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 a5499254e5..f6d55c1a49 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 @@ final class DhtObjectRepresentation extends StoredObjectRepresentation { @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 86078335d3..fdc143621c 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.LinkedList; 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.transport.PackedObjectInfo; 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<ChunkInfo>[] infoByOrder; + private List<ChunkKey>[] chunkByOrder; /** Information on chunks already written out. */ private Map<ChunkKey, ChunkInfo> 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<ChunkKey, ChunkInfo>(); dirtyMeta = new HashMap<ChunkKey, ChunkMeta>(); chunkMeta = new HashMap<ChunkKey, ChunkMeta>(); @@ -306,7 +311,7 @@ public class DhtPackParser extends PackParser { if (!success) rollback(); - infoByOrder = null; + chunkByOrder = null; objectListByName = null; objectListByChunk = null; linkIterators = null; @@ -332,54 +337,74 @@ public class DhtPackParser extends PackParser { } 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<ChunkInfo> list : infoByOrder) { + cachedPackKey = CachedPackKey.fromInfo(info.build()); + for (List<ChunkKey> 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<ChunkInfo> list) { + private void addChunkList(CachedPackInfo.Builder info, + MessageDigest version, List<ChunkKey> 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 @@ public class DhtPackParser extends PackParser { } } - 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 @@ public class DhtPackParser extends PackParser { } } - private void deleteChunks(List<ChunkInfo> list) throws DhtException { + private void deleteChunks(List<ChunkKey> 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 @@ public class DhtPackParser extends PackParser { private void putChunkIndex(List<DhtInfo> 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<ChunkKey> e = edges.commitEdges; - List<ChunkKey> s = sequentialHint(key, OBJ_COMMIT); - meta.commitPrefetch = new ChunkMeta.PrefetchHint(e, s); + List<ChunkKey> e = edges != null ? edges.commitEdges : null; + List<ChunkKey> 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<ChunkKey> 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<ChunkKey> sequentialHint(ChunkKey key, int typeCode) { - List<ChunkInfo> infoList = infoByOrder[typeCode]; - if (infoList == null) + List<ChunkKey> all = chunkByOrder[typeCode]; + if (all == null) return null; - - List<ChunkKey> all = new ArrayList<ChunkKey>(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 @@ public class DhtPackParser extends PackParser { } private void putDirtyMeta() throws DhtException { - for (ChunkMeta meta : dirtyMeta.values()) { + for (Map.Entry<ChunkKey, ChunkMeta> 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 @@ public class DhtPackParser extends PackParser { private boolean longOfsDelta(ChunkFormatter w, long infSize, long basePtr) { final int type = typeOf(basePtr); - final List<ChunkInfo> infoList = infoByOrder[type]; + final List<ChunkKey> 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 @@ public class DhtPackParser extends PackParser { 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 @@ public class DhtPackParser extends PackParser { 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 @@ public class DhtPackParser extends PackParser { 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 @@ public class DhtPackParser extends PackParser { ChunkKey key = w.end(chunkKeyDigest); ChunkInfo info = w.getChunkInfo(); - if (infoByOrder[typeCode] == null) - infoByOrder[typeCode] = new ArrayList<ChunkInfo>(); - infoByOrder[typeCode].add(info); + if (chunkByOrder[typeCode] == null) + chunkByOrder[typeCode] = new ArrayList<ChunkKey>(); + chunkByOrder[typeCode].add(key); infoByKey.put(key, info); if (w.getChunkMeta() != null) @@ -1260,7 +1311,7 @@ public class DhtPackParser extends PackParser { } private long makeObjectPointer(ChunkFormatter w, int typeCode) { - List<ChunkInfo> list = infoByOrder[typeCode]; + List<ChunkKey> 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 @@ public class DhtPackParser extends PackParser { } private boolean isInCurrentChunk(long objectPtr) { - List<ChunkInfo> list = infoByOrder[typeOf(objectPtr)]; + List<ChunkKey> list = chunkByOrder[typeOf(objectPtr)]; if (list == null) return chunkIdx(objectPtr) == 0; return chunkIdx(objectPtr) == list.size(); } private ChunkKey chunkOf(long objectPtr) throws DhtException { - List<ChunkInfo> list = infoByOrder[typeOf(objectPtr)]; + List<ChunkKey> list = chunkByOrder[typeOf(objectPtr)]; int idx = chunkIdx(objectPtr); if (list == null || list.size() <= idx) { throw new DhtException(MessageFormat.format( @@ -1295,7 +1346,7 @@ public class DhtPackParser extends PackParser { Integer.valueOf(idx), // Integer.valueOf(offsetOf(objectPtr)))); } - return list.get(idx).getChunkKey(); + return list.get(idx); } private static DhtException panicCannotInsert() { @@ -1349,8 +1400,19 @@ public class DhtPackParser extends PackParser { } 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 05438ab8dd..f9288b9e2e 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 java.util.zip.Inflater; 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.ObjectWalk; 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 class DhtReader extends ObjectReader implements ObjectReuseAsIs { @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 @@ public class DhtReader extends ObjectReader implements ObjectReuseAsIs { } 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 @@ public class DhtReader extends ObjectReader implements ObjectReuseAsIs { } 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 22569b91ee..ef6123a539 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.TimeoutException; 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.lib.SymbolicRef; 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 @@ public class DhtRefDatabase extends RefDatabase { 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 @@ public class DhtRefDatabase extends RefDatabase { 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 @@ public class DhtRefDatabase extends RefDatabase { 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 @@ public class DhtRefDatabase extends RefDatabase { private RefCache read() throws DhtException, TimeoutException { RefList.Builder<Ref> id = new RefList.Builder<Ref>(); RefList.Builder<Ref> sym = new RefList.Builder<Ref>(); - ObjectIdSubclassMap<RefData.IdWithChunk> hints = new ObjectIdSubclassMap<RefData.IdWithChunk>(); + ObjectIdSubclassMap<IdWithChunk> hints = new ObjectIdSubclassMap<IdWithChunk>(); for (Map.Entry<RefKey, RefData> e : scan()) { Ref ref = fromData(e.getKey().getName(), e.getValue()); @@ -362,12 +363,12 @@ public class DhtRefDatabase extends RefDatabase { 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 @@ public class DhtRefDatabase extends RefDatabase { } 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 @@ public class DhtRefDatabase extends RefDatabase { final RefList<Ref> sym; - final ObjectIdSubclassMap<RefData.IdWithChunk> hints; + final ObjectIdSubclassMap<IdWithChunk> hints; RefCache(RefList<Ref> ids, RefList<Ref> sym, - ObjectIdSubclassMap<RefData.IdWithChunk> hints) { + ObjectIdSubclassMap<IdWithChunk> 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 158b7cf496..f131e2d741 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.io.IOException; 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 @@ class DhtRefUpdate extends RefUpdate { 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 @@ class DhtRefUpdate extends RefUpdate { @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 @@ class DhtRefUpdate extends RefUpdate { 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 3c35ad6df3..4fb520be15 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 class DhtText extends TranslationBundle { /***/ 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 class DhtText extends TranslationBundle { /***/ 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 aaef431c73..e6afd731fe 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 java.util.zip.InflaterInputStream; 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 @@ class LargeNonDeltaObject extends ObjectLoader { 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 @@ class LargeNonDeltaObject extends ObjectLoader { 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 941ed6a6d1..9123a8be8f 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 class ObjectInfo { 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 class ObjectInfo { 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 class ObjectInfo { 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 17e36ab99a..d36b03bdb5 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.Set; 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 @@ final class ObjectWriter { 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 @@ final class ObjectWriter { throw metaError.get(); } - private class MetaLoader implements AsyncCallback<Collection<ChunkMeta>> { + private class MetaLoader implements AsyncCallback<Map<ChunkKey, ChunkMeta>> { private final Context context; private final Set<ChunkKey> keys; @@ -231,13 +231,11 @@ final class ObjectWriter { this.keys = keys; } - public void onSuccess(Collection<ChunkMeta> result) { + public void onSuccess(Map<ChunkKey, ChunkMeta> 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 c3bedc4ae1..c0684022f3 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 java.util.zip.Inflater; 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 final class PackChunk { 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 @@ public final class PackChunk { 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 @@ public final class PackChunk { 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 @@ public final class PackChunk { 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 @@ public final class PackChunk { 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 @@ public final class PackChunk { 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 b7463db3f9..743f1f5944 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.Set; 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 @@ class Prefetcher implements StreamingCallback<Collection<PackChunk.Members>> { 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<String> list) { + List<ChunkKey> keys = new ArrayList<ChunkKey>(list.size()); + for (String keyString : list) + keys.add(ChunkKey.fromString(keyString)); + push(keys); + } + void push(Iterable<ChunkKey> 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 482caf8917..9cf513d265 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 java.util.Map; 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 @@ class QueueObjectLookup<T extends ObjectId> implements AsyncOperation { RecentInfoCache infoCache = reader.getRecentInfoCache(); List<T> 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 f704c1daf5..f75e3bdc82 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 java.io.IOException; 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 e34e9d1c34..0000000000 --- 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. - * <p> - * 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 0000000000..7c5d9e0b8c --- /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 dcf3dfb172..0000000000 --- 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. - * <p> - * For more information on the network format, see the canonical documentation - * at <a href="http://code.google.com/p/protobuf/">Google Protocol Buffers</a>. - */ -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 <T> - * the type of enumeration. - * @param all - * all of the supported values. - * @return decode the current field as an enumerated value. - */ - public <T extends Enum> 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 <T> - * type of the enumerated values. - * @param field - * field tag number. - * @param value - * value to store; if null the field is omitted. - */ - public <T extends Enum> 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 d5c5cc9ff7..db0fded3f2 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 interface ChunkTable { * results early. */ public void getMeta(Context options, Set<ChunkKey> keys, - AsyncCallback<Collection<ChunkMeta>> callback); + AsyncCallback<Map<ChunkKey, ChunkMeta>> 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 48171265c1..b46ca0b5a6 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 @@ package org.eclipse.jgit.storage.dht.spi; 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 interface RefTable { * @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 5921ca95c1..8f2dab83ed 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 @@ package org.eclipse.jgit.storage.dht.spi; 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 22989cb93f..b7f94fd6c8 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 class CacheChunkTable implements ChunkTable { } public void getMeta(Context options, Set<ChunkKey> keys, - AsyncCallback<Collection<ChunkMeta>> callback) { + AsyncCallback<Map<ChunkKey, ChunkMeta>> callback) { List<CacheKey> toFind = new ArrayList<CacheKey>(keys.size()); for (ChunkKey k : keys) toFind.add(nsMeta.key(k)); @@ -118,8 +125,10 @@ public class CacheChunkTable implements ChunkTable { 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 class CacheChunkTable implements ChunkTable { } private static byte[] encode(PackChunk.Members members) { - final byte[] meta; - if (members.hasMeta()) - meta = members.getMeta().asBytes(); - else - meta = null; - - ByteBuffer chunkData = members.getChunkDataAsByteBuffer(); - ByteBuffer chunkIndex = members.getChunkIndexAsByteBuffer(); - - 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); + // 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(); + + 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); + + 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 @@ public class CacheChunkTable implements ChunkTable { private final Set<ChunkKey> remaining; - private final AsyncCallback<Collection<ChunkMeta>> normalCallback; + private final AsyncCallback<Map<ChunkKey, ChunkMeta>> normalCallback; - private final StreamingCallback<Collection<ChunkMeta>> streamingCallback; + private final StreamingCallback<Map<ChunkKey, ChunkMeta>> streamingCallback; - private final List<ChunkMeta> all; + private final Map<ChunkKey, ChunkMeta> all; MetaFromCache(Context options, Set<ChunkKey> keys, - AsyncCallback<Collection<ChunkMeta>> callback) { + AsyncCallback<Map<ChunkKey, ChunkMeta>> callback) { this.options = options; this.remaining = new HashSet<ChunkKey>(keys); this.normalCallback = callback; if (callback instanceof StreamingCallback<?>) { - streamingCallback = (StreamingCallback<Collection<ChunkMeta>>) callback; + streamingCallback = (StreamingCallback<Map<ChunkKey, ChunkMeta>>) callback; all = null; } else { streamingCallback = null; - all = new ArrayList<ChunkMeta>(keys.size()); + all = new HashMap<ChunkKey, ChunkMeta>(); } } public void onPartialResult(Map<CacheKey, byte[]> result) { for (Map.Entry<CacheKey, byte[]> 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.<Void> 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 class CacheChunkTable implements ChunkTable { } private class MetaFromDatabase implements - StreamingCallback<Collection<ChunkMeta>> { + StreamingCallback<Map<ChunkKey, ChunkMeta>> { private final Object lock = new Object(); - private final List<ChunkMeta> all; + private final Map<ChunkKey, ChunkMeta> all; - private final AsyncCallback<Collection<ChunkMeta>> normalCallback; + private final AsyncCallback<Map<ChunkKey, ChunkMeta>> normalCallback; - private final StreamingCallback<Collection<ChunkMeta>> streamingCallback; + private final StreamingCallback<Map<ChunkKey, ChunkMeta>> streamingCallback; - MetaFromDatabase(List<ChunkMeta> all, - AsyncCallback<Collection<ChunkMeta>> normalCallback, - StreamingCallback<Collection<ChunkMeta>> streamingCallback) { + MetaFromDatabase(Map<ChunkKey, ChunkMeta> all, + AsyncCallback<Map<ChunkKey, ChunkMeta>> normalCallback, + StreamingCallback<Map<ChunkKey, ChunkMeta>> streamingCallback) { this.all = all; this.normalCallback = normalCallback; this.streamingCallback = streamingCallback; } - public void onPartialResult(Collection<ChunkMeta> result) { - final List<ChunkMeta> toPutIntoCache = copy(result); + public void onPartialResult(Map<ChunkKey, ChunkMeta> result) { + final Map<ChunkKey, ChunkMeta> toPutIntoCache = copy(result); if (streamingCallback != null) streamingCallback.onPartialResult(result); else { synchronized (lock) { - all.addAll(result); + all.putAll(result); } } @@ -425,20 +484,22 @@ public class CacheChunkTable implements ChunkTable { // 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<ChunkKey, ChunkMeta> ent + : toPutIntoCache.entrySet()) { + ChunkKey key = ent.getKey(); + Change op = Change.put(nsMeta.key(key), + ent.getValue().toByteArray()); client.modify(singleton(op), none); } } }); } - private <T> List<T> copy(Collection<T> result) { - return new ArrayList<T>(result); + private <K, V> Map<K, V> copy(Map<K, V> result) { + return new HashMap<K, V>(result); } - public void onSuccess(Collection<ChunkMeta> result) { + public void onSuccess(Map<ChunkKey, ChunkMeta> 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 0438dc09e7..0cd3549e04 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.Map; 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.ObjectIndexKey; 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 class CacheObjectIndexTable implements ObjectIndexTable { buf.remove(ns.key(objId)); } - private static byte[] encode(Collection<ObjectInfo> 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<ObjectInfo> decode(byte[] raw) { - List<ObjectInfo> res = new ArrayList<ObjectInfo>(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<Map<CacheKey, byte[]>> { private final Object lock = new Object(); @@ -217,7 +169,15 @@ public class CacheObjectIndexTable implements ObjectIndexTable { for (Map.Entry<CacheKey, byte[]> e : result.entrySet()) { ObjectIndexKey objKey; - Collection<ObjectInfo> list = decode(e.getValue()); + Collection<ObjectInfo> list; + try { + list = decode(e.getValue()); + } catch (InvalidProtocolBufferException badCell) { + client.modify( + Collections.singleton(Change.remove(e.getKey())), + Sync.<Void> none()); + continue; + } objKey = ObjectIndexKey.fromBytes(e.getKey().getBytes()); if (tmp != null) @@ -238,6 +198,21 @@ public class CacheObjectIndexTable implements ObjectIndexTable { } } + private Collection<ObjectInfo> 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<CacheKey, byte[]> result) { if (result != null && !result.isEmpty()) onPartialResult(result); @@ -305,6 +280,19 @@ public class CacheObjectIndexTable implements ObjectIndexTable { client.modify(ops, Sync.<Void> none()); } + + private byte[] encode(List<ObjectInfo> 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 5edb49eddf..2b6c8dac31 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 @@ package org.eclipse.jgit.storage.dht.spi.cache; 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 b71c242625..a378e0a8b3 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 @@ package org.eclipse.jgit.storage.dht.spi.cache; 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 class CacheRepositoryTable implements RepositoryTable { byte[] data = result.get(memKey); if (data != null) { - List<CachedPackInfo> r = new ArrayList<CachedPackInfo>(); - 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<CachedPackInfo> 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 8a04dbb6d5..277b2b83a8 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 @@ final class MemChunkTable implements ChunkTable { 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 @@ final class MemChunkTable implements ChunkTable { } public void getMeta(Context options, Set<ChunkKey> keys, - AsyncCallback<Collection<ChunkMeta>> callback) { - int cnt = keys.size(); - List<ChunkMeta> out = new ArrayList<ChunkMeta>(cnt); + AsyncCallback<Map<ChunkKey, ChunkMeta>> callback) { + Map<ChunkKey, ChunkMeta> out = new HashMap<ChunkKey, ChunkMeta>(); 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 @@ final class MemChunkTable implements ChunkTable { 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 e6f4f7acac..e3bb7fdd11 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.ObjectIndexTable; 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 @@ final class MemObjectIndexTable implements ObjectIndexTable { for (ObjectIndexKey objId : objects) { for (MemTable.Cell cell : table.scanFamily(objId.asBytes(), colInfo)) { - Collection<ObjectInfo> info = out.get(objId); - if (info == null) { - info = new ArrayList<ObjectInfo>(4); - out.put(objId, info); + Collection<ObjectInfo> chunks = out.get(objId); + ChunkKey chunkKey; + if (chunks == null) { + chunks = new ArrayList<ObjectInfo>(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 @@ final class MemObjectIndexTable implements ObjectIndexTable { 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 6c41f20c4a..595e3fdd7c 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 @@ final class MemRefTable implements RefTable { Map<RefKey, RefData> out = new HashMap<RefKey, RefData>(); 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 @@ final class MemRefTable implements RefTable { 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 @@ final class MemRefTable implements RefTable { 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 01e90de3ba..d393934a23 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 @@ final class MemRepositoryTable implements RepositoryTable { 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 @@ final class MemRepositoryTable implements RepositoryTable { public Collection<CachedPackInfo> getCachedPacks(RepositoryKey repo) throws DhtException, TimeoutException { List<CachedPackInfo> out = new ArrayList<CachedPackInfo>(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) @@ -135,6 +135,7 @@ <args4j-version>2.0.12</args4j-version> <servlet-api-version>2.5</servlet-api-version> <jetty-version>7.1.6.v20100715</jetty-version> + <protobuf-version>2.4.0a</protobuf-version> </properties> <build> @@ -348,6 +349,12 @@ <artifactId>jetty-servlet</artifactId> <version>${jetty-version}</version> </dependency> + + <dependency> + <groupId>com.google.protobuf</groupId> + <artifactId>protobuf-java</artifactId> + <version>${protobuf-version}</version> + </dependency> </dependencies> </dependencyManagement> @@ -392,6 +399,7 @@ <modules> <module>org.eclipse.jgit</module> + <module>org.eclipse.jgit.generated.storage.dht.proto</module> <module>org.eclipse.jgit.storage.dht</module> <module>org.eclipse.jgit.ant</module> <module>org.eclipse.jgit.ui</module> |