Date: Mon, 17 Aug 2020 19:49:00 +0300
Subject: [PATCH 13/18] Edit readme
---
visitor/README.md | 48 ++++++++++++++++++++++++++++++-----------------
1 file changed, 31 insertions(+), 17 deletions(-)
diff --git a/visitor/README.md b/visitor/README.md
index c97e97120..75a032a47 100644
--- a/visitor/README.md
+++ b/visitor/README.md
@@ -9,13 +9,17 @@ tags:
---
## Intent
-Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.
+
+Represent an operation to be performed on the elements of an object structure. Visitor lets you
+define a new operation without changing the classes of the elements on which it operates.
## Explanation
Real world example
-> Consider a tree structure with army units. Commander has two sergeants under it and each sergeant has three soldiers under them. Given that the hierarchy implements the visitor pattern, we can easily create new objects that interact with the commander, sergeants, soldiers or all of them.
+> Consider a tree structure with army units. Commander has two sergeants under it and each sergeant
+> has three soldiers under them. Given that the hierarchy implements the visitor pattern, we can
+> easily create new objects that interact with the commander, sergeants, soldiers or all of them.
In plain words
@@ -23,7 +27,10 @@ In plain words
Wikipedia says
-> In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying the structures.
+> In object-oriented programming and software engineering, the visitor design pattern is a way of
+> separating an algorithm from an object structure on which it operates. A practical result of this
+> separation is the ability to add new operations to existing object structures without modifying
+> the structures.
**Programmatic Example**
@@ -111,7 +118,7 @@ public class Soldier extends Unit {
}
```
-And then some concrete visitors.
+Here are then some concrete visitors.
```java
public class CommanderVisitor implements UnitVisitor {
@@ -175,32 +182,39 @@ public class SoldierVisitor implements UnitVisitor {
}
```
-Finally we can show the power of visitors in action.
+Finally, we can show the power of visitors in action.
```java
commander.accept(new SoldierVisitor());
-// Greetings soldier
-// Greetings soldier
-// Greetings soldier
-// Greetings soldier
-// Greetings soldier
-// Greetings soldier
commander.accept(new SergeantVisitor());
-// Hello sergeant
-// Hello sergeant
commander.accept(new CommanderVisitor());
-// Good to see you commander
+```
+
+Program output:
+
+```
+Greetings soldier
+Greetings soldier
+Greetings soldier
+Greetings soldier
+Greetings soldier
+Greetings soldier
+Hello sergeant
+Hello sergeant
+Good to see you commander
```
## Class diagram
+
## Applicability
+
Use the Visitor pattern when
-* An object structure contains many classes of objects with differing interfaces, and you want to perform operations on these objects that depend on their concrete classes
-* Many distinct and unrelated operations need to be performed on objects in an object structure, and you want to avoid "polluting" their classes with these operations. Visitor lets you keep related operations together by defining them in one class. When the object structure is shared by many applications, use Visitor to put operations in just those applications that need them
-* The classes defining the object structure rarely change, but you often want to define new operations over the structure. Changing the object structure classes requires redefining the interface to all visitors, which is potentially costly. If the object structure classes change often, then it's probably better to define the operations in those classes
+* An object structure contains many classes of objects with differing interfaces, and you want to perform operations on these objects that depend on their concrete classes.
+* Many distinct and unrelated operations need to be performed on objects in an object structure, and you want to avoid "polluting" their classes with these operations. Visitor lets you keep related operations together by defining them in one class. When the object structure is shared by many applications, use Visitor to put operations in just those applications that need them.
+* The classes defining the object structure rarely change, but you often want to define new operations over the structure. Changing the object structure classes requires redefining the interface to all visitors, which is potentially costly. If the object structure classes change often, then it's probably better to define the operations in those classes.
## Real world examples
From ef43af3b2372026214512fa486c758ce98721567 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Tue, 18 Aug 2020 16:42:02 +0000
Subject: [PATCH 14/18] docs: update README.md [skip ci]
---
README.md | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 36094b1db..225f14709 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
[](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)
-[](#contributors-)
+[](#contributors-)
# Introduction
@@ -254,6 +254,9 @@ This project is licensed under the terms of the MIT license.
xdvrx1
👀 🤔 |
Subhrodip Mohanta
💻 |
+
+ 
Bethan Palmer
💻 |
+
From 6c7715ace6b15cf010a4540b862d2b961c6e91c9 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Tue, 18 Aug 2020 16:42:03 +0000
Subject: [PATCH 15/18] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index 6ea5a5de6..712ae41c2 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -1130,6 +1130,15 @@
"contributions": [
"code"
]
+ },
+ {
+ "login": "nahteb",
+ "name": "Bethan Palmer",
+ "avatar_url": "https://avatars3.githubusercontent.com/u/13121570?v=4",
+ "profile": "https://github.com/nahteb",
+ "contributions": [
+ "code"
+ ]
}
],
"contributorsPerLine": 4,
From 06f20570b637dd1c432b27b2ab8e7e041eb2754c Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Tue, 18 Aug 2020 16:45:37 +0000
Subject: [PATCH 16/18] docs: update README.md [skip ci]
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 36094b1db..91db25047 100644
--- a/README.md
+++ b/README.md
@@ -252,7 +252,7 @@ This project is licensed under the terms of the MIT license.
Ashish Trivedi
💻 |
洪月阳
💻 |
xdvrx1
👀 🤔 |
-
Subhrodip Mohanta
💻 |
+
Subhrodip Mohanta
💻 👀 |
From 31881f500dd6442c1b0e6413fb931d47b953d5aa Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
<46447321+allcontributors[bot]@users.noreply.github.com>
Date: Tue, 18 Aug 2020 16:45:38 +0000
Subject: [PATCH 17/18] docs: update .all-contributorsrc [skip ci]
---
.all-contributorsrc | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/.all-contributorsrc b/.all-contributorsrc
index 6ea5a5de6..8894929f7 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -1128,7 +1128,8 @@
"avatar_url": "https://avatars0.githubusercontent.com/u/13291222?v=4",
"profile": "http://subho.xyz",
"contributions": [
- "code"
+ "code",
+ "review"
]
}
],
From 847585334c4edea23aa675cc6b18c40db14982e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?=
Date: Tue, 18 Aug 2020 20:07:47 +0300
Subject: [PATCH 18/18] Update README.md
---
unit-of-work/README.md | 25 +++++++++++++++++--------
1 file changed, 17 insertions(+), 8 deletions(-)
diff --git a/unit-of-work/README.md b/unit-of-work/README.md
index 590f718d3..01aa8e5d7 100644
--- a/unit-of-work/README.md
+++ b/unit-of-work/README.md
@@ -11,21 +11,27 @@ tags:
---
## Intent
-When a business transaction is completed, all the the updates are sent as one big unit of work to be persisted
-in one go to minimize database round-trips.
+
+When a business transaction is completed, all the the updates are sent as one big unit of work to be
+persisted in one go to minimize database round-trips.
## Explanation
+
Real world example
-> We have a database containing student information. Administrators all over the country are constantly updating this information and it causes high load on the database server. To make the load more manageable we apply to Unit of Work pattern to send many small updates in batches.
+> We have a database containing student information. Administrators all over the country are
+> constantly updating this information and it causes high load on the database server. To make the
+> load more manageable we apply to Unit of Work pattern to send many small updates in batches.
In plain words
-> Unit of Work merges many small database updates in single batch to optimize the number of round-trips.
+> Unit of Work merges many small database updates in single batch to optimize the number of
+> round-trips.
[MartinFowler.com](https://martinfowler.com/eaaCatalog/unitOfWork.html) says
-> Maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.
+> Maintains a list of objects affected by a business transaction and coordinates the writing out of
+> changes and the resolution of concurrency problems.
**Programmatic Example**
@@ -57,8 +63,9 @@ public class Student {
}
```
-The essence of the implementation is the `StudentRepository` implementing the Unit of Work pattern. It maintains a map
-of database operations (`context`) that need to be done and when `commit` is called it applies them in single batch.
+The essence of the implementation is the `StudentRepository` implementing the Unit of Work pattern.
+It maintains a map of database operations (`context`) that need to be done and when `commit` is
+called it applies them in single batch.
```java
public interface IUnitOfWork {
@@ -160,7 +167,7 @@ public class StudentRepository implements IUnitOfWork {
}
```
-Finally here's how we use the `StudentRepository` and `commit` the transaction.
+Finally, here's how we use the `StudentRepository` and `commit` the transaction.
```java
studentRepository.registerNew(ram);
@@ -170,9 +177,11 @@ Finally here's how we use the `StudentRepository` and `commit` the transaction.
```
## Class diagram
+
## Applicability
+
Use the Unit Of Work pattern when
* To optimize the time taken for database transactions.