From 5bcdb0eddfe0fc4f256c3028221f0a19bf2a2380 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Mon, 18 Nov 2013 11:46:02 +0100 Subject: [PATCH] [#2852] Add jOOQ-xtend, an Open Source jOOQ extension for use with Eclipse's Xtend --- jOOQ-xtend/.classpath | 11 + jOOQ-xtend/.gitignore | 2 + jOOQ-xtend/.project | 40 + .../org.eclipse.core.resources.prefs | 5 + .../.settings/org.eclipse.core.runtime.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 390 ++++ jOOQ-xtend/.settings/org.eclipse.jdt.ui.prefs | 115 + .../.settings/org.eclipse.m2e.core.prefs | 4 + .../.settings/org.maven.ide.eclipse.prefs | 8 + jOOQ-xtend/LICENSE.txt | 22 + jOOQ-xtend/META-INF/MANIFEST.MF | 10 + jOOQ-xtend/build.properties | 5 + jOOQ-xtend/src/main/.gitignore | 1 + .../xtend/org/jooq/xtend/Conversions.xtend | 1907 +++++++++++++++++ jOOQ-xtend/src/test/.gitignore | 1 + .../xtend/test/XtendConversionsTest.xtend | 66 + 16 files changed, 2589 insertions(+) create mode 100644 jOOQ-xtend/.classpath create mode 100644 jOOQ-xtend/.gitignore create mode 100644 jOOQ-xtend/.project create mode 100644 jOOQ-xtend/.settings/org.eclipse.core.resources.prefs create mode 100644 jOOQ-xtend/.settings/org.eclipse.core.runtime.prefs create mode 100644 jOOQ-xtend/.settings/org.eclipse.jdt.core.prefs create mode 100644 jOOQ-xtend/.settings/org.eclipse.jdt.ui.prefs create mode 100644 jOOQ-xtend/.settings/org.eclipse.m2e.core.prefs create mode 100644 jOOQ-xtend/.settings/org.maven.ide.eclipse.prefs create mode 100644 jOOQ-xtend/LICENSE.txt create mode 100644 jOOQ-xtend/META-INF/MANIFEST.MF create mode 100644 jOOQ-xtend/build.properties create mode 100644 jOOQ-xtend/src/main/.gitignore create mode 100644 jOOQ-xtend/src/main/xtend/org/jooq/xtend/Conversions.xtend create mode 100644 jOOQ-xtend/src/test/.gitignore create mode 100644 jOOQ-xtend/src/test/xtend/org/jooq/xtend/test/XtendConversionsTest.xtend diff --git a/jOOQ-xtend/.classpath b/jOOQ-xtend/.classpath new file mode 100644 index 0000000000..e55fb07e12 --- /dev/null +++ b/jOOQ-xtend/.classpath @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/jOOQ-xtend/.gitignore b/jOOQ-xtend/.gitignore new file mode 100644 index 0000000000..6bbef7bfd3 --- /dev/null +++ b/jOOQ-xtend/.gitignore @@ -0,0 +1,2 @@ +/xtend-gen +/bin diff --git a/jOOQ-xtend/.project b/jOOQ-xtend/.project new file mode 100644 index 0000000000..8576201467 --- /dev/null +++ b/jOOQ-xtend/.project @@ -0,0 +1,40 @@ + + + jOOQ-xtend + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.xtend.shared.ui.xtendBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.xtend.shared.ui.xtendXPandNature + + diff --git a/jOOQ-xtend/.settings/org.eclipse.core.resources.prefs b/jOOQ-xtend/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000000..839d647eef --- /dev/null +++ b/jOOQ-xtend/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +encoding//src/main/java=UTF-8 +encoding//src/main/resources=UTF-8 +encoding//src/test/java=UTF-8 +encoding/=UTF-8 diff --git a/jOOQ-xtend/.settings/org.eclipse.core.runtime.prefs b/jOOQ-xtend/.settings/org.eclipse.core.runtime.prefs new file mode 100644 index 0000000000..5a0ad22d2a --- /dev/null +++ b/jOOQ-xtend/.settings/org.eclipse.core.runtime.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +line.separator=\n diff --git a/jOOQ-xtend/.settings/org.eclipse.jdt.core.prefs b/jOOQ-xtend/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000000..278b06feb7 --- /dev/null +++ b/jOOQ-xtend/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,390 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore +org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault +org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable +org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.6 +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.doc.comment.support=enabled +org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.autoboxing=ignore +org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning +org.eclipse.jdt.core.compiler.problem.deadCode=warning +org.eclipse.jdt.core.compiler.problem.deprecation=warning +org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled +org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled +org.eclipse.jdt.core.compiler.problem.discouragedReference=warning +org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +org.eclipse.jdt.core.compiler.problem.fieldHiding=warning +org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning +org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning +org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled +org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning +org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore +org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning +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=protected +org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning +org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=warning +org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=all_standard_tags +org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=warning +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=warning +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore +org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error +org.eclipse.jdt.core.compiler.problem.nullReference=error +org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error +org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning +org.eclipse.jdt.core.compiler.problem.potentialNullReference=warning +org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning +org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning +org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning +org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning +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=warning +org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning +org.eclipse.jdt.core.compiler.problem.unclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning +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=warning +org.eclipse.jdt.core.compiler.problem.unusedLabel=warning +org.eclipse.jdt.core.compiler.problem.unusedLocal=warning +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=warning +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=warning +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning +org.eclipse.jdt.core.compiler.source=1.6 +org.eclipse.jdt.core.formatter.align_type_members_on_columns=true +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 +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=49 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0 +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_resources_in_try=80 +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.alignment_for_union_type_in_multicatch=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=0 +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_in_block_comment=true +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true +org.eclipse.jdt.core.formatter.comment.format_block_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=do not insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true +org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true +org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=1 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=1 +org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off +org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true +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=true +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=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_method=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=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_annotation_on_type=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_label=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=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=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=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=do not 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_try=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_semicolon_in_try_resources=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_try=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_try=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_semicolon_in_try_resources=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.join_lines_in_comments=true +org.eclipse.jdt.core.formatter.join_wrapped_lines=true +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=120 +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=space +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.use_on_off_tags=false +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true +org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true +org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true diff --git a/jOOQ-xtend/.settings/org.eclipse.jdt.ui.prefs b/jOOQ-xtend/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 0000000000..bed9e53e5a --- /dev/null +++ b/jOOQ-xtend/.settings/org.eclipse.jdt.ui.prefs @@ -0,0 +1,115 @@ +cleanup.add_default_serial_version_id=false +cleanup.add_generated_serial_version_id=true +cleanup.add_missing_annotations=true +cleanup.add_missing_deprecated_annotations=true +cleanup.add_missing_methods=false +cleanup.add_missing_nls_tags=false +cleanup.add_missing_override_annotations=true +cleanup.add_missing_override_annotations_interface_methods=true +cleanup.add_serial_version_id=true +cleanup.always_use_blocks=true +cleanup.always_use_parentheses_in_expressions=false +cleanup.always_use_this_for_non_static_field_access=true +cleanup.always_use_this_for_non_static_method_access=false +cleanup.convert_to_enhanced_for_loop=false +cleanup.correct_indentation=true +cleanup.format_source_code=false +cleanup.format_source_code_changes_only=false +cleanup.make_local_variable_final=true +cleanup.make_parameters_final=false +cleanup.make_private_fields_final=true +cleanup.make_type_abstract_if_missing_method=false +cleanup.make_variable_declarations_final=false +cleanup.never_use_blocks=false +cleanup.never_use_parentheses_in_expressions=true +cleanup.organize_imports=true +cleanup.qualify_static_field_accesses_with_declaring_class=false +cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true +cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true +cleanup.qualify_static_member_accesses_with_declaring_class=true +cleanup.qualify_static_method_accesses_with_declaring_class=false +cleanup.remove_private_constructors=true +cleanup.remove_trailing_whitespaces=true +cleanup.remove_trailing_whitespaces_all=true +cleanup.remove_trailing_whitespaces_ignore_empty=false +cleanup.remove_unnecessary_casts=true +cleanup.remove_unnecessary_nls_tags=true +cleanup.remove_unused_imports=true +cleanup.remove_unused_local_variables=false +cleanup.remove_unused_private_fields=true +cleanup.remove_unused_private_members=false +cleanup.remove_unused_private_methods=true +cleanup.remove_unused_private_types=true +cleanup.sort_members=false +cleanup.sort_members_all=false +cleanup.use_blocks=true +cleanup.use_blocks_only_for_return_and_throw=false +cleanup.use_parentheses_in_expressions=false +cleanup.use_this_for_non_static_field_access=false +cleanup.use_this_for_non_static_field_access_only_if_necessary=false +cleanup.use_this_for_non_static_method_access=false +cleanup.use_this_for_non_static_method_access_only_if_necessary=true +cleanup_profile=_jOOQ +cleanup_settings_version=2 +eclipse.preferences.version=1 +editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true +formatter_profile=_jOOQ +formatter_settings_version=12 +org.eclipse.jdt.ui.ignorelowercasenames=true +org.eclipse.jdt.ui.importorder=java;javax;org.jooq;org;com; +org.eclipse.jdt.ui.javadoc=false +org.eclipse.jdt.ui.ondemandthreshold=99999 +org.eclipse.jdt.ui.staticondemandthreshold=99999 +org.eclipse.jdt.ui.text.custom_code_templates= +sp_cleanup.add_default_serial_version_id=true +sp_cleanup.add_generated_serial_version_id=false +sp_cleanup.add_missing_annotations=true +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=true +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=false +sp_cleanup.format_source_code_changes_only=false +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=true +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=true +sp_cleanup.remove_unnecessary_nls_tags=false +sp_cleanup.remove_unused_imports=true +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/jOOQ-xtend/.settings/org.eclipse.m2e.core.prefs b/jOOQ-xtend/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000000..f897a7f1cb --- /dev/null +++ b/jOOQ-xtend/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/jOOQ-xtend/.settings/org.maven.ide.eclipse.prefs b/jOOQ-xtend/.settings/org.maven.ide.eclipse.prefs new file mode 100644 index 0000000000..df2ab6d230 --- /dev/null +++ b/jOOQ-xtend/.settings/org.maven.ide.eclipse.prefs @@ -0,0 +1,8 @@ +#Sun Apr 10 10:03:42 CEST 2011 +activeProfiles= +eclipse.preferences.version=1 +fullBuildGoals=process-test-resources +resolveWorkspaceProjects=true +resourceFilterGoals=process-resources resources\:testResources +skipCompilerPlugin=true +version=1 diff --git a/jOOQ-xtend/LICENSE.txt b/jOOQ-xtend/LICENSE.txt new file mode 100644 index 0000000000..7918e1c9da --- /dev/null +++ b/jOOQ-xtend/LICENSE.txt @@ -0,0 +1,22 @@ +Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com) +All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +Other licenses: +----------------------------------------------------------------------------- +Commercial licenses for this work are available. These replace the above +ASL 2.0 and offer limited warranties, support, maintenance, and commercial +database integrations. + +For more information, please visit: http://www.jooq.org/licenses \ No newline at end of file diff --git a/jOOQ-xtend/META-INF/MANIFEST.MF b/jOOQ-xtend/META-INF/MANIFEST.MF new file mode 100644 index 0000000000..f6b54ae1d2 --- /dev/null +++ b/jOOQ-xtend/META-INF/MANIFEST.MF @@ -0,0 +1,10 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: Xtend Tutorial +Bundle-SymbolicName: jOOQ-tools +Bundle-Version: 2.3.0.qualifier +Bundle-Vendor: Eclipse Tools Project +Require-Bundle: org.eclipse.xtext.xbase.lib;bundle-version="2.3.0", + org.eclipse.xtend.lib;bundle-version="2.3.0", + org.junit4 +Bundle-RequiredExecutionEnvironment: J2SE-1.5 diff --git a/jOOQ-xtend/build.properties b/jOOQ-xtend/build.properties new file mode 100644 index 0000000000..d8e2f0e92e --- /dev/null +++ b/jOOQ-xtend/build.properties @@ -0,0 +1,5 @@ +source.. = src/,\ + xtend-gen/ +output.. = bin/ +bin.includes = META-INF/,\ + . diff --git a/jOOQ-xtend/src/main/.gitignore b/jOOQ-xtend/src/main/.gitignore new file mode 100644 index 0000000000..04b73cb01e --- /dev/null +++ b/jOOQ-xtend/src/main/.gitignore @@ -0,0 +1 @@ +/xtend-gen diff --git a/jOOQ-xtend/src/main/xtend/org/jooq/xtend/Conversions.xtend b/jOOQ-xtend/src/main/xtend/org/jooq/xtend/Conversions.xtend new file mode 100644 index 0000000000..0b917274e2 --- /dev/null +++ b/jOOQ-xtend/src/main/xtend/org/jooq/xtend/Conversions.xtend @@ -0,0 +1,1907 @@ +/** + * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com) + * All rights reserved. + * + * This work is dual-licensed + * - under the Apache Software License 2.0 (the "ASL") + * - under the jOOQ License and Maintenance Agreement (the "jOOQ License") + * ============================================================================= + * You may choose which license applies to you: + * + * - If you're using this work with Open Source databases, you may choose + * either ASL or jOOQ License. + * - If you're using this work with at least one commercial database, you must + * choose jOOQ License + * + * For more information, please visit http://www.jooq.org/licenses + * + * Apache Software License 2.0: + * ----------------------------------------------------------------------------- + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * jOOQ License and Maintenance Agreement: + * ----------------------------------------------------------------------------- + * Data Geekery grants the Customer the non-exclusive, timely limited and + * non-transferable license to install and use the Software under the terms of + * the jOOQ License and Maintenance Agreement. + * + * This library is distributed with a LIMITED WARRANTY. See the jOOQ License + * and Maintenance Agreement for more details: http://www.jooq.org/licensing + */ +package org.jooq.xtend + +import javax.annotation.Generated + +import org.jooq.Condition +import org.jooq.Field +import org.jooq.QuantifiedSelect +import org.jooq.Record +import org.jooq.Record1 +import org.jooq.Record2 +import org.jooq.Record3 +import org.jooq.Record4 +import org.jooq.Record5 +import org.jooq.Record6 +import org.jooq.Record7 +import org.jooq.Record8 +import org.jooq.Record9 +import org.jooq.Record10 +import org.jooq.Record11 +import org.jooq.Record12 +import org.jooq.Record13 +import org.jooq.Record14 +import org.jooq.Record15 +import org.jooq.Record16 +import org.jooq.Record17 +import org.jooq.Record18 +import org.jooq.Record19 +import org.jooq.Record20 +import org.jooq.Record21 +import org.jooq.Record22 +import org.jooq.Row +import org.jooq.RowN +import org.jooq.Row1 +import org.jooq.Row2 +import org.jooq.Row3 +import org.jooq.Row4 +import org.jooq.Row5 +import org.jooq.Row6 +import org.jooq.Row7 +import org.jooq.Row8 +import org.jooq.Row9 +import org.jooq.Row10 +import org.jooq.Row11 +import org.jooq.Row12 +import org.jooq.Row13 +import org.jooq.Row14 +import org.jooq.Row15 +import org.jooq.Row16 +import org.jooq.Row17 +import org.jooq.Row18 +import org.jooq.Row19 +import org.jooq.Row20 +import org.jooq.Row21 +import org.jooq.Row22 +import org.jooq.Select + +import org.jooq.impl.DSL + +/** + * jOOQ type conversions used to enhance the jOOQ Java API with Xtend operators. + * + * @author Lukas Eder + * @see http://www.eclipse.org/xtend/documentation.html#operators + */ +@Generated("This class was generated using jOOQ-tools") +class Conversions { + + def static operator_or(Condition c1, Condition c2) { + c1.or(c2); + } + + def static operator_and(Condition c1, Condition c2) { + c1.and(c2); + } + + def static operator_tripleEquals(Field f1, T f2) { + f1.eq(f2) + } + + def static operator_tripleEquals(Field f1, Field f2) { + f1.eq(f2) + } + + def static operator_tripleEquals(Field f1, Select> f2) { + f1.eq(f2) + } + + def static operator_tripleEquals(Field f1, QuantifiedSelect> f2) { + f1.eq(f2) + } + + def static operator_tripleEquals(RowN r1, RowN r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(RowN r1, Record r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(RowN r1, Select r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row1 r1, Row1 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row1 r1, Record1 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row1 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row2 r1, Row2 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row2 r1, Record2 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row2 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row3 r1, Row3 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row3 r1, Record3 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row3 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row4 r1, Row4 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row4 r1, Record4 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row4 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row5 r1, Row5 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row5 r1, Record5 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row5 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row6 r1, Row6 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row6 r1, Record6 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row6 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row7 r1, Row7 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row7 r1, Record7 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row7 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row8 r1, Row8 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row8 r1, Record8 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row8 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row9 r1, Row9 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row9 r1, Record9 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row9 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row10 r1, Row10 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row10 r1, Record10 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row10 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row11 r1, Row11 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row11 r1, Record11 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row11 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row12 r1, Row12 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row12 r1, Record12 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row12 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row13 r1, Row13 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row13 r1, Record13 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row13 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row14 r1, Row14 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row14 r1, Record14 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row14 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row15 r1, Row15 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row15 r1, Record15 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row15 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row16 r1, Row16 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row16 r1, Record16 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row16 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row17 r1, Row17 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row17 r1, Record17 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row17 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row18 r1, Row18 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row18 r1, Record18 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row18 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row19 r1, Row19 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row19 r1, Record19 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row19 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row20 r1, Row20 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row20 r1, Record20 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row20 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row21 r1, Row21 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row21 r1, Record21 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row21 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row22 r1, Row22 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row22 r1, Record22 r2) { + r1.eq(r2) + } + + def static operator_tripleEquals(Row22 r1, Select> r2) { + r1.eq(r2) + } + + def static operator_tripleNotEquals(Field f1, T f2) { + f1.ne(f2) + } + + def static operator_tripleNotEquals(Field f1, Field f2) { + f1.ne(f2) + } + + def static operator_tripleNotEquals(Field f1, Select> f2) { + f1.ne(f2) + } + + def static operator_tripleNotEquals(Field f1, QuantifiedSelect> f2) { + f1.ne(f2) + } + + def static operator_tripleNotEquals(Row1 r1, Row1 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row1 r1, Record1 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row1 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row2 r1, Row2 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row2 r1, Record2 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row2 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row3 r1, Row3 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row3 r1, Record3 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row3 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row4 r1, Row4 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row4 r1, Record4 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row4 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row5 r1, Row5 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row5 r1, Record5 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row5 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row6 r1, Row6 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row6 r1, Record6 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row6 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row7 r1, Row7 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row7 r1, Record7 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row7 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row8 r1, Row8 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row8 r1, Record8 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row8 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row9 r1, Row9 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row9 r1, Record9 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row9 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row10 r1, Row10 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row10 r1, Record10 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row10 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row11 r1, Row11 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row11 r1, Record11 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row11 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row12 r1, Row12 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row12 r1, Record12 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row12 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row13 r1, Row13 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row13 r1, Record13 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row13 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row14 r1, Row14 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row14 r1, Record14 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row14 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row15 r1, Row15 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row15 r1, Record15 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row15 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row16 r1, Row16 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row16 r1, Record16 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row16 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row17 r1, Row17 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row17 r1, Record17 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row17 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row18 r1, Row18 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row18 r1, Record18 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row18 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row19 r1, Row19 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row19 r1, Record19 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row19 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row20 r1, Row20 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row20 r1, Record20 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row20 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row21 r1, Row21 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row21 r1, Record21 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row21 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row22 r1, Row22 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row22 r1, Record22 r2) { + r1.ne(r2) + } + + def static operator_tripleNotEquals(Row22 r1, Select> r2) { + r1.ne(r2) + } + + def static operator_lessThan(Field f1, T f2) { + f1.lt(f2) + } + + def static operator_lessThan(Field f1, Field f2) { + f1.lt(f2) + } + + def static operator_lessThan(Field f1, Select> f2) { + f1.lt(f2) + } + + def static operator_lessThan(Field f1, QuantifiedSelect> f2) { + f1.lt(f2) + } + + def static operator_lessThan(Row1 r1, Row1 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row1 r1, Record1 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row1 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row2 r1, Row2 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row2 r1, Record2 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row2 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row3 r1, Row3 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row3 r1, Record3 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row3 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row4 r1, Row4 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row4 r1, Record4 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row4 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row5 r1, Row5 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row5 r1, Record5 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row5 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row6 r1, Row6 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row6 r1, Record6 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row6 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row7 r1, Row7 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row7 r1, Record7 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row7 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row8 r1, Row8 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row8 r1, Record8 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row8 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row9 r1, Row9 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row9 r1, Record9 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row9 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row10 r1, Row10 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row10 r1, Record10 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row10 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row11 r1, Row11 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row11 r1, Record11 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row11 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row12 r1, Row12 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row12 r1, Record12 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row12 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row13 r1, Row13 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row13 r1, Record13 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row13 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row14 r1, Row14 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row14 r1, Record14 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row14 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row15 r1, Row15 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row15 r1, Record15 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row15 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row16 r1, Row16 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row16 r1, Record16 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row16 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row17 r1, Row17 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row17 r1, Record17 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row17 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row18 r1, Row18 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row18 r1, Record18 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row18 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row19 r1, Row19 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row19 r1, Record19 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row19 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row20 r1, Row20 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row20 r1, Record20 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row20 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row21 r1, Row21 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row21 r1, Record21 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row21 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row22 r1, Row22 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row22 r1, Record22 r2) { + r1.lt(r2) + } + + def static operator_lessThan(Row22 r1, Select> r2) { + r1.lt(r2) + } + + def static operator_greaterThan(Field f1, T f2) { + f1.gt(f2) + } + + def static operator_greaterThan(Field f1, Field f2) { + f1.gt(f2) + } + + def static operator_greaterThan(Field f1, Select> f2) { + f1.gt(f2) + } + + def static operator_greaterThan(Field f1, QuantifiedSelect> f2) { + f1.gt(f2) + } + + def static operator_greaterThan(Row1 r1, Row1 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row1 r1, Record1 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row1 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row2 r1, Row2 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row2 r1, Record2 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row2 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row3 r1, Row3 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row3 r1, Record3 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row3 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row4 r1, Row4 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row4 r1, Record4 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row4 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row5 r1, Row5 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row5 r1, Record5 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row5 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row6 r1, Row6 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row6 r1, Record6 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row6 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row7 r1, Row7 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row7 r1, Record7 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row7 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row8 r1, Row8 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row8 r1, Record8 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row8 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row9 r1, Row9 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row9 r1, Record9 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row9 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row10 r1, Row10 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row10 r1, Record10 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row10 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row11 r1, Row11 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row11 r1, Record11 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row11 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row12 r1, Row12 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row12 r1, Record12 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row12 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row13 r1, Row13 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row13 r1, Record13 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row13 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row14 r1, Row14 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row14 r1, Record14 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row14 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row15 r1, Row15 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row15 r1, Record15 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row15 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row16 r1, Row16 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row16 r1, Record16 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row16 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row17 r1, Row17 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row17 r1, Record17 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row17 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row18 r1, Row18 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row18 r1, Record18 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row18 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row19 r1, Row19 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row19 r1, Record19 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row19 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row20 r1, Row20 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row20 r1, Record20 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row20 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row21 r1, Row21 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row21 r1, Record21 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row21 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row22 r1, Row22 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row22 r1, Record22 r2) { + r1.gt(r2) + } + + def static operator_greaterThan(Row22 r1, Select> r2) { + r1.gt(r2) + } + + def static operator_lessEqualsThan(Field f1, T f2) { + f1.le(f2) + } + + def static operator_lessEqualsThan(Field f1, Field f2) { + f1.le(f2) + } + + def static operator_lessEqualsThan(Field f1, Select> f2) { + f1.le(f2) + } + + def static operator_lessEqualsThan(Field f1, QuantifiedSelect> f2) { + f1.le(f2) + } + + def static operator_lessEqualsThan(Row1 r1, Row1 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row1 r1, Record1 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row1 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row2 r1, Row2 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row2 r1, Record2 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row2 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row3 r1, Row3 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row3 r1, Record3 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row3 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row4 r1, Row4 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row4 r1, Record4 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row4 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row5 r1, Row5 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row5 r1, Record5 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row5 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row6 r1, Row6 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row6 r1, Record6 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row6 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row7 r1, Row7 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row7 r1, Record7 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row7 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row8 r1, Row8 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row8 r1, Record8 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row8 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row9 r1, Row9 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row9 r1, Record9 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row9 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row10 r1, Row10 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row10 r1, Record10 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row10 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row11 r1, Row11 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row11 r1, Record11 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row11 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row12 r1, Row12 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row12 r1, Record12 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row12 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row13 r1, Row13 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row13 r1, Record13 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row13 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row14 r1, Row14 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row14 r1, Record14 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row14 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row15 r1, Row15 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row15 r1, Record15 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row15 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row16 r1, Row16 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row16 r1, Record16 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row16 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row17 r1, Row17 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row17 r1, Record17 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row17 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row18 r1, Row18 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row18 r1, Record18 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row18 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row19 r1, Row19 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row19 r1, Record19 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row19 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row20 r1, Row20 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row20 r1, Record20 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row20 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row21 r1, Row21 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row21 r1, Record21 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row21 r1, Select> r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row22 r1, Row22 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row22 r1, Record22 r2) { + r1.le(r2) + } + + def static operator_lessEqualsThan(Row22 r1, Select> r2) { + r1.le(r2) + } + + def static operator_greaterEqualsThan(Field f1, T f2) { + f1.ge(f2) + } + + def static operator_greaterEqualsThan(Field f1, Field f2) { + f1.ge(f2) + } + + def static operator_greaterEqualsThan(Field f1, Select> f2) { + f1.ge(f2) + } + + def static operator_greaterEqualsThan(Field f1, QuantifiedSelect> f2) { + f1.ge(f2) + } + + def static operator_greaterEqualsThan(Row1 r1, Row1 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row1 r1, Record1 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row1 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row2 r1, Row2 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row2 r1, Record2 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row2 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row3 r1, Row3 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row3 r1, Record3 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row3 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row4 r1, Row4 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row4 r1, Record4 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row4 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row5 r1, Row5 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row5 r1, Record5 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row5 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row6 r1, Row6 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row6 r1, Record6 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row6 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row7 r1, Row7 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row7 r1, Record7 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row7 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row8 r1, Row8 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row8 r1, Record8 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row8 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row9 r1, Row9 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row9 r1, Record9 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row9 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row10 r1, Row10 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row10 r1, Record10 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row10 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row11 r1, Row11 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row11 r1, Record11 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row11 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row12 r1, Row12 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row12 r1, Record12 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row12 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row13 r1, Row13 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row13 r1, Record13 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row13 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row14 r1, Row14 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row14 r1, Record14 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row14 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row15 r1, Row15 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row15 r1, Record15 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row15 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row16 r1, Row16 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row16 r1, Record16 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row16 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row17 r1, Row17 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row17 r1, Record17 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row17 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row18 r1, Row18 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row18 r1, Record18 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row18 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row19 r1, Row19 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row19 r1, Record19 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row19 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row20 r1, Row20 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row20 r1, Record20 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row20 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row21 r1, Row21 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row21 r1, Record21 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row21 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row22 r1, Row22 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row22 r1, Record22 r2) { + r1.ge(r2) + } + + def static operator_greaterEqualsThan(Row22 r1, Select> r2) { + r1.ge(r2) + } + + def static operator_upTo(Field f1, Integer f2) { + DSL::generateSeries(f1, DSL::value(f2)) + } + + def static operator_upTo(Field f1, Field f2) { + DSL::generateSeries(f1, f2) + } + + def static operator_doubleLessThan(Field f1, T f2) { + DSL::shl(f1, f2) + } + + def static operator_doubleLessThan(Field f1, Field f2) { + DSL::shl(f1, f2) + } + + def static operator_doubleGreaterThan(Field f1, T f2) { + DSL::shr(f1, f2) + } + + def static operator_doubleGreaterThan(Field f1, Field f2) { + DSL::shr(f1, f2) + } + + def static operator_diamond(Field f1, T f2) { + f1.ne(f2) + } + + def static operator_elvis(Field f1, T f2) { + DSL::nvl(f1, f2) + } + + def static operator_elvis(Field f1, Field f2) { + DSL::nvl(f1, f2) + } + + def static operator_spaceship(Field f1, T f2) { + f1.isNotDistinctFrom(f2) + } + + def static operator_spaceship(Field f1, Field f2) { + f1.isNotDistinctFrom(f2) + } + + def static operator_plus(Field f1, T f2) { + f1.add(f2) + } + + def static operator_plus(Field f1, Field f2) { + f1.add(f2) + } + + def static operator_minus(Field f1, T f2) { + f1.sub(f2) + } + + def static operator_minus(Field f1, Field f2) { + f1.sub(f2) + } + + def static operator_multiply(Field f1, T f2) { + f1.mul(f2) + } + + def static operator_multiply(Field f1, Field f2) { + f1.mul(f2) + } + + def static operator_divide(Field f1, T f2) { + f1.div(f2) + } + + def static operator_divide(Field f1, Field f2) { + f1.div(f2) + } + + def static operator_modulo(Field f1, T f2) { + f1.mod(f2) + } + + def static operator_modulo(Field f1, Field f2) { + f1.mod(f2) + } + + def static operator_power(Field f1, T f2) { + DSL::power(f1, f2) + } + + def static operator_power(Field f1, Field f2) { + DSL::power(f1, f2) + } + + def static operator_not(Condition c) { + c.not() + } + + def static operator_minus(Field f) { + f.neg(); + } +} diff --git a/jOOQ-xtend/src/test/.gitignore b/jOOQ-xtend/src/test/.gitignore new file mode 100644 index 0000000000..04b73cb01e --- /dev/null +++ b/jOOQ-xtend/src/test/.gitignore @@ -0,0 +1 @@ +/xtend-gen diff --git a/jOOQ-xtend/src/test/xtend/org/jooq/xtend/test/XtendConversionsTest.xtend b/jOOQ-xtend/src/test/xtend/org/jooq/xtend/test/XtendConversionsTest.xtend new file mode 100644 index 0000000000..193062ab8b --- /dev/null +++ b/jOOQ-xtend/src/test/xtend/org/jooq/xtend/test/XtendConversionsTest.xtend @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com) + * All rights reserved. + * + * This work is dual-licensed + * - under the Apache Software License 2.0 (the "ASL") + * - under the jOOQ License and Maintenance Agreement (the "jOOQ License") + * ============================================================================= + * You may choose which license applies to you: + * + * - If you're using this work with Open Source databases, you may choose + * either ASL or jOOQ License. + * - If you're using this work with at least one commercial database, you must + * choose jOOQ License + * + * For more information, please visit http://www.jooq.org/licenses + * + * Apache Software License 2.0: + * ----------------------------------------------------------------------------- + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * jOOQ License and Maintenance Agreement: + * ----------------------------------------------------------------------------- + * Data Geekery grants the Customer the non-exclusive, timely limited and + * non-transferable license to install and use the Software under the terms of + * the jOOQ License and Maintenance Agreement. + * + * This library is distributed with a LIMITED WARRANTY. See the jOOQ License + * and Maintenance Agreement for more details: http://www.jooq.org/licensing + */ +package org.jooq.xtend.test + +import java.sql.DriverManager +import static extension org.jooq.xtend.Conversions.* + +import org.jooq.impl.DSL +import org.jooq.Record2 +import org.jooq.Select + +import static org.jooq.impl.DSL.* + +/** + * @author Lukas Eder + */ +class XtendConversionsTest { + + def static void main(String[] args) { + Class::forName("org.h2.Driver") + using(DriverManager::getConnection("jdbc:h2:~/test", "sa", "")) + + val r = row(inline(1), inline("a")) + val s = (select(inline(2), inline("b"))) as Select> + // val c = r > s + org.jooq.xtend.Conversions::operator_greaterThan(r, r) + } +} \ No newline at end of file