From 751b20ea51a6731793df6b9c83ac7879c4d8d6da Mon Sep 17 00:00:00 2001 From: lukaseder Date: Thu, 20 Apr 2017 16:08:36 +0200 Subject: [PATCH] [#6109] Prefer Java 8 syntax (method references, lambda expressions) in manual example --- .../resources/org/jooq/web/manual-2.6.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.0.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.1.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.2.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.3.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.4.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.5.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.6.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.7.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.8.xml | 30 +++++++++++-------- .../resources/org/jooq/web/manual-3.9.xml | 30 +++++++++++-------- 11 files changed, 187 insertions(+), 143 deletions(-) diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-2.6.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-2.6.xml index 0997f50e03..fe494a89f7 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-2.6.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-2.6.xml @@ -5694,23 +5694,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

See also the manual's section about the , which provides similar features diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.0.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.0.xml index dfe95528a7..c517403f99 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.0.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.0.xml @@ -6701,23 +6701,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

See also the manual's section about the , which provides similar features diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.1.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.1.xml index a72d964742..f218653ab5 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.1.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.1.xml @@ -7041,23 +7041,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.2.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.2.xml index f348bfd712..95fe76adff 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.2.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.2.xml @@ -7306,23 +7306,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.3.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.3.xml index 87c874b38d..c03c2a003f 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.3.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.3.xml @@ -8162,23 +8162,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.4.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.4.xml index 4f66dae08a..5cd5d3318f 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.4.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.4.xml @@ -9020,23 +9020,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.5.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.5.xml index 8bddc4ed39..087d178c96 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.5.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.5.xml @@ -9447,23 +9447,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.6.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.6.xml index 06894abbab..11afd29549 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.6.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.6.xml @@ -9834,23 +9834,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.7.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.7.xml index 53a044ceef..b54fc784cb 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.7.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.7.xml @@ -10091,23 +10091,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.8.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.8.xml index 137d4703f4..aa3556f8cd 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.8.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.8.xml @@ -10180,23 +10180,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your . diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.9.xml b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.9.xml index 6494d15a7f..fa91ea81cd 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.9.xml +++ b/jOOQ-manual/src/main/resources/org/jooq/web/manual-3.9.xml @@ -10263,23 +10263,27 @@ List ids = create.selectFrom(BOOK) .orderBy(BOOK.ID) .fetch() - .map(new RecordMapper() { + .map(BookRecord::getId); + +// Or more concisely, as fetch().map(mapper) can be written as fetch(mapper): +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(BookRecord::getId); + +// Or using a lambda expression: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(book -> book.getId()); + +// Of course, the lambda could be expanded into the following anonymous RecordMapper: +create.selectFrom(BOOK) + .orderBy(BOOK.ID) + .fetch(new RecordMapper() { @Override public Integer map(BookRecord book) { return book.getId(); } - }); - -// Or more concisely -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(new RecordMapper() {...}); - -// Or even more concisely with Java 8's lambda expressions: -create.selectFrom(BOOK) - .orderBy(BOOK.ID) - .fetch(book -> book.getId()); -]]> + });]]>

Your custom RecordMapper types can be used automatically through jOOQ's , by injecting a into your .