-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
- <classpathentry kind="src" path="src"/>
- <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-10">
- <attributes>
- <attribute name="module" value="true"/>
- </attributes>
- </classpathentry>
- <classpathentry kind="output" path="bin"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>\r
+<classpath>\r
+ <classpathentry kind="src" path="src" />\r
+ <classpathentry kind="con"\r
+ path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5" />\r
+ <classpathentry kind="con"\r
+ path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-10">\r
+ <attributes>\r
+ <attribute name="module" value="true" />\r
+ </attributes>\r
+ </classpathentry>\r
+ <classpathentry kind="output" path="bin" />\r
+</classpath>\r
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=10
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=10
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.release=enabled
-org.eclipse.jdt.core.compiler.source=10
+eclipse.preferences.version=1\r
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled\r
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=10\r
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve\r
+org.eclipse.jdt.core.compiler.compliance=10\r
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate\r
+org.eclipse.jdt.core.compiler.debug.localVariable=generate\r
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate\r
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error\r
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error\r
+org.eclipse.jdt.core.compiler.release=enabled\r
+org.eclipse.jdt.core.compiler.source=10\r
+org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false\r
+org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647\r
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false\r
+org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false\r
+org.eclipse.jdt.core.formatter.align_with_spaces=false\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16\r
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16\r
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0\r
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16\r
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16\r
+org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16\r
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80\r
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16\r
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16\r
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0\r
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0\r
+org.eclipse.jdt.core.formatter.alignment_for_module_statements=16\r
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16\r
+org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0\r
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80\r
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16\r
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16\r
+org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0\r
+org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0\r
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16\r
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1\r
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1\r
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0\r
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0\r
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1\r
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1\r
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1\r
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1\r
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0\r
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1\r
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1\r
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_block=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_switch=next_line\r
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line\r
+org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped=true\r
+org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false\r
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false\r
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false\r
+org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=true\r
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true\r
+org.eclipse.jdt.core.formatter.comment.format_header=false\r
+org.eclipse.jdt.core.formatter.comment.format_html=true\r
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true\r
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true\r
+org.eclipse.jdt.core.formatter.comment.format_source_code=true\r
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false\r
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=false\r
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert\r
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert\r
+org.eclipse.jdt.core.formatter.comment.line_length=140\r
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true\r
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true\r
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false\r
+org.eclipse.jdt.core.formatter.compact_else_if=true\r
+org.eclipse.jdt.core.formatter.continuation_indentation=2\r
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2\r
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off\r
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on\r
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false\r
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=false\r
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true\r
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true\r
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true\r
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true\r
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true\r
+org.eclipse.jdt.core.formatter.indent_empty_lines=false\r
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true\r
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true\r
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true\r
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false\r
+org.eclipse.jdt.core.formatter.indentation.size=4\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert\r
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert\r
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert\r
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert\r
+org.eclipse.jdt.core.formatter.join_lines_in_comments=true\r
+org.eclipse.jdt.core.formatter.join_wrapped_lines=true\r
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false\r
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false\r
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false\r
+org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false\r
+org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false\r
+org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false\r
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false\r
+org.eclipse.jdt.core.formatter.lineSplit=140\r
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false\r
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false\r
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0\r
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines\r
+org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines\r
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true\r
+org.eclipse.jdt.core.formatter.tabulation.char=tab\r
+org.eclipse.jdt.core.formatter.tabulation.size=4\r
+org.eclipse.jdt.core.formatter.use_on_off_tags=true\r
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false\r
+org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false\r
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true\r
+org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true\r
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true\r
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true\r
+org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter\r
--- /dev/null
+eclipse.preferences.version=1\r
+formatter_profile=_MyPrefrence\r
+formatter_settings_version=14\r
/**\r
* stdlogic according to IEEE 1164\r
*/\r
-public enum Bit {\r
+public enum Bit\r
+{\r
U, X, ZERO, ONE, Z;\r
\r
- public static Bit and(Bit a, Bit b) {\r
+ public static Bit and(Bit a, Bit b)\r
+ {\r
return a.and(b);\r
}\r
\r
- public Bit and(Bit other) {\r
+ public Bit and(Bit other)\r
+ {\r
return fromTable(AND_TABLE, this, other);\r
}\r
\r
- public static Bit or(Bit a, Bit b) {\r
+ public static Bit or(Bit a, Bit b)\r
+ {\r
return a.or(b);\r
}\r
\r
- public Bit or(Bit other) {\r
+ public Bit or(Bit other)\r
+ {\r
return fromTable(OR_TABLE, this, other);\r
}\r
\r
- public static Bit xor(Bit a, Bit b) {\r
+ public static Bit xor(Bit a, Bit b)\r
+ {\r
return a.xor(b);\r
}\r
\r
- public Bit xor(Bit other) {\r
+ public Bit xor(Bit other)\r
+ {\r
return fromTable(XOR_TABLE, this, other);\r
}\r
\r
- public Bit not() {\r
- switch (this) {\r
+ public Bit not()\r
+ {\r
+ switch (this)\r
+ {\r
case U:\r
return U;\r
case ONE:\r
}\r
}\r
\r
- public Bit[] makeArray(int length) {\r
+ public Bit[] makeArray(int length)\r
+ {\r
Bit[] bits = new Bit[length];\r
Arrays.fill(bits, this);\r
return bits;\r
}\r
\r
- public Bit combineWith(Bit other) {\r
+ public Bit combineWith(Bit other)\r
+ {\r
return fromTable(JOIN_TABLE, this, other);\r
}\r
\r
- public static Bit combine(Bit a, Bit b) {\r
+ public static Bit combine(Bit a, Bit b)\r
+ {\r
return a.combineWith(b);\r
}\r
\r
- private static Bit fromTable(Bit[][] table, Bit a, Bit b) {\r
+ private static Bit fromTable(Bit[][] table, Bit a, Bit b)\r
+ {\r
return table[a.ordinal()][b.ordinal()];\r
}\r
\r
\r
import era.mi.logic.timeline.Timeline;\r
\r
-public class Simulation {\r
+public class Simulation\r
+{\r
public final static Timeline TIMELINE = new Timeline(11);\r
\r
- public static void main(String[] args) {\r
+ public static void main(String[] args)\r
+ {\r
}\r
}
\ No newline at end of file
\r
import java.util.Arrays;\r
\r
-public final class Util {\r
+public final class Util\r
+{\r
\r
@SuppressWarnings("unchecked")\r
- public static <T> T[] concat(T[]... arrays) {\r
+ public static <T> T[] concat(T[]... arrays)\r
+ {\r
if (arrays.length == 0)\r
throw new IllegalArgumentException("Cannot concatenate 0 arrays.");\r
\r
\r
T[] newArray = Arrays.copyOf(arrays[0], length);\r
int appendIndex = arrays[0].length;\r
- for (int i = 1; i < arrays.length; i++) {\r
+ for (int i = 1; i < arrays.length; i++)\r
+ {\r
System.arraycopy(arrays[i], 0, newArray, appendIndex, arrays[i].length);\r
appendIndex += arrays[i].length;\r
}\r
// return (T[][]) newArray;\r
// }\r
\r
- public static Bit[] and(Bit[] a, Bit[] b) {\r
+ public static Bit[] and(Bit[] a, Bit[] b)\r
+ {\r
return binBitOp(a, b, (bA, bB) -> Bit.and(bA, bB));\r
}\r
\r
- public static Bit[] or(Bit[] a, Bit[] b) {\r
+ public static Bit[] or(Bit[] a, Bit[] b)\r
+ {\r
return binBitOp(a, b, (bA, bB) -> Bit.or(bA, bB));\r
}\r
\r
- public static Bit[] xor(Bit[] a, Bit[] b) {\r
+ public static Bit[] xor(Bit[] a, Bit[] b)\r
+ {\r
return binBitOp(a, b, (bA, bB) -> Bit.xor(bA, bB));\r
}\r
\r
- private static Bit[] binBitOp(Bit[] a, Bit[] b, BitOp op) {\r
+ private static Bit[] binBitOp(Bit[] a, Bit[] b, BitOp op)\r
+ {\r
if (a.length != b.length)\r
throw new IllegalArgumentException("Bit Arrays were not of equal length.");\r
Bit[] out = new Bit[a.length];\r
- for (int i = 0; i < a.length; i++) {\r
+ for (int i = 0; i < a.length; i++)\r
+ {\r
out[i] = op.execute(a[i], b[i]);\r
}\r
return out;\r
}\r
\r
- public static Bit[] not(Bit[] a) {\r
+ public static Bit[] not(Bit[] a)\r
+ {\r
Bit[] out = new Bit[a.length];\r
- for (int i = 0; i < a.length; i++) {\r
+ for (int i = 0; i < a.length; i++)\r
+ {\r
out[i] = a[i].not();\r
}\r
return out;\r
* \r
* @author Christian Femers\r
*/\r
- public static Bit[] combineInto(Bit[] dest, Bit[] addition) {\r
+ public static Bit[] combineInto(Bit[] dest, Bit[] addition)\r
+ {\r
if (dest.length != addition.length)\r
throw new IllegalArgumentException("Bit Arrays were not of equal length.");\r
- for (int i = 0; i < addition.length; i++) {\r
+ for (int i = 0; i < addition.length; i++)\r
+ {\r
dest[i] = dest[i].combineWith(addition[i]);\r
}\r
return dest;\r
}\r
\r
- interface BitOp {\r
+ interface BitOp\r
+ {\r
Bit execute(Bit a, Bit b);\r
}\r
}\r
* \r
* @author Fabian Stemmler\r
*/\r
-public abstract class BasicComponent implements WireArrayObserver, Component {\r
+public abstract class BasicComponent implements WireArrayObserver, Component\r
+{\r
private int processTime;\r
\r
/**\r
* \r
* @author Fabian Stemmler\r
*/\r
- public BasicComponent(int processTime) {\r
+ public BasicComponent(int processTime)\r
+ {\r
this.processTime = processTime > 0 ? processTime : 1;\r
}\r
\r
@Override\r
- public void update(WireArray initiator, Bit[] oldValues) {\r
- Simulation.TIMELINE.addEvent((e) -> {\r
+ public void update(WireArray initiator, Bit[] oldValues)\r
+ {\r
+ Simulation.TIMELINE.addEvent((e) ->\r
+ {\r
compute();\r
}, processTime);\r
}\r
import era.mi.logic.Bit;\r
import era.mi.logic.wires.WireArray;\r
\r
-public class BitDisplay extends BasicComponent {\r
+public class BitDisplay extends BasicComponent\r
+{\r
private final WireArray in;\r
private Bit[] displayedValue;\r
\r
- public BitDisplay(WireArray in) {\r
+ public BitDisplay(WireArray in)\r
+ {\r
super(1);\r
this.in = in;\r
in.addObserver(this);\r
}\r
\r
@Override\r
- protected void compute() {\r
+ protected void compute()\r
+ {\r
displayedValue = in.getValues();\r
}\r
\r
- public Bit[] getDisplayedValue() {\r
+ public Bit[] getDisplayedValue()\r
+ {\r
return displayedValue;\r
}\r
\r
- public boolean isDisplaying(Bit... values) {\r
+ public boolean isDisplaying(Bit... values)\r
+ {\r
return Arrays.equals(displayedValue, values);\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(in));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(new ArrayList<WireArray>());\r
}\r
}\r
import era.mi.logic.timeline.TimelineEvent;\r
import era.mi.logic.timeline.TimelineEventHandler;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
-public class Clock implements TimelineEventHandler, Component {\r
+public class Clock implements TimelineEventHandler, Component\r
+{\r
private boolean toggle = false;\r
- private WireArrayInput outI;\r
+ private WireArrayEnd outI;\r
private int delta;\r
\r
/**\r
* @param out {@link WireArray} the clock's impulses are fed into\r
* @param delta ticks between rising and falling edge\r
*/\r
- public Clock(WireArray out, int delta) {\r
+ public Clock(WireArray out, int delta)\r
+ {\r
this.delta = delta;\r
this.outI = out.createInput();\r
Simulation.TIMELINE.addEvent(this, 50);\r
}\r
\r
@Override\r
- public void handle(TimelineEvent e) {\r
+ public void handle(TimelineEvent e)\r
+ {\r
addToTimeline();\r
outI.feedSignals(new Bit[] { toggle ? Bit.ONE : Bit.ZERO });\r
toggle = !toggle;\r
}\r
\r
- public WireArray getOut() {\r
+ public WireArray getOut()\r
+ {\r
return outI.owner;\r
}\r
\r
- private void addToTimeline() {\r
+ private void addToTimeline()\r
+ {\r
Simulation.TIMELINE.addEvent(this, delta);\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList());\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(outI.owner));\r
}\r
}\r
\r
import era.mi.logic.wires.WireArray;\r
\r
-public interface Component {\r
+public interface Component\r
+{\r
\r
/**\r
* Returns immutable list of all inputs to the {@link Component} (including e.g. the select bits to a MUX). Intended for visualization\r
import java.util.List;\r
\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
/**\r
* Models a multiplexer. Takes an arbitrary amount of input {@link WireArray}s, one of which, as determined by select, is put through to the\r
* @author Fabian Stemmler\r
*\r
*/\r
-public class Demux extends BasicComponent {\r
+public class Demux extends BasicComponent\r
+{\r
private final WireArray select, in;\r
private final WireArray[] outputs;\r
- private final WireArrayInput[] outputsI;\r
+ private final WireArrayEnd[] outputsI;\r
private final int outputSize;\r
private int selected = -1;\r
\r
* @param select Indexes the input array which is to be mapped to the output. Must have enough bits to index all inputs.\r
* @param outputs One of these inputs is mapped to the output, depending on the select bits\r
*/\r
- public Demux(int processTime, WireArray in, WireArray select, WireArray... outputs) {\r
+ public Demux(int processTime, WireArray in, WireArray select, WireArray... outputs)\r
+ {\r
super(processTime);\r
outputSize = in.length;\r
\r
this.in = in;\r
this.outputs = outputs;\r
- this.outputsI = new WireArrayInput[outputs.length];\r
- for (int i = 0; i < this.outputsI.length; i++) {\r
+ this.outputsI = new WireArrayEnd[outputs.length];\r
+ for (int i = 0; i < this.outputsI.length; i++)\r
+ {\r
if (outputs[i].length != outputSize)\r
throw new IllegalArgumentException("All DEMUX wire arrays must be of uniform length!");\r
this.outputsI[i] = outputs[i].createInput();\r
}\r
\r
@Override\r
- public void compute() {\r
+ public void compute()\r
+ {\r
int selectValue = select.hasNumericValue() ? (int) select.getUnsignedValue() : -1;\r
if (selectValue >= outputsI.length)\r
selectValue = -1;\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(in, select));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(outputs));\r
}\r
}\r
\r
import era.mi.logic.Bit;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
/**\r
* This class models a simple on/off (ONE/ZERO) switch for user interaction.\r
* @author Christian Femers\r
*\r
*/\r
-public class ManualSwitch implements Component {\r
+public class ManualSwitch implements Component\r
+{\r
private WireArray output;\r
- private WireArrayInput outputI;\r
+ private WireArrayEnd outputI;\r
private boolean isOn;\r
\r
- public ManualSwitch(WireArray output) {\r
+ public ManualSwitch(WireArray output)\r
+ {\r
if (output.length != 1)\r
throw new IllegalArgumentException("Switch output can be only a single wire");\r
this.output = output;\r
this.outputI = output.createInput();\r
}\r
\r
- public void switchOn() {\r
+ public void switchOn()\r
+ {\r
setState(true);\r
}\r
\r
- public void switchOff() {\r
+ public void switchOff()\r
+ {\r
setState(false);\r
}\r
\r
- public void toggle() {\r
+ public void toggle()\r
+ {\r
setState(!isOn);\r
}\r
\r
- public void setState(boolean isOn) {\r
+ public void setState(boolean isOn)\r
+ {\r
if (this.isOn == isOn)\r
return;\r
this.isOn = isOn;\r
outputI.feedSignals(getValue());\r
}\r
\r
- public boolean isOn() {\r
+ public boolean isOn()\r
+ {\r
return isOn;\r
}\r
\r
- public Bit getValue() {\r
+ public Bit getValue()\r
+ {\r
return isOn ? Bit.ONE : Bit.ZERO;\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return List.of();\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return List.of(output);\r
}\r
\r
\r
import era.mi.logic.Bit;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
import era.mi.logic.wires.WireArrayObserver;\r
\r
-public class Merger implements WireArrayObserver, Component {\r
- private WireArrayInput outI;\r
+public class Merger implements WireArrayObserver, Component\r
+{\r
+ private WireArrayEnd outI;\r
private WireArray[] inputs;\r
private int[] beginningIndex;\r
\r
* @param union The output of merging n {@link WireArray}s into one. Must have length = a1.length() + a2.length() + ... + an.length().\r
* @param inputs The inputs to be merged into the union\r
*/\r
- public Merger(WireArray union, WireArray... inputs) {\r
+ public Merger(WireArray union, WireArray... inputs)\r
+ {\r
this.inputs = inputs;\r
this.outI = union.createInput();\r
this.beginningIndex = new int[inputs.length];\r
\r
int length = 0;\r
- for (int i = 0; i < inputs.length; i++) {\r
+ for (int i = 0; i < inputs.length; i++)\r
+ {\r
beginningIndex[i] = length;\r
length += inputs[i].length;\r
inputs[i].addObserver(this);\r
"The output of merging n WireArrays into one must have length = a1.length() + a2.length() + ... + an.length().");\r
}\r
\r
- public WireArray getInput(int index) {\r
+ public WireArray getInput(int index)\r
+ {\r
return inputs[index];\r
}\r
\r
- public WireArray getUnion() {\r
+ public WireArray getUnion()\r
+ {\r
return outI.owner;\r
}\r
\r
@Override\r
- public void update(WireArray initiator, Bit[] oldValues) {\r
+ public void update(WireArray initiator, Bit[] oldValues)\r
+ {\r
int index = find(initiator);\r
int beginning = beginningIndex[index];\r
outI.feedSignals(beginning, initiator.getValues());\r
}\r
\r
- private int find(WireArray w) {\r
+ private int find(WireArray w)\r
+ {\r
for (int i = 0; i < inputs.length; i++)\r
if (inputs[i] == w)\r
return i;\r
return -1;\r
}\r
\r
- public WireArray[] getInputs() {\r
+ public WireArray[] getInputs()\r
+ {\r
return inputs.clone();\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(inputs));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(outI.owner));\r
}\r
}\r
import java.util.List;\r
\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
/**\r
* Models a multiplexer. Takes an arbitrary amount of input {@link WireArray}s, one of which, as determined by select, is put through to the\r
* @author Fabian Stemmler\r
*\r
*/\r
-public class Mux extends BasicComponent {\r
+public class Mux extends BasicComponent\r
+{\r
private WireArray select;\r
- private WireArrayInput outI;\r
+ private WireArrayEnd outI;\r
private WireArray[] inputs;\r
private final int outputSize;\r
\r
* @param select Indexes the input array which is to be mapped to the output. Must have enough bits to index all inputs.\r
* @param inputs One of these inputs is mapped to the output, depending on the select bits\r
*/\r
- public Mux(int processTime, WireArray out, WireArray select, WireArray... inputs) {\r
+ public Mux(int processTime, WireArray out, WireArray select, WireArray... inputs)\r
+ {\r
super(processTime);\r
outputSize = out.length;\r
\r
this.inputs = inputs.clone();\r
- for (int i = 0; i < this.inputs.length; i++) {\r
+ for (int i = 0; i < this.inputs.length; i++)\r
+ {\r
if (inputs[i].length != outputSize)\r
throw new IllegalArgumentException("All MUX wire arrays must be of uniform length!");\r
inputs[i].addObserver(this);\r
outI = out.createInput();\r
}\r
\r
- public WireArray getOut() {\r
+ public WireArray getOut()\r
+ {\r
return outI.owner;\r
}\r
\r
- public WireArray getSelect() {\r
+ public WireArray getSelect()\r
+ {\r
return select;\r
}\r
\r
@Override\r
- public void compute() {\r
+ public void compute()\r
+ {\r
int selectValue;\r
- if (!select.hasNumericValue() || (selectValue = (int) select.getUnsignedValue()) >= inputs.length) {\r
+ if (!select.hasNumericValue() || (selectValue = (int) select.getUnsignedValue()) >= inputs.length)\r
+ {\r
outI.clearSignals();\r
return;\r
}\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
ArrayList<WireArray> wires = new ArrayList<WireArray>(Arrays.asList(inputs));\r
wires.add(select);\r
return Collections.unmodifiableList(wires);\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(outI.owner));\r
}\r
}\r
\r
import era.mi.logic.Bit;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
import era.mi.logic.wires.WireArrayObserver;\r
\r
-public class Splitter implements WireArrayObserver {\r
+public class Splitter implements WireArrayObserver\r
+{\r
private WireArray input;\r
- private WireArrayInput[] outputs;\r
+ private WireArrayEnd[] outputs;\r
\r
- public Splitter(WireArray input, WireArray... outputs) {\r
+ public Splitter(WireArray input, WireArray... outputs)\r
+ {\r
this.input = input;\r
this.outputs = WireArray.extractInputs(outputs);\r
input.addObserver(this);\r
"The input of splitting one into n WireArrays must have length = a1.length() + a2.length() + ... + an.length().");\r
}\r
\r
- protected void compute() {\r
+ protected void compute()\r
+ {\r
int startIndex = 0;\r
Bit[] inputBits = input.getValues();\r
- for (int i = 0; i < outputs.length; i++) {\r
+ for (int i = 0; i < outputs.length; i++)\r
+ {\r
Bit[] outputBits = new Bit[outputs[i].owner.length];\r
System.arraycopy(inputBits, startIndex, outputBits, 0, outputs[i].owner.length);\r
outputs[i].feedSignals(outputBits);\r
}\r
\r
@Override\r
- public void update(WireArray initiator, Bit[] oldValues) {\r
+ public void update(WireArray initiator, Bit[] oldValues)\r
+ {\r
compute();\r
}\r
}\r
\r
import era.mi.logic.Bit;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
-public class TriStateBuffer extends BasicComponent {\r
+public class TriStateBuffer extends BasicComponent\r
+{\r
WireArray in, enable;\r
- WireArrayInput outI;\r
+ WireArrayEnd outI;\r
\r
- public TriStateBuffer(int processTime, WireArray in, WireArray out, WireArray enable) {\r
+ public TriStateBuffer(int processTime, WireArray in, WireArray out, WireArray enable)\r
+ {\r
super(processTime);\r
if (in.length != out.length)\r
throw new IllegalArgumentException(\r
}\r
\r
@Override\r
- protected void compute() {\r
+ protected void compute()\r
+ {\r
if (enable.getValue() == Bit.ONE)\r
outI.feedSignals(in.getValues());\r
else\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(in, enable));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(outI.owner));\r
}\r
\r
import era.mi.logic.Util;\r
import era.mi.logic.wires.WireArray;\r
\r
-public class AndGate extends MultiInputGate {\r
- public AndGate(int processTime, WireArray out, WireArray... in) {\r
+public class AndGate extends MultiInputGate\r
+{\r
+ public AndGate(int processTime, WireArray out, WireArray... in)\r
+ {\r
super(processTime, Util::and, out, in);\r
}\r
}\r
import era.mi.logic.Bit;\r
import era.mi.logic.components.BasicComponent;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
-public abstract class MultiInputGate extends BasicComponent {\r
+public abstract class MultiInputGate extends BasicComponent\r
+{\r
protected WireArray[] in;\r
protected WireArray out;\r
- protected WireArrayInput outI;\r
+ protected WireArrayEnd outI;\r
protected final int length;\r
protected Operation op;\r
\r
- protected MultiInputGate(int processTime, Operation op, WireArray out, WireArray... in) {\r
+ protected MultiInputGate(int processTime, Operation op, WireArray out, WireArray... in)\r
+ {\r
super(processTime);\r
this.op = op;\r
length = out.length;\r
this.in = in.clone();\r
if (in.length < 1)\r
throw new IllegalArgumentException(String.format("Cannot create gate with %d wires.", in.length));\r
- for (WireArray w : in) {\r
+ for (WireArray w : in)\r
+ {\r
if (w.length != length)\r
throw new IllegalArgumentException("All wires connected to the gate must be of uniform length.");\r
w.addObserver(this);\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(in));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(out));\r
}\r
\r
- protected void compute() {\r
+ protected void compute()\r
+ {\r
Bit[] result = in[0].getValues();\r
for (int i = 1; i < in.length; i++)\r
result = op.execute(result, in[i].getValues());\r
outI.feedSignals(result);\r
}\r
\r
- protected interface Operation {\r
+ protected interface Operation\r
+ {\r
public Bit[] execute(Bit[] a, Bit[] b);\r
}\r
}\r
import era.mi.logic.Util;\r
import era.mi.logic.components.BasicComponent;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
-public class NotGate extends BasicComponent {\r
+public class NotGate extends BasicComponent\r
+{\r
private WireArray in, out;\r
- private WireArrayInput outI;\r
+ private WireArrayEnd outI;\r
\r
- public NotGate(int processTime, WireArray in, WireArray out) {\r
+ public NotGate(int processTime, WireArray in, WireArray out)\r
+ {\r
super(processTime);\r
this.in = in;\r
in.addObserver(this);\r
outI = out.createInput();\r
}\r
\r
- public void compute() {\r
+ public void compute()\r
+ {\r
outI.feedSignals(Util.not(in.getValues()));\r
}\r
\r
- public WireArray getIn() {\r
+ public WireArray getIn()\r
+ {\r
return in;\r
}\r
\r
- public WireArray getOut() {\r
+ public WireArray getOut()\r
+ {\r
return out;\r
}\r
\r
@Override\r
- public List<WireArray> getAllInputs() {\r
+ public List<WireArray> getAllInputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(in));\r
}\r
\r
@Override\r
- public List<WireArray> getAllOutputs() {\r
+ public List<WireArray> getAllOutputs()\r
+ {\r
return Collections.unmodifiableList(Arrays.asList(out));\r
}\r
}\r
import era.mi.logic.Util;\r
import era.mi.logic.wires.WireArray;\r
\r
-public class OrGate extends MultiInputGate {\r
- public OrGate(int processTime, WireArray out, WireArray... in) {\r
+public class OrGate extends MultiInputGate\r
+{\r
+ public OrGate(int processTime, WireArray out, WireArray... in)\r
+ {\r
super(processTime, Util::or, out, in);\r
}\r
}\r
* \r
* @author Fabian Stemmler\r
*/\r
-public class XorGate extends MultiInputGate {\r
- public XorGate(int processTime, WireArray out, WireArray... in) {\r
+public class XorGate extends MultiInputGate\r
+{\r
+ public XorGate(int processTime, WireArray out, WireArray... in)\r
+ {\r
super(processTime, Util::xor, out, in);\r
}\r
\r
import era.mi.logic.components.gates.OrGate;\r
import era.mi.logic.components.gates.XorGate;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
\r
-class ComponentTest {\r
+class ComponentTest\r
+{\r
\r
@Test\r
- void circuitExampleTest() {\r
+ void circuitExampleTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(1, 1), b = new WireArray(1, 1), c = new WireArray(1, 10), d = new WireArray(2, 1),\r
e = new WireArray(1, 1), f = new WireArray(1, 1), g = new WireArray(1, 1), h = new WireArray(2, 1), i = new WireArray(2, 1),\r
}\r
\r
@Test\r
- void splitterTest() {\r
+ void splitterTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(3, 1), b = new WireArray(2, 1), c = new WireArray(3, 1), in = new WireArray(8, 1);\r
in.createInput().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
}\r
\r
@Test\r
- void mergerTest() {\r
+ void mergerTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(3, 1), b = new WireArray(2, 1), c = new WireArray(3, 1), out = new WireArray(8, 1);\r
a.createInput().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);\r
}\r
\r
@Test\r
- void triStateBufferTest() {\r
+ void triStateBufferTest()\r
+ {\r
WireArray a = new WireArray(1, 1), b = new WireArray(1, 1), en = new WireArray(1, 1), notEn = new WireArray(1, 1);\r
new NotGate(1, en, notEn);\r
new TriStateBuffer(1, a, b, en);\r
new TriStateBuffer(1, b, a, notEn);\r
\r
- WireArrayInput enI = en.createInput(), aI = a.createInput(), bI = b.createInput();\r
+ WireArrayEnd enI = en.createInput(), aI = a.createInput(), bI = b.createInput();\r
enI.feedSignals(Bit.ONE);\r
aI.feedSignals(Bit.ONE);\r
\r
}\r
\r
@Test\r
- void muxTest() {\r
+ void muxTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(4, 3), b = new WireArray(4, 6), c = new WireArray(4, 4), select = new WireArray(2, 5),\r
out = new WireArray(4, 1);\r
- WireArrayInput selectIn = select.createInput();\r
+ WireArrayEnd selectIn = select.createInput();\r
\r
selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
a.createInput().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
}\r
\r
@Test\r
- void demuxTest() {\r
+ void demuxTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(4, 3), b = new WireArray(4, 6), c = new WireArray(4, 4), select = new WireArray(2, 5),\r
in = new WireArray(4, 1);\r
- WireArrayInput selectIn = select.createInput();\r
+ WireArrayEnd selectIn = select.createInput();\r
\r
selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
in.createInput().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
Simulation.TIMELINE.executeAll();\r
\r
assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
- assertBitArrayEquals(b.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
- assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
+ assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
+ assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
selectIn.feedSignals(Bit.ZERO, Bit.ONE);\r
Simulation.TIMELINE.executeAll();\r
\r
assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
- assertBitArrayEquals(b.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
+ assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
\r
selectIn.feedSignals(Bit.ONE, Bit.ONE);\r
Simulation.TIMELINE.executeAll();\r
\r
assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
- assertBitArrayEquals(b.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
+ assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
\r
}\r
\r
@Test\r
- void andTest() {\r
+ void andTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(4, 1), b = new WireArray(4, 3), c = new WireArray(4, 1);\r
new AndGate(1, c, a, b);\r
}\r
\r
@Test\r
- void orTest() {\r
+ void orTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(4, 1), b = new WireArray(4, 3), c = new WireArray(4, 1);\r
new OrGate(1, c, a, b);\r
}\r
\r
@Test\r
- void xorTest() {\r
+ void xorTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(3, 1), b = new WireArray(3, 2), c = new WireArray(3, 1), d = new WireArray(3, 1);\r
new XorGate(1, d, a, b, c);\r
}\r
\r
@Test\r
- void rsLatchCircuitTest() {\r
+ void rsLatchCircuitTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray r = new WireArray(1, 1), s = new WireArray(1, 1), t1 = new WireArray(1, 15), t2 = new WireArray(1, 1),\r
q = new WireArray(1, 1), nq = new WireArray(1, 1);\r
new NotGate(1, t2, q);\r
new NotGate(1, t1, nq);\r
\r
- WireArrayInput sIn = s.createInput(), rIn = r.createInput();\r
+ WireArrayEnd sIn = s.createInput(), rIn = r.createInput();\r
\r
sIn.feedSignals(Bit.ONE);\r
rIn.feedSignals(Bit.ZERO);\r
}\r
\r
@Test\r
- void numericValueTest() {\r
+ void numericValueTest()\r
+ {\r
Simulation.TIMELINE.reset();\r
\r
WireArray a = new WireArray(4, 1);\r
}\r
\r
@Test\r
- void multipleInputs() {\r
+ void multipleInputs()\r
+ {\r
Simulation.TIMELINE.reset();\r
WireArray w = new WireArray(2, 1);\r
- WireArrayInput wI1 = w.createInput(), wI2 = w.createInput();\r
+ WireArrayEnd wI1 = w.createInput(), wI2 = w.createInput();\r
wI1.feedSignals(Bit.ONE, Bit.Z);\r
wI2.feedSignals(Bit.Z, Bit.X);\r
Simulation.TIMELINE.executeAll();\r
assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);\r
}\r
\r
- @Test\r
- void wireConnections() {\r
+// @Test\r
+ void wireConnections()\r
+ {\r
// Nur ein Experiment, was über mehrere 'passive' Bausteine hinweg passieren würde\r
\r
Simulation.TIMELINE.reset();\r
WireArray a = new WireArray(1, 2);\r
WireArray b = new WireArray(1, 2);\r
WireArray c = new WireArray(1, 2);\r
- WireArrayInput aI = a.createInput();\r
- WireArrayInput bI = b.createInput();\r
- WireArrayInput cI = c.createInput();\r
+ WireArrayEnd aI = a.createInput();\r
+ WireArrayEnd bI = b.createInput();\r
+ WireArrayEnd cI = c.createInput();\r
\r
TestBitDisplay test = new TestBitDisplay(c);\r
TestBitDisplay test2 = new TestBitDisplay(a);\r
test2.assertAfterSimulationIs(Bit.ONE);\r
}\r
\r
- private static void assertBitArrayEquals(Bit[] actual, Bit... expected) {\r
+ private static void assertBitArrayEquals(Bit[] actual, Bit... expected)\r
+ {\r
assertArrayEquals(expected, actual);\r
}\r
}\r
import era.mi.logic.Bit;\r
import era.mi.logic.Simulation;\r
import era.mi.logic.wires.WireArray;\r
-import era.mi.logic.wires.WireArray.WireArrayInput;\r
+import era.mi.logic.wires.WireArray.WireArrayEnd;\r
import era.mi.logic.wires.WireArrayObserver;\r
\r
-public class Connector implements WireArrayObserver {\r
+public class Connector implements WireArrayObserver\r
+{\r
private final WireArray a;\r
// private final WireArray b;\r
- private final WireArrayInput aI;\r
- private final WireArrayInput bI;\r
+ private final WireArrayEnd aI;\r
+ private final WireArrayEnd bI;\r
\r
- public Connector(WireArray a, WireArray b) {\r
+ public Connector(WireArray a, WireArray b)\r
+ {\r
if (a.length != b.length)\r
throw new IllegalArgumentException(String.format("WireArray width does not match: %d, %d", a.length, b.length));\r
this.a = a;\r
}\r
\r
@Override\r
- public void update(WireArray initiator, Bit[] oldValues) {\r
- Simulation.TIMELINE.addEvent((e) -> {\r
+ public void update(WireArray initiator, Bit[] oldValues)\r
+ {\r
+ Simulation.TIMELINE.addEvent((e) ->\r
+ {\r
if (initiator == a)\r
bI.feedSignals(aI.wireValuesExcludingMe());\r
else\r
import era.mi.logic.timeline.Timeline.ExecutionResult;\r
import era.mi.logic.wires.WireArray;\r
\r
-public class GUITest extends JPanel {\r
+public class GUITest extends JPanel\r
+{\r
\r
private static final long serialVersionUID = 1L;\r
\r
int width;\r
boolean sizeChanged;\r
\r
- public GUITest() {\r
- addMouseListener(new MouseListener() {\r
+ public GUITest()\r
+ {\r
+ addMouseListener(new MouseListener()\r
+ {\r
\r
@Override\r
- public void mouseReleased(MouseEvent e) {\r
- for (Entry<ManualSwitch, Rectangle> dim : switchMap.entrySet()) {\r
- if (dim.getValue().contains(e.getPoint())) {\r
+ public void mouseReleased(MouseEvent e)\r
+ {\r
+ for (Entry<ManualSwitch, Rectangle> dim : switchMap.entrySet())\r
+ {\r
+ if (dim.getValue().contains(e.getPoint()))\r
+ {\r
dim.getKey().switchOff();\r
repaint();\r
}\r
}\r
\r
@Override\r
- public void mousePressed(MouseEvent e) {\r
- for (Entry<ManualSwitch, Rectangle> dim : switchMap.entrySet()) {\r
- if (dim.getValue().contains(e.getPoint())) {\r
+ public void mousePressed(MouseEvent e)\r
+ {\r
+ for (Entry<ManualSwitch, Rectangle> dim : switchMap.entrySet())\r
+ {\r
+ if (dim.getValue().contains(e.getPoint()))\r
+ {\r
dim.getKey().switchOn();\r
repaint();\r
}\r
}\r
\r
@Override\r
- public void mouseExited(MouseEvent e) {\r
+ public void mouseExited(MouseEvent e)\r
+ {\r
// none\r
}\r
\r
@Override\r
- public void mouseEntered(MouseEvent e) {\r
+ public void mouseEntered(MouseEvent e)\r
+ {\r
// none\r
}\r
\r
@Override\r
- public void mouseClicked(MouseEvent e) {\r
+ public void mouseClicked(MouseEvent e)\r
+ {\r
// If you want toggle buttons, use this code instead\r
// for (Entry<ManualSwitch, Rectangle> dim : switchMap.entrySet()) {\r
// if (dim.getValue().contains(e.getPoint())) {\r
}\r
\r
@Override\r
- public void paint(Graphics some_g) {\r
+ public void paint(Graphics some_g)\r
+ {\r
super.paint(some_g);\r
Graphics2D g = ((Graphics2D) some_g);\r
g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);\r
drawString(g, "Hint: drag the cursor out of the pressed switch to keep it's state", 5, 0, 0.0, 1.0);\r
}\r
\r
- private void checkSizeChange() {\r
+ private void checkSizeChange()\r
+ {\r
sizeChanged = height != getHeight() || width != getWidth();\r
- if (sizeChanged) {\r
+ if (sizeChanged)\r
+ {\r
height = getHeight();\r
width = getWidth();\r
}\r
}\r
\r
- private void adaptFont(Graphics g) {\r
+ private void adaptFont(Graphics g)\r
+ {\r
g.setFont(g.getFont().deriveFont(Math.min(height, width) / 40f));\r
}\r
\r
- private void drawString(Graphics g, String s, int x, int y, double anchorX, double anchorY) {\r
+ private void drawString(Graphics g, String s, int x, int y, double anchorX, double anchorY)\r
+ {\r
int h = g.getFontMetrics().getAscent();\r
int w = g.getFontMetrics().stringWidth(s);\r
g.drawString(s, x - (int) (w * anchorX), y + (int) (h * anchorY));\r
}\r
\r
- private void drawWire(Graphics g, WireArray wa, String name, double x1, double y1, double x2, double y2) {\r
+ private void drawWire(Graphics g, WireArray wa, String name, double x1, double y1, double x2, double y2)\r
+ {\r
setTo(g, wa);\r
g.drawLine(gX(x1), gY(y1), gX(x2), gY(y2));\r
drawString(g, name, (gX(x1) + gX(x2)) / 2, (gY(y1) + gY(y2)) / 2 - 5, 0, 0);\r
}\r
\r
- private void drawSquare(Graphics g, int posX, int posY, String text) {\r
+ private void drawSquare(Graphics g, int posX, int posY, String text)\r
+ {\r
int x1 = gX(posX) - 5;\r
int x2 = gX(posX + 1) + 5;\r
int y1 = gY(posY) - 5;\r
\r
}\r
\r
- private void drawSwitch(Graphics g, ManualSwitch ms, String text, double posX1, double posY1, double posX2, double posY2) {\r
+ private void drawSwitch(Graphics g, ManualSwitch ms, String text, double posX1, double posY1, double posX2, double posY2)\r
+ {\r
int x1 = gX(posX1) - 5;\r
int x2 = gX(posX2) + 5;\r
int y1 = gY(posY1) - 5;\r
int y2 = gY(posY2) + 5;\r
\r
- if (sizeChanged) {\r
+ if (sizeChanged)\r
+ {\r
Rectangle r = new Rectangle(x1, y1, x2 - x1, y2 - y1);\r
switchMap.put(ms, r);\r
}\r
drawString(g, text, (x1 + x2) / 2, (y1 + y2) / 2, 0.5, 0.5);\r
}\r
\r
- private static void setBlack(Graphics g) {\r
+ private static void setBlack(Graphics g)\r
+ {\r
g.setColor(Color.BLACK);\r
}\r
\r
- private static void setTo(Graphics g, WireArray wa) {\r
- switch (wa.getValue()) {\r
+ private static void setTo(Graphics g, WireArray wa)\r
+ {\r
+ switch (wa.getValue())\r
+ {\r
case ONE:\r
g.setColor(Color.GREEN);\r
break;\r
}\r
}\r
\r
- private int gY(double pos) {\r
+ private int gY(double pos)\r
+ {\r
return (int) (pos * height / 11);\r
}\r
\r
- private int gX(double pos) {\r
+ private int gX(double pos)\r
+ {\r
return (int) (pos * width / 11) + 50;\r
}\r
\r
- public static void main(String[] args) {\r
+ public static void main(String[] args)\r
+ {\r
JFrame f = new JFrame("Test circuit 1.0.0");\r
GUITest gt = new GUITest();\r
f.add(gt);\r
long lastFrame = begin;\r
long updateT = 16;\r
\r
- while (f.isVisible()) {\r
+ while (f.isVisible())\r
+ {\r
ExecutionResult er = Simulation.TIMELINE.executeUpTo((lastFrame - begin) * 3, lastFrame + 14);\r
// if (Simulation.TIMELINE.hasNext()) \r
// Simulation.TIMELINE.executeNext();\r
if (er != ExecutionResult.NOTHING_DONE)\r
gt.repaint(12);\r
- try {\r
+ try\r
+ {\r
Thread.sleep(Math.max(16 - System.currentTimeMillis() + lastFrame, 0));\r
- } catch (Exception e) {\r
+ }\r
+ catch (Exception e)\r
+ {\r
e.printStackTrace();\r
}\r
lastFrame = System.currentTimeMillis();\r
import era.mi.logic.components.BitDisplay;\r
import era.mi.logic.wires.WireArray;\r
\r
-public final class TestBitDisplay extends BitDisplay {\r
+public final class TestBitDisplay extends BitDisplay\r
+{\r
\r
- public TestBitDisplay(WireArray in) {\r
+ public TestBitDisplay(WireArray in)\r
+ {\r
super(in);\r
}\r
\r
- public void assertDisplays(Bit... expected) {\r
+ public void assertDisplays(Bit... expected)\r
+ {\r
assertArrayEquals(expected, getDisplayedValue());\r
}\r
\r
- public void assertAfterSimulationIs(Bit... expected) {\r
+ public void assertAfterSimulationIs(Bit... expected)\r
+ {\r
Simulation.TIMELINE.executeAll();\r
assertDisplays(expected);\r
}\r
\r
- public void assertAfterSimulationIs(LongConsumer r, Bit... expected) {\r
- while (Simulation.TIMELINE.hasNext()) {\r
+ public void assertAfterSimulationIs(LongConsumer r, Bit... expected)\r
+ {\r
+ while (Simulation.TIMELINE.hasNext())\r
+ {\r
Simulation.TIMELINE.executeNext();\r
r.accept(Simulation.TIMELINE.getSimulationTime());\r
}\r
}\r
\r
@Override\r
- protected void compute() {\r
+ protected void compute()\r
+ {\r
super.compute();\r
System.out.println("update: value is " + Arrays.toString(getDisplayedValue()));\r
}\r
* @author Fabian Stemmler\r
*\r
*/\r
-public class Timeline {\r
+public class Timeline\r
+{\r
private PriorityQueue<InnerEvent> events;\r
private long currentTime = 0;\r
\r
private final List<Consumer<TimelineEvent>> eventAddedListener;\r
\r
- public Timeline(int initCapacity) {\r
- events = new PriorityQueue<InnerEvent>(initCapacity, (a, b) -> {\r
+ public Timeline(int initCapacity)\r
+ {\r
+ events = new PriorityQueue<InnerEvent>(initCapacity, (a, b) ->\r
+ {\r
long difference = a.getTiming() - b.getTiming();\r
if (difference == 0)\r
return 0;\r
eventAddedListener = new ArrayList<>();\r
}\r
\r
- public boolean hasNext() {\r
+ public boolean hasNext()\r
+ {\r
return !events.isEmpty();\r
}\r
\r
- public void executeNext() {\r
+ public void executeNext()\r
+ {\r
InnerEvent first = events.poll();\r
currentTime = first.getTiming();\r
first.run();\r
}\r
\r
- public void executeAll() {\r
+ public void executeAll()\r
+ {\r
while (hasNext())\r
executeNext();\r
}\r
* @return if it was possible to fulfil the goal in the given real world time.\r
* @author Christian Femers\r
*/\r
- public ExecutionResult executeUpTo(long timestamp, long stopMillis) {\r
- if (events.isEmpty()) {\r
+ public ExecutionResult executeUpTo(long timestamp, long stopMillis)\r
+ {\r
+ if (events.isEmpty())\r
+ {\r
currentTime = timestamp;\r
return ExecutionResult.NOTHING_DONE;\r
}\r
int checkStop = 0;\r
InnerEvent first = events.peek();\r
- while (first != null && first.getTiming() <= timestamp) {\r
+ while (first != null && first.getTiming() <= timestamp)\r
+ {\r
events.remove();\r
currentTime = first.getTiming();\r
first.run();\r
return ExecutionResult.DONE_IN_TIME;\r
}\r
\r
- public long getSimulationTime() {\r
+ public long getSimulationTime()\r
+ {\r
return currentTime;\r
}\r
\r
- public long nextEventTime() {\r
+ public long nextEventTime()\r
+ {\r
if (!hasNext())\r
return -1;\r
else\r
return events.peek().timing;\r
}\r
\r
- public void reset() {\r
+ public void reset()\r
+ {\r
events.clear();\r
currentTime = 0;\r
}\r
\r
- public void addEventAddedListener(Consumer<TimelineEvent> listener) {\r
+ public void addEventAddedListener(Consumer<TimelineEvent> listener)\r
+ {\r
eventAddedListener.add(listener);\r
}\r
\r
- public void removeEventAddedListener(Consumer<TimelineEvent> listener) {\r
+ public void removeEventAddedListener(Consumer<TimelineEvent> listener)\r
+ {\r
eventAddedListener.remove(listener);\r
}\r
\r
* @param function The {@link TimelineEventHandler} that will be executed, when the {@link InnerEvent} occurs on the timeline.\r
* @param relativeTiming The amount of MI ticks in which the {@link InnerEvent} is called, starting from the current time.\r
*/\r
- public void addEvent(TimelineEventHandler function, int relativeTiming) {\r
+ public void addEvent(TimelineEventHandler function, int relativeTiming)\r
+ {\r
long timing = currentTime + relativeTiming;\r
TimelineEvent event = new TimelineEvent(timing);\r
events.add(new InnerEvent(function, event, timing));\r
eventAddedListener.forEach(l -> l.accept(event));\r
}\r
\r
- private class InnerEvent {\r
+ private class InnerEvent\r
+ {\r
\r
private final long timing;\r
private final TimelineEventHandler function;\r
* @param function {@link TimelineEventHandler} to be executed when the {@link InnerEvent} occurs\r
* @param timing Point in the MI simulation {@link Timeline}, at which the {@link InnerEvent} is executed;\r
*/\r
- InnerEvent(TimelineEventHandler function, TimelineEvent event, long timing) {\r
+ InnerEvent(TimelineEventHandler function, TimelineEvent event, long timing)\r
+ {\r
this.function = function;\r
this.event = event;\r
this.timing = timing;\r
}\r
\r
- public long getTiming() {\r
+ public long getTiming()\r
+ {\r
return timing;\r
}\r
\r
- public void run() {\r
+ public void run()\r
+ {\r
function.handle(event);\r
}\r
\r
@Override\r
- public String toString() {\r
+ public String toString()\r
+ {\r
return event.toString();\r
}\r
}\r
\r
@Override\r
- public String toString() {\r
+ public String toString()\r
+ {\r
return "simulation time: " + currentTime + ", " + events.toString();\r
}\r
\r
- public static long toNanoseconds(long ticks) {\r
+ public static long toNanoseconds(long ticks)\r
+ {\r
return ticks; // TODO: Alter this when it has been determined how ticks should relate to real time.\r
}\r
\r
- public enum ExecutionResult {\r
+ public enum ExecutionResult\r
+ {\r
NOTHING_DONE, DONE_IN_TIME, RAN_OUT_OF_TIME\r
}\r
}
\ No newline at end of file
* @author Fabian Stemmler\r
*\r
*/\r
-public class TimelineEvent {\r
+public class TimelineEvent\r
+{\r
private final long timing;\r
\r
- TimelineEvent(long timing) {\r
+ TimelineEvent(long timing)\r
+ {\r
super();\r
this.timing = timing;\r
}\r
\r
- public long getTiming() {\r
+ public long getTiming()\r
+ {\r
return timing;\r
}\r
\r
- public String toString() {\r
+ public String toString()\r
+ {\r
return "timestamp: " + timing;\r
}\r
}
\ No newline at end of file
package era.mi.logic.timeline;\r
\r
-public interface TimelineEventHandler {\r
+public interface TimelineEventHandler\r
+{\r
public void handle(TimelineEvent e);\r
}
\ No newline at end of file
package era.mi.logic.wires;\r
\r
+import java.io.Closeable;\r
import java.util.ArrayList;\r
import java.util.Arrays;\r
import java.util.Iterator;\r
* @author Fabian Stemmler\r
*\r
*/\r
-public class WireArray {\r
+public class WireArray\r
+{\r
private Bit[] values;\r
public final int travelTime;\r
private List<WireArrayObserver> observers = new ArrayList<WireArrayObserver>();\r
public final int length;\r
- private List<WireArrayInput> inputs = new ArrayList<WireArrayInput>();\r
+ private List<WireArrayEnd> inputs = new ArrayList<WireArrayEnd>();\r
\r
- public WireArray(int length, int travelTime) {\r
+ public WireArray(int length, int travelTime)\r
+ {\r
if (length < 1)\r
throw new IllegalArgumentException(\r
String.format("Tried to create an array of wires with length %d, but a length of less than 1 makes no sense.", length));\r
initValues();\r
}\r
\r
- private void initValues() {\r
- values = Bit.Z.makeArray(length);\r
+ private void initValues()\r
+ {\r
+ values = Bit.U.makeArray(length);\r
}\r
\r
- private void recalculateSingleInput() {\r
- WireArrayInput input = inputs.get(0);\r
- if (!Arrays.equals(input.getValues(), values)) {\r
+ private void recalculateSingleInput()\r
+ {\r
+ WireArrayEnd input = inputs.get(0);\r
+ if (!Arrays.equals(input.getValues(), values))\r
+ {\r
Bit[] oldValues = values.clone();\r
System.arraycopy(input.getValues(), 0, values, 0, length);\r
notifyObservers(oldValues);\r
}\r
}\r
\r
- private void recalculateMultipleInputs() {\r
- Iterator<WireArrayInput> it = inputs.iterator();\r
+ private void recalculateMultipleInputs()\r
+ {\r
+ Iterator<WireArrayEnd> it = inputs.iterator();\r
Bit[] newValues = it.next().inputValues.clone();\r
\r
- while (it.hasNext()) {\r
- WireArrayInput input = it.next();\r
+ while (it.hasNext())\r
+ {\r
+ WireArrayEnd input = it.next();\r
Bit[] bits = input.getValues();\r
- for (int i = 0; i < length; i++) {\r
+ for (int i = 0; i < length; i++)\r
+ {\r
if (Bit.Z.equals(bits[i]) || newValues[i].equals(bits[i]))\r
continue;\r
else if (Bit.Z.equals(newValues[i]))\r
}\r
}\r
\r
- if (!Arrays.equals(newValues, values)) {\r
+ if (!Arrays.equals(newValues, values))\r
+ {\r
Bit[] oldValues = values;\r
values = newValues;\r
notifyObservers(oldValues);\r
}\r
}\r
\r
- private void recalculate() {\r
- switch (inputs.size()) {\r
+ private void recalculate()\r
+ {\r
+ switch (inputs.size())\r
+ {\r
case 0:\r
return;\r
case 1:\r
* \r
* @author Fabian Stemmler\r
*/\r
- public boolean hasNumericValue() {\r
- for (Bit b : values) {\r
+ public boolean hasNumericValue()\r
+ {\r
+ for (Bit b : values)\r
+ {\r
if (b != Bit.ZERO && b != Bit.ONE)\r
return false;\r
}\r
* \r
* @author Fabian Stemmler\r
*/\r
- public long getUnsignedValue() {\r
+ public long getUnsignedValue()\r
+ {\r
long val = 0;\r
long mask = 1;\r
- for (int i = 0; i < length; i++) {\r
- switch (values[i]) {\r
+ for (int i = 0; i < length; i++)\r
+ {\r
+ switch (values[i])\r
+ {\r
default:\r
case Z:\r
case X:\r
* \r
* @author Fabian Stemmler\r
*/\r
- public long getSignedValue() {\r
+ public long getSignedValue()\r
+ {\r
long val = getUnsignedValue();\r
long mask = 1 << (length - 1);\r
- if ((mask & val) != 0) {\r
+ if ((mask & val) != 0)\r
+ {\r
int shifts = 64 - length;\r
return (val << shifts) >> shifts;\r
}\r
* \r
* @author Fabian Stemmler\r
*/\r
- public Bit getValue() {\r
+ public Bit getValue()\r
+ {\r
return getValue(0);\r
}\r
\r
* \r
* @author Fabian Stemmler\r
*/\r
- public Bit getValue(int index) {\r
+ public Bit getValue(int index)\r
+ {\r
return values[index];\r
}\r
\r
- public Bit[] getValues(int start, int end) {\r
+ public Bit[] getValues(int start, int end)\r
+ {\r
int length = end - start;\r
Bit[] bits = new Bit[length];\r
System.arraycopy(values, start, bits, 0, length);\r
* \r
* @author Fabian Stemmler\r
*/\r
- public Bit[] getValues() {\r
+ public Bit[] getValues()\r
+ {\r
return values.clone();\r
}\r
\r
* \r
* @author Fabian Stemmler\r
*/\r
- public boolean addObserver(WireArrayObserver ob) {\r
+ public boolean addObserver(WireArrayObserver ob)\r
+ {\r
return observers.add(ob);\r
}\r
\r
- private void notifyObservers(Bit[] oldValues) {\r
+ private void notifyObservers(Bit[] oldValues)\r
+ {\r
for (WireArrayObserver o : observers)\r
o.update(this, oldValues);\r
}\r
\r
/**\r
- * Create and register a {@link WireArrayInput} object, which is tied to this {@link WireArray}.\r
+ * Create and register a {@link WireArrayEnd} object, which is tied to this {@link WireArray}.\r
*/\r
- public WireArrayInput createInput() {\r
- return new WireArrayInput(this);\r
+ public WireArrayEnd createInput()\r
+ {\r
+ return new WireArrayEnd(this);\r
}\r
\r
- private void registerInput(WireArrayInput toRegister) {\r
+ private void registerInput(WireArrayEnd toRegister)\r
+ {\r
inputs.add(toRegister);\r
}\r
\r
/**\r
- * A {@link WireArrayInput} feeds a constant signal into the {@link WireArray} it is tied to. The combination of all inputs determines\r
- * the {@link WireArray}s final value. X dominates all other inputs Z does not affect the final value, unless there are no other inputs\r
- * than Z 0 and 1 turn into X when they are mixed\r
+ * A {@link WireArrayEnd} feeds a constant signal into the {@link WireArray} it is tied to. The combination of all inputs determines the\r
+ * {@link WireArray}s final value. X dominates all other inputs Z does not affect the final value, unless there are no other inputs than\r
+ * Z 0 and 1 turn into X when they are mixed\r
* \r
* @author Fabian Stemmler\r
*/\r
- public class WireArrayInput {\r
+ public class WireArrayEnd implements Closeable\r
+ {\r
public final WireArray owner;\r
+ private boolean open;\r
private Bit[] inputValues;\r
\r
- private WireArrayInput(WireArray owner) {\r
+ private WireArrayEnd(WireArray owner)\r
+ {\r
super();\r
this.owner = owner;\r
+ open = true;\r
initValues();\r
owner.registerInput(this);\r
}\r
\r
- private void initValues() {\r
+ private void initValues()\r
+ {\r
inputValues = Bit.Z.makeArray(length);\r
}\r
\r
* \r
* @author Fabian Stemmler\r
*/\r
- public void feedSignals(Bit... newValues) {\r
- if (newValues.length == length) {\r
+ public void feedSignals(Bit... newValues)\r
+ {\r
+ if (newValues.length == length)\r
+ {\r
feedSignals(0, newValues);\r
} else\r
throw new IllegalArgumentException(\r
- String.format("Attempted to input %o bits instead of %o bits.", newValues.length, length));\r
+ String.format("Attempted to input %d bits instead of %d bits.", newValues.length, length));\r
}\r
\r
/**\r
* \r
* @author Fabian Stemmler\r
*/\r
- public void feedSignals(int startingBit, Bit... newValues) {\r
+ public void feedSignals(int startingBit, Bit... newValues)\r
+ {\r
+ if (!open)\r
+ throw new RuntimeException("Attempted to write to closed WireArrayEnd.");\r
Simulation.TIMELINE.addEvent((e) -> setValues(startingBit, newValues), travelTime);\r
}\r
\r
- private void setValues(int startingBit, Bit... newValues) {\r
+ private void setValues(int startingBit, Bit... newValues)\r
+ {\r
int exclLastIndex = startingBit + newValues.length;\r
if (length < exclLastIndex)\r
throw new ArrayIndexOutOfBoundsException(\r
- String.format("Attempted to input bits from index %o to %o when there are only %o wires.", startingBit,\r
+ String.format("Attempted to input bits from index %d to %d when there are only %d wires.", startingBit,\r
exclLastIndex - 1, length));\r
- if (!Arrays.equals(inputValues, startingBit, exclLastIndex, newValues, 0, newValues.length)) {\r
+ if (!Arrays.equals(inputValues, startingBit, exclLastIndex, newValues, 0, newValues.length))\r
+ {\r
System.arraycopy(newValues, 0, inputValues, startingBit, newValues.length);\r
owner.recalculate();\r
}\r
}\r
\r
/**\r
- * Returns a copy (safe to modify) of the values the {@link WireArrayInput} is currently feeding into the associated\r
+ * Returns a copy (safe to modify) of the values the {@link WireArrayEnd} is currently feeding into the associated\r
* {@link WireArray}.\r
*/\r
- public Bit[] getValues() {\r
+ public Bit[] getValues()\r
+ {\r
return inputValues.clone();\r
}\r
\r
/**\r
- * {@link WireArrayInput} now feeds Z into the associated {@link WireArray}.\r
+ * {@link WireArrayEnd} now feeds Z into the associated {@link WireArray}.\r
*/\r
- public void clearSignals() {\r
+ public void clearSignals()\r
+ {\r
feedSignals(Bit.Z.makeArray(length));\r
}\r
\r
- public Bit[] wireValuesExcludingMe() {\r
+ public Bit[] wireValuesExcludingMe()\r
+ {\r
Bit[] bits = Bit.Z.makeArray(length);\r
- for (WireArrayInput wai : inputs) {\r
+ for (WireArrayEnd wai : inputs)\r
+ {\r
if (wai == this)\r
continue;\r
Util.combineInto(bits, wai.getValues());\r
return bits;\r
}\r
\r
+ public Bit getWireValue()\r
+ {\r
+ return owner.getValue();\r
+ }\r
+\r
+ public Bit[] getWireValues()\r
+ {\r
+ return owner.getValues();\r
+ }\r
+\r
@Override\r
- public String toString() {\r
+ public String toString()\r
+ {\r
return Arrays.toString(inputValues);\r
}\r
+\r
+ @Override\r
+ public void close()\r
+ {\r
+ inputs.remove(this);\r
+ open = false;\r
+ }\r
}\r
\r
@Override\r
- public String toString() {\r
+ public String toString()\r
+ {\r
return String.format("wire 0x%08x value: %s inputs: %s", hashCode(), Arrays.toString(values), inputs);\r
}\r
\r
- public static WireArrayInput[] extractInputs(WireArray[] w) {\r
- WireArrayInput[] inputs = new WireArrayInput[w.length];\r
+ public static WireArrayEnd[] extractInputs(WireArray[] w)\r
+ {\r
+ WireArrayEnd[] inputs = new WireArrayEnd[w.length];\r
for (int i = 0; i < w.length; i++)\r
inputs[i] = w[i].createInput();\r
return inputs;\r
\r
import era.mi.logic.Bit;\r
\r
-public interface WireArrayObserver {\r
+public interface WireArrayObserver\r
+{\r
public void update(WireArray initiator, Bit[] oldValues);\r
}\r
projects / Mograsim.git / commitdiff