From 0685a505d3d0d53b685a23cbe2dab727a721005f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?= Date: Sat, 7 Dec 2019 18:03:49 +0200 Subject: [PATCH 1/3] #1113 Add uml-reverse-mapper plugin --- .../etc/abstract-document.urm.puml | 65 ++++ .../etc/abstract-factory.urm.puml | 101 ++++++ acyclic-visitor/etc/acyclic-visitor.urm.puml | 53 +++ adapter/etc/adapter.urm.puml | 31 ++ .../etc/aggregator-service.urm.puml | 43 +++ .../etc/aggregator-microservices.urm.puml | 2 + .../etc/information-microservice.urm.puml | 12 + .../etc/inventory-microservice.urm.puml | 12 + ambassador/etc/ambassador.urm.puml | 47 +++ .../etc/api-gateway-service.urm.puml | 48 +++ api-gateway/etc/api-gateway.urm.puml | 2 + .../etc/image-microservice.urm.puml | 12 + .../etc/price-microservice.urm.puml | 12 + .../etc/async-method-invocation.urm.puml | 51 +++ balking/etc/balking.urm.puml | 30 ++ bridge/etc/bridge.urm.puml | 58 +++ builder/etc/builder.urm.puml | 100 ++++++ .../etc/business-delegate.urm.puml | 57 +++ bytecode/etc/bytecode.urm.puml | 69 ++++ caching/etc/caching.urm.puml | 119 +++++++ callback/etc/callback.urm.puml | 28 ++ chain/etc/chain.urm.puml | 61 ++++ circuit-breaker/etc/circuit-breaker.urm.puml | 44 +++ .../etc/collection-pipeline.urm.puml | 52 +++ combinator/etc/combinator.urm.puml | 26 ++ command/etc/command.urm.puml | 83 +++++ commander/etc/commander.urm.puml | 329 ++++++++++++++++++ composite/etc/composite.urm.puml | 41 +++ converter/etc/converter.urm.puml | 50 +++ cqrs/etc/cqrs.urm.puml | 134 +++++++ dao/etc/dao.urm.puml | 68 ++++ data-bus/etc/data-bus.urm.puml | 82 +++++ data-locality/etc/data-locality.urm.puml | 80 +++++ data-mapper/etc/data-mapper.urm.puml | 43 +++ .../etc/data-transfer-object.urm.puml | 27 ++ decorator/etc/decorator.urm.puml | 32 ++ delegation/etc/delegation.urm.puml | 39 +++ .../etc/dependency-injection.urm.puml | 57 +++ dirty-flag/etc/dirty-flag.urm.puml | 25 ++ double-buffer/etc/double-buffer.urm.puml | 45 +++ .../etc/double-checked-locking.urm.puml | 22 ++ double-dispatch/etc/double-dispatch.urm.puml | 74 ++++ eip-aggregator/etc/eip-aggregator.urm.puml | 14 + .../etc/eip-message-channel.urm.puml | 9 + .../etc/eip-publish-subscribe.urm.puml | 9 + eip-splitter/etc/eip-splitter.urm.puml | 8 + eip-wire-tap/etc/eip-wire-tap.urm.puml | 8 + etc/java-design-patterns.urm.puml | 2 + .../etc/event-aggregator.urm.puml | 74 ++++ .../etc/event-asynchronous.urm.puml | 70 ++++ .../etc/event-driven-architecture.urm.puml | 64 ++++ event-queue/etc/event-queue.urm.puml | 38 ++ event-sourcing/etc/event-sourcing.urm.puml | 107 ++++++ execute-around/etc/execute-around.urm.puml | 14 + .../etc/extension-objects.urm.puml | 2 + facade/etc/facade.urm.puml | 60 ++++ factory-kit/etc/factory-kit.urm.puml | 46 +++ factory-method/etc/factory-method.urm.puml | 56 +++ feature-toggle/etc/feature-toggle.urm.puml | 48 +++ fluentinterface/etc/fluentinterface.urm.puml | 72 ++++ flux/etc/flux.urm.puml | 117 +++++++ flyweight/etc/flyweight.urm.puml | 65 ++++ .../etc/front-controller.urm.puml | 53 +++ game-loop/etc/game-loop.urm.puml | 63 ++++ .../etc/guarded-suspension.urm.puml | 15 + .../etc/half-sync-half-async.urm.puml | 33 ++ hexagonal/etc/hexagonal.urm.puml | 305 ++++++++++++++++ .../etc/intercepting-filter.urm.puml | 88 +++++ interpreter/etc/interpreter.urm.puml | 51 +++ iterator/etc/iterator.urm.puml | 85 +++++ layers/etc/layers.urm.puml | 136 ++++++++ lazy-loading/etc/lazy-loading.urm.puml | 40 +++ leader-election/etc/leader-election.urm.puml | 120 +++++++ marker/etc/marker.urm.puml | 2 + .../etc/master-worker-pattern.urm.puml | 78 +++++ mediator/etc/mediator.urm.puml | 69 ++++ memento/etc/memento.urm.puml | 49 +++ .../etc/model-view-controller.urm.puml | 70 ++++ .../etc/model-view-presenter.urm.puml | 90 +++++ module/etc/module.urm.puml | 43 +++ monad/etc/monad.urm.puml | 36 ++ monostate/etc/monostate.urm.puml | 32 ++ multiton/etc/multiton.urm.puml | 43 +++ mute-idiom/etc/mute-idiom.urm.puml | 24 ++ mutex/etc/mutex.urm.puml | 27 ++ .../dom/etc/naked-objects-dom.urm.puml | 2 + naked-objects/etc/naked-objects.urm.puml | 2 + .../etc/naked-objects-fixture.urm.puml | 2 + .../etc/naked-objects-integtests.urm.puml | 2 + .../webapp/etc/naked-objects-webapp.urm.puml | 2 + null-object/etc/null-object.urm.puml | 41 +++ object-mother/etc/object-mother.urm.puml | 45 +++ object-pool/etc/object-pool.urm.puml | 30 ++ observer/etc/observer.urm.puml | 80 +++++ page-object/etc/page-object.urm.puml | 2 + .../etc/sample-application.urm.puml | 9 + .../etc/test-automation.urm.puml | 51 +++ .../etc/partial-response.urm.puml | 31 ++ pipeline/etc/pipeline.urm.puml | 36 ++ poison-pill/etc/poison-pill.urm.puml | 71 ++++ pom.xml | 26 ++ priority-queue/etc/priority-queue.urm.puml | 54 +++ .../etc/private-class-data.urm.puml | 36 ++ .../etc/producer-consumer.urm.puml | 40 +++ promise/etc/promise.urm.puml | 79 +++++ property/etc/property.urm.puml | 54 +++ prototype/etc/prototype.urm.puml | 105 ++++++ proxy/etc/proxy.urm.puml | 32 ++ .../etc/queue-load-leveling.urm.puml | 44 +++ reactor/etc/reactor.urm.puml | 155 +++++++++ .../etc/reader-writer-lock.urm.puml | 65 ++++ repository/etc/repository.urm.puml | 56 +++ ...rce-acquisition-is-initialization.urm.puml | 19 + retry/etc/retry.urm.puml | 54 +++ role-object/etc/role-object.urm.puml | 60 ++++ saga/etc/saga.urm.puml | 222 ++++++++++++ semaphore/etc/semaphore.urm.puml | 56 +++ servant/etc/servant.urm.puml | 56 +++ serverless/etc/serverless.urm.puml | 138 ++++++++ service-layer/etc/service-layer.urm.puml | 159 +++++++++ service-locator/etc/service-locator.urm.puml | 41 +++ sharding/etc/sharding.urm.puml | 71 ++++ singleton/etc/singleton.urm.puml | 44 +++ .../etc/spatial-partition.urm.puml | 72 ++++ specification/etc/specification.urm.puml | 177 ++++++++++ state/etc/state.urm.puml | 39 +++ step-builder/etc/step-builder.urm.puml | 91 +++++ strategy/etc/strategy.urm.puml | 37 ++ .../etc/subclass-sandbox.urm.puml | 27 ++ template-method/etc/template-method.urm.puml | 39 +++ thread-pool/etc/thread-pool.urm.puml | 37 ++ throttling/etc/throttling.urm.puml | 47 +++ tls/etc/tls.urm.puml | 25 ++ tolerant-reader/etc/tolerant-reader.urm.puml | 39 +++ trampoline/etc/trampoline.urm.puml | 18 + twin/etc/twin.urm.puml | 27 ++ .../etc/typeobjectpattern.urm.puml | 72 ++++ update-method/etc/update-method.urm.puml | 51 +++ value-object/etc/value-object.urm.puml | 22 ++ visitor/etc/visitor.urm.puml | 60 ++++ 140 files changed, 7753 insertions(+) create mode 100644 abstract-document/etc/abstract-document.urm.puml create mode 100644 abstract-factory/etc/abstract-factory.urm.puml create mode 100644 acyclic-visitor/etc/acyclic-visitor.urm.puml create mode 100644 adapter/etc/adapter.urm.puml create mode 100644 aggregator-microservices/aggregator-service/etc/aggregator-service.urm.puml create mode 100644 aggregator-microservices/etc/aggregator-microservices.urm.puml create mode 100644 aggregator-microservices/information-microservice/etc/information-microservice.urm.puml create mode 100644 aggregator-microservices/inventory-microservice/etc/inventory-microservice.urm.puml create mode 100644 ambassador/etc/ambassador.urm.puml create mode 100644 api-gateway/api-gateway-service/etc/api-gateway-service.urm.puml create mode 100644 api-gateway/etc/api-gateway.urm.puml create mode 100644 api-gateway/image-microservice/etc/image-microservice.urm.puml create mode 100644 api-gateway/price-microservice/etc/price-microservice.urm.puml create mode 100644 async-method-invocation/etc/async-method-invocation.urm.puml create mode 100644 balking/etc/balking.urm.puml create mode 100644 bridge/etc/bridge.urm.puml create mode 100644 builder/etc/builder.urm.puml create mode 100644 business-delegate/etc/business-delegate.urm.puml create mode 100644 bytecode/etc/bytecode.urm.puml create mode 100644 caching/etc/caching.urm.puml create mode 100644 callback/etc/callback.urm.puml create mode 100644 chain/etc/chain.urm.puml create mode 100644 circuit-breaker/etc/circuit-breaker.urm.puml create mode 100644 collection-pipeline/etc/collection-pipeline.urm.puml create mode 100644 combinator/etc/combinator.urm.puml create mode 100644 command/etc/command.urm.puml create mode 100644 commander/etc/commander.urm.puml create mode 100644 composite/etc/composite.urm.puml create mode 100644 converter/etc/converter.urm.puml create mode 100644 cqrs/etc/cqrs.urm.puml create mode 100644 dao/etc/dao.urm.puml create mode 100644 data-bus/etc/data-bus.urm.puml create mode 100644 data-locality/etc/data-locality.urm.puml create mode 100644 data-mapper/etc/data-mapper.urm.puml create mode 100644 data-transfer-object/etc/data-transfer-object.urm.puml create mode 100644 decorator/etc/decorator.urm.puml create mode 100644 delegation/etc/delegation.urm.puml create mode 100644 dependency-injection/etc/dependency-injection.urm.puml create mode 100644 dirty-flag/etc/dirty-flag.urm.puml create mode 100644 double-buffer/etc/double-buffer.urm.puml create mode 100644 double-checked-locking/etc/double-checked-locking.urm.puml create mode 100644 double-dispatch/etc/double-dispatch.urm.puml create mode 100644 eip-aggregator/etc/eip-aggregator.urm.puml create mode 100644 eip-message-channel/etc/eip-message-channel.urm.puml create mode 100644 eip-publish-subscribe/etc/eip-publish-subscribe.urm.puml create mode 100644 eip-splitter/etc/eip-splitter.urm.puml create mode 100644 eip-wire-tap/etc/eip-wire-tap.urm.puml create mode 100644 etc/java-design-patterns.urm.puml create mode 100644 event-aggregator/etc/event-aggregator.urm.puml create mode 100644 event-asynchronous/etc/event-asynchronous.urm.puml create mode 100644 event-driven-architecture/etc/event-driven-architecture.urm.puml create mode 100644 event-queue/etc/event-queue.urm.puml create mode 100644 event-sourcing/etc/event-sourcing.urm.puml create mode 100644 execute-around/etc/execute-around.urm.puml create mode 100644 extension-objects/etc/extension-objects.urm.puml create mode 100644 facade/etc/facade.urm.puml create mode 100644 factory-kit/etc/factory-kit.urm.puml create mode 100644 factory-method/etc/factory-method.urm.puml create mode 100644 feature-toggle/etc/feature-toggle.urm.puml create mode 100644 fluentinterface/etc/fluentinterface.urm.puml create mode 100644 flux/etc/flux.urm.puml create mode 100644 flyweight/etc/flyweight.urm.puml create mode 100644 front-controller/etc/front-controller.urm.puml create mode 100644 game-loop/etc/game-loop.urm.puml create mode 100644 guarded-suspension/etc/guarded-suspension.urm.puml create mode 100644 half-sync-half-async/etc/half-sync-half-async.urm.puml create mode 100644 hexagonal/etc/hexagonal.urm.puml create mode 100644 intercepting-filter/etc/intercepting-filter.urm.puml create mode 100644 interpreter/etc/interpreter.urm.puml create mode 100644 iterator/etc/iterator.urm.puml create mode 100644 layers/etc/layers.urm.puml create mode 100644 lazy-loading/etc/lazy-loading.urm.puml create mode 100644 leader-election/etc/leader-election.urm.puml create mode 100644 marker/etc/marker.urm.puml create mode 100644 master-worker-pattern/etc/master-worker-pattern.urm.puml create mode 100644 mediator/etc/mediator.urm.puml create mode 100644 memento/etc/memento.urm.puml create mode 100644 model-view-controller/etc/model-view-controller.urm.puml create mode 100644 model-view-presenter/etc/model-view-presenter.urm.puml create mode 100644 module/etc/module.urm.puml create mode 100644 monad/etc/monad.urm.puml create mode 100644 monostate/etc/monostate.urm.puml create mode 100644 multiton/etc/multiton.urm.puml create mode 100644 mute-idiom/etc/mute-idiom.urm.puml create mode 100644 mutex/etc/mutex.urm.puml create mode 100644 naked-objects/dom/etc/naked-objects-dom.urm.puml create mode 100644 naked-objects/etc/naked-objects.urm.puml create mode 100644 naked-objects/fixture/etc/naked-objects-fixture.urm.puml create mode 100644 naked-objects/integtests/etc/naked-objects-integtests.urm.puml create mode 100644 naked-objects/webapp/etc/naked-objects-webapp.urm.puml create mode 100644 null-object/etc/null-object.urm.puml create mode 100644 object-mother/etc/object-mother.urm.puml create mode 100644 object-pool/etc/object-pool.urm.puml create mode 100644 observer/etc/observer.urm.puml create mode 100644 page-object/etc/page-object.urm.puml create mode 100644 page-object/sample-application/etc/sample-application.urm.puml create mode 100644 page-object/test-automation/etc/test-automation.urm.puml create mode 100644 partial-response/etc/partial-response.urm.puml create mode 100644 pipeline/etc/pipeline.urm.puml create mode 100644 poison-pill/etc/poison-pill.urm.puml create mode 100644 priority-queue/etc/priority-queue.urm.puml create mode 100644 private-class-data/etc/private-class-data.urm.puml create mode 100644 producer-consumer/etc/producer-consumer.urm.puml create mode 100644 promise/etc/promise.urm.puml create mode 100644 property/etc/property.urm.puml create mode 100644 prototype/etc/prototype.urm.puml create mode 100644 proxy/etc/proxy.urm.puml create mode 100644 queue-load-leveling/etc/queue-load-leveling.urm.puml create mode 100644 reactor/etc/reactor.urm.puml create mode 100644 reader-writer-lock/etc/reader-writer-lock.urm.puml create mode 100644 repository/etc/repository.urm.puml create mode 100644 resource-acquisition-is-initialization/etc/resource-acquisition-is-initialization.urm.puml create mode 100644 retry/etc/retry.urm.puml create mode 100644 role-object/etc/role-object.urm.puml create mode 100644 saga/etc/saga.urm.puml create mode 100644 semaphore/etc/semaphore.urm.puml create mode 100644 servant/etc/servant.urm.puml create mode 100644 serverless/etc/serverless.urm.puml create mode 100644 service-layer/etc/service-layer.urm.puml create mode 100644 service-locator/etc/service-locator.urm.puml create mode 100644 sharding/etc/sharding.urm.puml create mode 100644 singleton/etc/singleton.urm.puml create mode 100644 spatial-partition/etc/spatial-partition.urm.puml create mode 100644 specification/etc/specification.urm.puml create mode 100644 state/etc/state.urm.puml create mode 100644 step-builder/etc/step-builder.urm.puml create mode 100644 strategy/etc/strategy.urm.puml create mode 100644 subclass-sandbox/etc/subclass-sandbox.urm.puml create mode 100644 template-method/etc/template-method.urm.puml create mode 100644 thread-pool/etc/thread-pool.urm.puml create mode 100644 throttling/etc/throttling.urm.puml create mode 100644 tls/etc/tls.urm.puml create mode 100644 tolerant-reader/etc/tolerant-reader.urm.puml create mode 100644 trampoline/etc/trampoline.urm.puml create mode 100644 twin/etc/twin.urm.puml create mode 100644 typeobjectpattern/etc/typeobjectpattern.urm.puml create mode 100644 update-method/etc/update-method.urm.puml create mode 100644 value-object/etc/value-object.urm.puml create mode 100644 visitor/etc/visitor.urm.puml diff --git a/abstract-document/etc/abstract-document.urm.puml b/abstract-document/etc/abstract-document.urm.puml new file mode 100644 index 000000000000..9940dc2cfd05 --- /dev/null +++ b/abstract-document/etc/abstract-document.urm.puml @@ -0,0 +1,65 @@ +@startuml +package com.iluwatar.abstractdocument.domain.enums { + enum Property { + + MODEL {static} + + PARTS {static} + + PRICE {static} + + TYPE {static} + + valueOf(name : String) : Property {static} + + values() : Property[] {static} + } +} +package com.iluwatar.abstractdocument.domain { + class Car { + + Car(properties : Map) + } + interface HasModel { + + getModel() : Optional + } + interface HasParts { + + getParts() : Stream + } + interface HasPrice { + + getPrice() : Optional + } + interface HasType { + + getType() : Optional + } + class Part { + + Part(properties : Map) + } +} +package com.iluwatar.abstractdocument { + abstract class AbstractDocument { + - properties : Map + # AbstractDocument(properties : Map) + + children(key : String, constructor : Function, T>) : Stream + + get(key : String) : Object + + put(key : String, value : Object) + + toString() : String + } + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface Document { + + children(String, Function, T>) : Stream {abstract} + + get(String) : Object {abstract} + + put(String, Object) {abstract} + } +} +AbstractDocument ..|> Document +Car ..|> HasModel +Car ..|> HasPrice +Car ..|> HasParts +Car --|> AbstractDocument +HasModel --|> Document +HasParts --|> Document +HasPrice --|> Document +HasType --|> Document +Part ..|> HasType +Part ..|> HasModel +Part ..|> HasPrice +Part --|> AbstractDocument +@enduml \ No newline at end of file diff --git a/abstract-factory/etc/abstract-factory.urm.puml b/abstract-factory/etc/abstract-factory.urm.puml new file mode 100644 index 000000000000..999091ef54f6 --- /dev/null +++ b/abstract-factory/etc/abstract-factory.urm.puml @@ -0,0 +1,101 @@ +@startuml +package com.iluwatar.abstractfactory { + class App { + - LOGGER : Logger {static} + - army : Army + - castle : Castle + - king : King + + App() + + createKingdom(factory : KingdomFactory) + + getArmy() : Army + ~ getArmy(factory : KingdomFactory) : Army + + getCastle() : Castle + ~ getCastle(factory : KingdomFactory) : Castle + + getKing() : King + ~ getKing(factory : KingdomFactory) : King + + main(args : String[]) {static} + - setArmy(army : Army) + - setCastle(castle : Castle) + - setKing(king : King) + } + class FactoryMaker { + + FactoryMaker() + + makeFactory(type : KingdomType) : KingdomFactory {static} + } + enum KingdomType { + + ELF {static} + + ORC {static} + + valueOf(name : String) : KingdomType {static} + + values() : KingdomType[] {static} + } + interface Army { + + getDescription() : String {abstract} + } + interface Castle { + + getDescription() : String {abstract} + } + class ElfArmy { + ~ DESCRIPTION : String {static} + + ElfArmy() + + getDescription() : String + } + class ElfCastle { + ~ DESCRIPTION : String {static} + + ElfCastle() + + getDescription() : String + } + class ElfKing { + ~ DESCRIPTION : String {static} + + ElfKing() + + getDescription() : String + } + class ElfKingdomFactory { + + ElfKingdomFactory() + + createArmy() : Army + + createCastle() : Castle + + createKing() : King + } + interface King { + + getDescription() : String {abstract} + } + interface KingdomFactory { + + createArmy() : Army {abstract} + + createCastle() : Castle {abstract} + + createKing() : King {abstract} + } + class OrcArmy { + ~ DESCRIPTION : String {static} + + OrcArmy() + + getDescription() : String + } + class OrcCastle { + ~ DESCRIPTION : String {static} + + OrcCastle() + + getDescription() : String + } + class OrcKing { + ~ DESCRIPTION : String {static} + + OrcKing() + + getDescription() : String + } + class OrcKingdomFactory { + + OrcKingdomFactory() + + createArmy() : Army + + createCastle() : Castle + + createKing() : King + } +} +KingdomType ..+ FactoryMaker +App --> "-castle" Castle +FactoryMaker ..+ App +App --> "-king" King +App --> "-army" Army +ElfArmy ..|> Army +ElfCastle ..|> Castle +ElfKing ..|> King +ElfKingdomFactory ..|> KingdomFactory +OrcArmy ..|> Army +OrcCastle ..|> Castle +OrcKing ..|> King +OrcKingdomFactory ..|> KingdomFactory +@enduml \ No newline at end of file diff --git a/acyclic-visitor/etc/acyclic-visitor.urm.puml b/acyclic-visitor/etc/acyclic-visitor.urm.puml new file mode 100644 index 000000000000..e67bbde4407c --- /dev/null +++ b/acyclic-visitor/etc/acyclic-visitor.urm.puml @@ -0,0 +1,53 @@ +@startuml +package com.iluwatar.acyclicvisitor { + interface AllModemVisitor { + } + class App { + + App() + + main(args : String[]) {static} + } + class ConfigureForDosVisitor { + - LOGGER : Logger {static} + + ConfigureForDosVisitor() + + visit(hayes : Hayes) + + visit(zoom : Zoom) + } + class ConfigureForUnixVisitor { + - LOGGER : Logger {static} + + ConfigureForUnixVisitor() + + visit(zoom : Zoom) + } + class Hayes { + - LOGGER : Logger {static} + + Hayes() + + accept(modemVisitor : ModemVisitor) + + toString() : String + } + interface HayesVisitor { + + visit(Hayes) {abstract} + } + abstract class Modem { + + Modem() + + accept(ModemVisitor) {abstract} + } + interface ModemVisitor { + } + class Zoom { + - LOGGER : Logger {static} + + Zoom() + + accept(modemVisitor : ModemVisitor) + + toString() : String + } + interface ZoomVisitor { + + visit(Zoom) {abstract} + } +} +AllModemVisitor --|> ZoomVisitor +AllModemVisitor --|> HayesVisitor +ConfigureForDosVisitor ..|> AllModemVisitor +ConfigureForUnixVisitor ..|> ZoomVisitor +Hayes --|> Modem +HayesVisitor --|> ModemVisitor +Zoom --|> Modem +ZoomVisitor --|> ModemVisitor +@enduml \ No newline at end of file diff --git a/adapter/etc/adapter.urm.puml b/adapter/etc/adapter.urm.puml new file mode 100644 index 000000000000..1277cbb87125 --- /dev/null +++ b/adapter/etc/adapter.urm.puml @@ -0,0 +1,31 @@ +@startuml +package com.iluwatar.adapter { + class App { + - App() + + main(args : String[]) {static} + } + class Captain { + - rowingBoat : RowingBoat + + Captain() + + Captain(boat : RowingBoat) + ~ row() + ~ setRowingBoat(boat : RowingBoat) + } + ~class FishingBoat { + - LOGGER : Logger {static} + ~ FishingBoat() + ~ sail() + } + class FishingBoatAdapter { + - boat : FishingBoat + + FishingBoatAdapter() + + row() + } + interface RowingBoat { + + row() {abstract} + } +} +FishingBoatAdapter --> "-boat" FishingBoat +Captain --> "-rowingBoat" RowingBoat +FishingBoatAdapter ..|> RowingBoat +@enduml \ No newline at end of file diff --git a/aggregator-microservices/aggregator-service/etc/aggregator-service.urm.puml b/aggregator-microservices/aggregator-service/etc/aggregator-service.urm.puml new file mode 100644 index 000000000000..32ab28920b87 --- /dev/null +++ b/aggregator-microservices/aggregator-service/etc/aggregator-service.urm.puml @@ -0,0 +1,43 @@ +@startuml +package com.iluwatar.aggregator.microservices { + class Aggregator { + - informationClient : ProductInformationClient + - inventoryClient : ProductInventoryClient + + Aggregator() + + getProduct() : Product + } + class App { + + App() + + main(args : String[]) {static} + } + class Product { + - productInventories : int + - title : String + + Product() + + getProductInventories() : int + + getTitle() : String + + setProductInventories(productInventories : int) + + setTitle(title : String) + } + interface ProductInformationClient { + + getProductTitle() : String {abstract} + } + class ProductInformationClientImpl { + - LOGGER : Logger {static} + + ProductInformationClientImpl() + + getProductTitle() : String + } + interface ProductInventoryClient { + + getProductInventories() : Integer {abstract} + } + class ProductInventoryClientImpl { + - LOGGER : Logger {static} + + ProductInventoryClientImpl() + + getProductInventories() : Integer + } +} +Aggregator --> "-informationClient" ProductInformationClient +Aggregator --> "-inventoryClient" ProductInventoryClient +ProductInformationClientImpl ..|> ProductInformationClient +ProductInventoryClientImpl ..|> ProductInventoryClient +@enduml \ No newline at end of file diff --git a/aggregator-microservices/etc/aggregator-microservices.urm.puml b/aggregator-microservices/etc/aggregator-microservices.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/aggregator-microservices/etc/aggregator-microservices.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/aggregator-microservices/information-microservice/etc/information-microservice.urm.puml b/aggregator-microservices/information-microservice/etc/information-microservice.urm.puml new file mode 100644 index 000000000000..e0a2ccb24fb2 --- /dev/null +++ b/aggregator-microservices/information-microservice/etc/information-microservice.urm.puml @@ -0,0 +1,12 @@ +@startuml +package com.iluwatar.information.microservice { + class InformationApplication { + + InformationApplication() + + main(args : String[]) {static} + } + class InformationController { + + InformationController() + + getProductTitle() : String + } +} +@enduml \ No newline at end of file diff --git a/aggregator-microservices/inventory-microservice/etc/inventory-microservice.urm.puml b/aggregator-microservices/inventory-microservice/etc/inventory-microservice.urm.puml new file mode 100644 index 000000000000..90f327e07db8 --- /dev/null +++ b/aggregator-microservices/inventory-microservice/etc/inventory-microservice.urm.puml @@ -0,0 +1,12 @@ +@startuml +package com.iluwatar.inventory.microservice { + class InventoryApplication { + + InventoryApplication() + + main(args : String[]) {static} + } + class InventoryController { + + InventoryController() + + getProductInventories() : int + } +} +@enduml \ No newline at end of file diff --git a/ambassador/etc/ambassador.urm.puml b/ambassador/etc/ambassador.urm.puml new file mode 100644 index 000000000000..517b0bf51d07 --- /dev/null +++ b/ambassador/etc/ambassador.urm.puml @@ -0,0 +1,47 @@ +@startuml +package com.iluwatar.ambassador.util { + interface RandomProvider { + + random() : double {abstract} + } +} +package com.iluwatar.ambassador { + class App { + + App() + + main(args : String[]) {static} + } + class Client { + - LOGGER : Logger {static} + - serviceAmbassador : ServiceAmbassador + + Client() + ~ useService(value : int) : long + } + class RemoteService { + - LOGGER : Logger {static} + - THRESHOLD : int {static} + - randomProvider : RandomProvider + - service : RemoteService {static} + - RemoteService() + ~ RemoteService(randomProvider : RandomProvider) + + doRemoteFunction(value : int) : long + ~ getRemoteService() : RemoteService {static} + } + ~interface RemoteServiceInterface { + + FAILURE : int {static} + + doRemoteFunction(int) : long {abstract} + } + class ServiceAmbassador { + - DELAY_MS : int {static} + - LOGGER : Logger {static} + - RETRIES : int {static} + ~ ServiceAmbassador() + - checkLatency(value : int) : long + + doRemoteFunction(value : int) : long + - safeCall(value : int) : long + } +} +RemoteService --> "-service" RemoteService +Client --> "-serviceAmbassador" ServiceAmbassador +RemoteService --> "-randomProvider" RandomProvider +RemoteService ..|> RemoteServiceInterface +ServiceAmbassador ..|> RemoteServiceInterface +@enduml \ No newline at end of file diff --git a/api-gateway/api-gateway-service/etc/api-gateway-service.urm.puml b/api-gateway/api-gateway-service/etc/api-gateway-service.urm.puml new file mode 100644 index 000000000000..5fabc6a0fab4 --- /dev/null +++ b/api-gateway/api-gateway-service/etc/api-gateway-service.urm.puml @@ -0,0 +1,48 @@ +@startuml +package com.iluwatar.api.gateway { + class ApiGateway { + - imageClient : ImageClient + - priceClient : PriceClient + + ApiGateway() + + getProductDesktop() : DesktopProduct + + getProductMobile() : MobileProduct + } + class App { + + App() + + main(args : String[]) {static} + } + class DesktopProduct { + - imagePath : String + - price : String + + DesktopProduct() + + getImagePath() : String + + getPrice() : String + + setImagePath(imagePath : String) + + setPrice(price : String) + } + interface ImageClient { + + getImagePath() : String {abstract} + } + class ImageClientImpl { + + ImageClientImpl() + + getImagePath() : String + } + class MobileProduct { + - price : String + + MobileProduct() + + getPrice() : String + + setPrice(price : String) + } + interface PriceClient { + + getPrice() : String {abstract} + } + class PriceClientImpl { + + PriceClientImpl() + + getPrice() : String + } +} +ApiGateway --> "-imageClient" ImageClient +ApiGateway --> "-priceClient" PriceClient +ImageClientImpl ..|> ImageClient +PriceClientImpl ..|> PriceClient +@enduml \ No newline at end of file diff --git a/api-gateway/etc/api-gateway.urm.puml b/api-gateway/etc/api-gateway.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/api-gateway/etc/api-gateway.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/api-gateway/image-microservice/etc/image-microservice.urm.puml b/api-gateway/image-microservice/etc/image-microservice.urm.puml new file mode 100644 index 000000000000..130dac9de383 --- /dev/null +++ b/api-gateway/image-microservice/etc/image-microservice.urm.puml @@ -0,0 +1,12 @@ +@startuml +package com.iluwatar.image.microservice { + class ImageApplication { + + ImageApplication() + + main(args : String[]) {static} + } + class ImageController { + + ImageController() + + getImagePath() : String + } +} +@enduml \ No newline at end of file diff --git a/api-gateway/price-microservice/etc/price-microservice.urm.puml b/api-gateway/price-microservice/etc/price-microservice.urm.puml new file mode 100644 index 000000000000..9893c9c601d1 --- /dev/null +++ b/api-gateway/price-microservice/etc/price-microservice.urm.puml @@ -0,0 +1,12 @@ +@startuml +package com.iluwatar.price.microservice { + class PriceApplication { + + PriceApplication() + + main(args : String[]) {static} + } + class PriceController { + + PriceController() + + getPrice() : String + } +} +@enduml \ No newline at end of file diff --git a/async-method-invocation/etc/async-method-invocation.urm.puml b/async-method-invocation/etc/async-method-invocation.urm.puml new file mode 100644 index 000000000000..6f5d0b27f9d4 --- /dev/null +++ b/async-method-invocation/etc/async-method-invocation.urm.puml @@ -0,0 +1,51 @@ +@startuml +package com.iluwatar.async.method.invocation { + class App { + - LOGGER : Logger {static} + + App() + - callback(name : String) : AsyncCallback {static} + - lazyval(value : T, delayMillis : long) : Callable {static} + - log(msg : String) {static} + + main(args : String[]) {static} + } + interface AsyncCallback { + + onComplete(T, Optional) {abstract} + } + interface AsyncExecutor { + + endProcess(AsyncResult) : T {abstract} + + startProcess(Callable) : AsyncResult {abstract} + + startProcess(Callable, AsyncCallback) : AsyncResult {abstract} + } + interface AsyncResult { + + await() {abstract} + + getValue() : T {abstract} + + isCompleted() : boolean {abstract} + } + class ThreadAsyncExecutor { + - idx : AtomicInteger + + ThreadAsyncExecutor() + + endProcess(asyncResult : AsyncResult) : T + + startProcess(task : Callable) : AsyncResult + + startProcess(task : Callable, callback : AsyncCallback) : AsyncResult + } + -class CompletableResult { + ~ COMPLETED : int {static} + ~ FAILED : int {static} + ~ RUNNING : int {static} + ~ callback : Optional> + ~ exception : Exception + ~ lock : Object + ~ state : int + ~ value : T + ~ CompletableResult(callback : AsyncCallback) + + await() + + getValue() : T + + isCompleted() : boolean + ~ setException(exception : Exception) + ~ setValue(value : T) + } +} +CompletableResult ..+ ThreadAsyncExecutor +ThreadAsyncExecutor ..|> AsyncExecutor +CompletableResult ..|> AsyncResult +@enduml \ No newline at end of file diff --git a/balking/etc/balking.urm.puml b/balking/etc/balking.urm.puml new file mode 100644 index 000000000000..191fd350bcd8 --- /dev/null +++ b/balking/etc/balking.urm.puml @@ -0,0 +1,30 @@ +@startuml +package com.iluwatar.balking { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface DelayProvider { + + executeAfterDelay(long, TimeUnit, Runnable) {abstract} + } + class WashingMachine { + - LOGGER : Logger {static} + - delayProvider : DelayProvider + - washingMachineState : WashingMachineState + + WashingMachine() + + WashingMachine(delayProvider : DelayProvider) + + endOfWashing() + + getWashingMachineState() : WashingMachineState + + wash() + } + enum WashingMachineState { + + ENABLED {static} + + WASHING {static} + + valueOf(name : String) : WashingMachineState {static} + + values() : WashingMachineState[] {static} + } +} +WashingMachine --> "-washingMachineState" WashingMachineState +WashingMachine --> "-delayProvider" DelayProvider +@enduml \ No newline at end of file diff --git a/bridge/etc/bridge.urm.puml b/bridge/etc/bridge.urm.puml new file mode 100644 index 000000000000..d5d6a38a91d9 --- /dev/null +++ b/bridge/etc/bridge.urm.puml @@ -0,0 +1,58 @@ +@startuml +package com.iluwatar.bridge { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface Enchantment { + + apply() {abstract} + + onActivate() {abstract} + + onDeactivate() {abstract} + } + class FlyingEnchantment { + - LOGGER : Logger {static} + + FlyingEnchantment() + + apply() + + onActivate() + + onDeactivate() + } + class Hammer { + - LOGGER : Logger {static} + - enchantment : Enchantment + + Hammer(enchantment : Enchantment) + + getEnchantment() : Enchantment + + swing() + + unwield() + + wield() + } + class SoulEatingEnchantment { + - LOGGER : Logger {static} + + SoulEatingEnchantment() + + apply() + + onActivate() + + onDeactivate() + } + class Sword { + - LOGGER : Logger {static} + - enchantment : Enchantment + + Sword(enchantment : Enchantment) + + getEnchantment() : Enchantment + + swing() + + unwield() + + wield() + } + interface Weapon { + + getEnchantment() : Enchantment {abstract} + + swing() {abstract} + + unwield() {abstract} + + wield() {abstract} + } +} +Sword --> "-enchantment" Enchantment +Hammer --> "-enchantment" Enchantment +FlyingEnchantment ..|> Enchantment +Hammer ..|> Weapon +SoulEatingEnchantment ..|> Enchantment +Sword ..|> Weapon +@enduml \ No newline at end of file diff --git a/builder/etc/builder.urm.puml b/builder/etc/builder.urm.puml new file mode 100644 index 000000000000..43d595a176fc --- /dev/null +++ b/builder/etc/builder.urm.puml @@ -0,0 +1,100 @@ +@startuml +package com.iluwatar.builder { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + enum Armor { + + CHAIN_MAIL {static} + + CLOTHES {static} + + LEATHER {static} + + PLATE_MAIL {static} + - title : String + + toString() : String + + valueOf(name : String) : Armor {static} + + values() : Armor[] {static} + } + enum HairColor { + + BLACK {static} + + BLOND {static} + + BROWN {static} + + RED {static} + + WHITE {static} + + toString() : String + + valueOf(name : String) : HairColor {static} + + values() : HairColor[] {static} + } + enum HairType { + + BALD {static} + + CURLY {static} + + LONG_CURLY {static} + + LONG_STRAIGHT {static} + + SHORT {static} + - title : String + + toString() : String + + valueOf(name : String) : HairType {static} + + values() : HairType[] {static} + } + class Hero { + - armor : Armor + - hairColor : HairColor + - hairType : HairType + - name : String + - profession : Profession + - weapon : Weapon + - Hero(builder : Builder) + + getArmor() : Armor + + getHairColor() : HairColor + + getHairType() : HairType + + getName() : String + + getProfession() : Profession + + getWeapon() : Weapon + + toString() : String + } + class Builder { + - armor : Armor + - hairColor : HairColor + - hairType : HairType + - name : String + - profession : Profession + - weapon : Weapon + + Builder(profession : Profession, name : String) + + build() : Hero + + withArmor(armor : Armor) : Builder + + withHairColor(hairColor : HairColor) : Builder + + withHairType(hairType : HairType) : Builder + + withWeapon(weapon : Weapon) : Builder + } + enum Profession { + + MAGE {static} + + PRIEST {static} + + THIEF {static} + + WARRIOR {static} + + toString() : String + + valueOf(name : String) : Profession {static} + + values() : Profession[] {static} + } + enum Weapon { + + AXE {static} + + BOW {static} + + DAGGER {static} + + SWORD {static} + + WARHAMMER {static} + + toString() : String + + valueOf(name : String) : Weapon {static} + + values() : Weapon[] {static} + } +} +Hero --> "-profession" Profession +Builder ..+ Hero +Hero --> "-armor" Armor +Builder --> "-hairColor" HairColor +Builder --> "-weapon" Weapon +Builder --> "-hairType" HairType +Hero --> "-hairColor" HairColor +Builder --> "-profession" Profession +Hero --> "-weapon" Weapon +Hero --> "-hairType" HairType +Builder --> "-armor" Armor +@enduml \ No newline at end of file diff --git a/business-delegate/etc/business-delegate.urm.puml b/business-delegate/etc/business-delegate.urm.puml new file mode 100644 index 000000000000..40aa2d6f0997 --- /dev/null +++ b/business-delegate/etc/business-delegate.urm.puml @@ -0,0 +1,57 @@ +@startuml +package com.iluwatar.business.delegate { + class App { + + App() + + main(args : String[]) {static} + } + class BusinessDelegate { + - businessService : BusinessService + - lookupService : BusinessLookup + - serviceType : ServiceType + + BusinessDelegate() + + doTask() + + setLookupService(businessLookup : BusinessLookup) + + setServiceType(serviceType : ServiceType) + } + class BusinessLookup { + - ejbService : EjbService + - jmsService : JmsService + + BusinessLookup() + + getBusinessService(serviceType : ServiceType) : BusinessService + + setEjbService(ejbService : EjbService) + + setJmsService(jmsService : JmsService) + } + interface BusinessService { + + doProcessing() {abstract} + } + class Client { + - businessDelegate : BusinessDelegate + + Client(businessDelegate : BusinessDelegate) + + doTask() + } + class EjbService { + - LOGGER : Logger {static} + + EjbService() + + doProcessing() + } + class JmsService { + - LOGGER : Logger {static} + + JmsService() + + doProcessing() + } + enum ServiceType { + + EJB {static} + + JMS {static} + + valueOf(name : String) : ServiceType {static} + + values() : ServiceType[] {static} + } +} +BusinessLookup --> "-ejbService" EjbService +BusinessDelegate --> "-serviceType" ServiceType +Client --> "-businessDelegate" BusinessDelegate +BusinessDelegate --> "-businessService" BusinessService +BusinessDelegate --> "-lookupService" BusinessLookup +BusinessLookup --> "-jmsService" JmsService +EjbService ..|> BusinessService +JmsService ..|> BusinessService +@enduml \ No newline at end of file diff --git a/bytecode/etc/bytecode.urm.puml b/bytecode/etc/bytecode.urm.puml new file mode 100644 index 000000000000..d675ae398c6c --- /dev/null +++ b/bytecode/etc/bytecode.urm.puml @@ -0,0 +1,69 @@ +@startuml +package com.iluwatar.bytecode { + class App { + - LOGGER : Logger {static} + + App() + - interpretInstruction(instruction : String, vm : VirtualMachine) {static} + + main(args : String[]) {static} + } + enum Instruction { + + ADD {static} + + DIVIDE {static} + + GET_AGILITY {static} + + GET_HEALTH {static} + + GET_WISDOM {static} + + LITERAL {static} + + PLAY_SOUND {static} + + SET_AGILITY {static} + + SET_HEALTH {static} + + SET_WISDOM {static} + + SPAWN_PARTICLES {static} + - value : int + + getInstruction(value : int) : Instruction {static} + + getIntValue() : int + + valueOf(name : String) : Instruction {static} + + values() : Instruction[] {static} + } + class VirtualMachine { + - stack : Stack + - wizards : Wizard[] + + VirtualMachine() + + execute(bytecode : int[]) + + getAgility(wizard : int) : int + + getHealth(wizard : int) : int + + getStack() : Stack + + getWisdom(wizard : int) : int + + getWizards() : Wizard[] + + setAgility(wizard : int, amount : int) + + setHealth(wizard : int, amount : int) + + setWisdom(wizard : int, amount : int) + } + class Wizard { + - LOGGER : Logger {static} + - agility : int + - health : int + - numberOfPlayedSounds : int + - numberOfSpawnedParticles : int + - wisdom : int + + Wizard() + + getAgility() : int + + getHealth() : int + + getNumberOfPlayedSounds() : int + + getNumberOfSpawnedParticles() : int + + getWisdom() : int + + playSound() + + setAgility(agility : int) + + setHealth(health : int) + + setWisdom(wisdom : int) + + spawnParticles() + } +} +package com.iluwatar.bytecode.util { + class InstructionConverterUtil { + + InstructionConverterUtil() + + convertToByteCode(instructions : String) : int[] {static} + - isValidInstruction(instruction : String) : boolean {static} + - isValidInt(value : String) : boolean {static} + } +} +@enduml \ No newline at end of file diff --git a/caching/etc/caching.urm.puml b/caching/etc/caching.urm.puml new file mode 100644 index 000000000000..a9dae801eb20 --- /dev/null +++ b/caching/etc/caching.urm.puml @@ -0,0 +1,119 @@ +@startuml +package com.iluwatar.caching.constants { + class CachingConstants { + + ADD_INFO : String {static} + + USER_ACCOUNT : String {static} + + USER_ID : String {static} + + USER_NAME : String {static} + + CachingConstants() + } +} +package com.iluwatar.caching { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + + useCacheAsideStategy() + + useReadAndWriteThroughStrategy() + + useReadThroughAndWriteAroundStrategy() + + useReadThroughAndWriteBehindStrategy() + } + class AppManager { + - cachingPolicy : CachingPolicy {static} + - AppManager() + + find(userId : String) : UserAccount {static} + - findAside(userId : String) : UserAccount {static} + + initCacheCapacity(capacity : int) {static} + + initCachingPolicy(policy : CachingPolicy) {static} + + initDb(useMongoDb : boolean) {static} + + printCacheContent() : String {static} + + save(userAccount : UserAccount) {static} + - saveAside(userAccount : UserAccount) {static} + } + class CacheStore { + - LOGGER : Logger {static} + - cache : LruCache {static} + - CacheStore() + + clearCache() {static} + + flushCache() {static} + + get(userId : String) : UserAccount {static} + + initCapacity(capacity : int) {static} + + invalidate(userId : String) {static} + + print() : String {static} + + readThrough(userId : String) : UserAccount {static} + + readThroughWithWriteBackPolicy(userId : String) : UserAccount {static} + + set(userId : String, userAccount : UserAccount) {static} + + writeAround(userAccount : UserAccount) {static} + + writeBehind(userAccount : UserAccount) {static} + + writeThrough(userAccount : UserAccount) {static} + } + enum CachingPolicy { + + AROUND {static} + + ASIDE {static} + + BEHIND {static} + + THROUGH {static} + - policy : String + + getPolicy() : String + + valueOf(name : String) : CachingPolicy {static} + + values() : CachingPolicy[] {static} + } + class DbManager { + - db : MongoDatabase {static} + - mongoClient : MongoClient {static} + - useMongoDB : boolean {static} + - virtualDB : Map {static} + - DbManager() + + connect() {static} + + createVirtualDb() {static} + + readFromDb(userId : String) : UserAccount {static} + + updateDb(userAccount : UserAccount) {static} + + upsertDb(userAccount : UserAccount) {static} + + writeToDb(userAccount : UserAccount) {static} + } + class LruCache { + - LOGGER : Logger {static} + ~ cache : Map + ~ capacity : int + ~ end : Node + ~ head : Node + + LruCache(capacity : int) + + clear() + + contains(userId : String) : boolean + + get(userId : String) : UserAccount + + getCacheDataInListForm() : List + + getLruData() : UserAccount + + invalidate(userId : String) + + isFull() : boolean + + remove(node : Node) + + set(userId : String, userAccount : UserAccount) + + setCapacity(newCapacity : int) + + setHead(node : Node) + } + ~class Node { + ~ next : Node + ~ previous : Node + ~ userAccount : UserAccount + ~ userId : String + + Node(this$0 : String, userId : UserAccount) + } + class UserAccount { + - additionalInfo : String + - userId : String + - userName : String + + UserAccount(userId : String, userName : String, additionalInfo : String) + + getAdditionalInfo() : String + + getUserId() : String + + getUserName() : String + + setAdditionalInfo(additionalInfo : String) + + setUserId(userId : String) + + setUserName(userName : String) + + toString() : String + } +} +Node --+ LruCache +LruCache --> "-head" Node +Node --> "-previous" Node +AppManager --> "-cachingPolicy" CachingPolicy +Node --> "-userAccount" UserAccount +CacheStore --> "-cache" LruCache +@enduml \ No newline at end of file diff --git a/callback/etc/callback.urm.puml b/callback/etc/callback.urm.puml new file mode 100644 index 000000000000..a666a4fdb25a --- /dev/null +++ b/callback/etc/callback.urm.puml @@ -0,0 +1,28 @@ +@startuml +package com.iluwatar.callback { + class App { + - LOGGER : Logger {static} + - App() + + main(args : String[]) {static} + } + interface Callback { + + call() {abstract} + } + class LambdasApp { + - LOGGER : Logger {static} + - LambdasApp() + + main(args : String[]) {static} + } + class SimpleTask { + - LOGGER : Logger {static} + + SimpleTask() + + execute() + } + abstract class Task { + + Task() + + execute() {abstract} + ~ executeWith(callback : Callback) + } +} +SimpleTask --|> Task +@enduml \ No newline at end of file diff --git a/chain/etc/chain.urm.puml b/chain/etc/chain.urm.puml new file mode 100644 index 000000000000..43c78a04223e --- /dev/null +++ b/chain/etc/chain.urm.puml @@ -0,0 +1,61 @@ +@startuml +package com.iluwatar.chain { + class App { + + App() + + main(args : String[]) {static} + } + class OrcCommander { + + OrcCommander(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class OrcKing { + - chain : RequestHandler + + OrcKing() + - buildChain() + + makeRequest(req : Request) + } + class OrcOfficer { + + OrcOfficer(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class OrcSoldier { + + OrcSoldier(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class Request { + - handled : boolean + - requestDescription : String + - requestType : RequestType + + Request(requestType : RequestType, requestDescription : String) + + getRequestDescription() : String + + getRequestType() : RequestType + + isHandled() : boolean + + markHandled() + + toString() : String + } + abstract class RequestHandler { + - LOGGER : Logger {static} + - next : RequestHandler + + RequestHandler(next : RequestHandler) + + handleRequest(req : Request) + # printHandling(req : Request) + + toString() : String {abstract} + } + enum RequestType { + + COLLECT_TAX {static} + + DEFEND_CASTLE {static} + + TORTURE_PRISONER {static} + + valueOf(name : String) : RequestType {static} + + values() : RequestType[] {static} + } +} +OrcKing --> "-chain" RequestHandler +RequestHandler --> "-next" RequestHandler +Request --> "-requestType" RequestType +OrcCommander --|> RequestHandler +OrcOfficer --|> RequestHandler +OrcSoldier --|> RequestHandler +@enduml \ No newline at end of file diff --git a/circuit-breaker/etc/circuit-breaker.urm.puml b/circuit-breaker/etc/circuit-breaker.urm.puml new file mode 100644 index 000000000000..21471900283a --- /dev/null +++ b/circuit-breaker/etc/circuit-breaker.urm.puml @@ -0,0 +1,44 @@ +@startuml +package com.iluwatar.circuitbreaker { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class CircuitBreaker { + ~ failureCount : int + - failureThreshold : int + - futureTime : long + ~ lastFailureTime : long + - retryTimePeriod : long + - state : State + - timeout : long + ~ CircuitBreaker(timeout : long, failureThreshold : int, retryTimePeriod : long) + + call(serviceToCall : String, serverStartTime : long) : String + + getState() : String + - recordFailure() + - reset() + # setState() + + setStateForBypass(state : State) + } + class DelayedService { + - delay : int + + DelayedService() + + DelayedService(delay : int) + + response(serverStartTime : long) : String + } + class MonitoringService { + + MonitoringService() + + localResourceResponse() : String + + remoteResourceResponse(circuitBreaker : CircuitBreaker, serverStartTime : long) : String + } + enum State { + + CLOSED {static} + + HALF_OPEN {static} + + OPEN {static} + + valueOf(name : String) : State {static} + + values() : State[] {static} + } +} +CircuitBreaker --> "-state" State +@enduml \ No newline at end of file diff --git a/collection-pipeline/etc/collection-pipeline.urm.puml b/collection-pipeline/etc/collection-pipeline.urm.puml new file mode 100644 index 000000000000..8cd51c44656b --- /dev/null +++ b/collection-pipeline/etc/collection-pipeline.urm.puml @@ -0,0 +1,52 @@ +@startuml +package com.iluwatar.collectionpipeline { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Car { + - category : Category + - make : String + - model : String + - year : int + + Car(make : String, model : String, yearOfMake : int, category : Category) + + equals(obj : Object) : boolean + + getCategory() : Category + + getMake() : String + + getModel() : String + + getYear() : int + + hashCode() : int + } + class CarFactory { + - CarFactory() + + createCars() : List {static} + } + enum Category { + + CONVERTIBLE {static} + + JEEP {static} + + SEDAN {static} + + valueOf(name : String) : Category {static} + + values() : Category[] {static} + } + class FunctionalProgramming { + - FunctionalProgramming() + + getGroupingOfCarsByCategory(cars : List) : Map> {static} + + getModelsAfter2000(cars : List) : List {static} + + getSedanCarsOwnedSortedByDate(persons : List) : List {static} + } + class ImperativeProgramming { + - ImperativeProgramming() + + getGroupingOfCarsByCategory(cars : List) : Map> {static} + + getModelsAfter2000(cars : List) : List {static} + + getSedanCarsOwnedSortedByDate(persons : List) : List {static} + } + class Person { + - cars : List + + Person(cars : List) + + getCars() : List + } +} +Person --> "-cars" Car +Car --> "-category" Category +@enduml \ No newline at end of file diff --git a/combinator/etc/combinator.urm.puml b/combinator/etc/combinator.urm.puml new file mode 100644 index 000000000000..83feec1ae782 --- /dev/null +++ b/combinator/etc/combinator.urm.puml @@ -0,0 +1,26 @@ +@startuml +package com.iluwatar.combinator { + class CombinatorApp { + - LOGGER : Logger {static} + + CombinatorApp() + + main(args : String[]) {static} + - text() : String {static} + } + interface Finder { + + and(andFinder : Finder) : Finder + + contains(word : String) : Finder {static} + + find(String) : List {abstract} + + not(notFinder : Finder) : Finder + + or(orFinder : Finder) : Finder + } + class Finders { + - Finders() + + advancedFinder(query : String, orQuery : String, notQuery : String) : Finder {static} + + expandedFinder(queries : String[]) : Finder {static} + + filteredFinder(query : String, excludeQueries : String[]) : Finder {static} + - identMult() : Finder {static} + - identSum() : Finder {static} + + specializedFinder(queries : String[]) : Finder {static} + } +} +@enduml \ No newline at end of file diff --git a/command/etc/command.urm.puml b/command/etc/command.urm.puml new file mode 100644 index 000000000000..a8b773418ee3 --- /dev/null +++ b/command/etc/command.urm.puml @@ -0,0 +1,83 @@ +@startuml +package com.iluwatar.command { + class App { + + App() + + main(args : String[]) {static} + } + abstract class Command { + + Command() + + execute(Target) {abstract} + + redo() {abstract} + + toString() : String {abstract} + + undo() {abstract} + } + class Goblin { + + Goblin() + + toString() : String + } + class InvisibilitySpell { + - target : Target + + InvisibilitySpell() + + execute(target : Target) + + redo() + + toString() : String + + undo() + } + class ShrinkSpell { + - oldSize : Size + - target : Target + + ShrinkSpell() + + execute(target : Target) + + redo() + + toString() : String + + undo() + } + enum Size { + + NORMAL {static} + + SMALL {static} + - title : String + + toString() : String + + valueOf(name : String) : Size {static} + + values() : Size[] {static} + } + abstract class Target { + - LOGGER : Logger {static} + - size : Size + - visibility : Visibility + + Target() + + getSize() : Size + + getVisibility() : Visibility + + printStatus() + + setSize(size : Size) + + setVisibility(visibility : Visibility) + + toString() : String {abstract} + } + enum Visibility { + + INVISIBLE {static} + + VISIBLE {static} + - title : String + + toString() : String + + valueOf(name : String) : Visibility {static} + + values() : Visibility[] {static} + } + class Wizard { + - LOGGER : Logger {static} + - redoStack : Deque + - undoStack : Deque + + Wizard() + + castSpell(command : Command, target : Target) + + redoLastSpell() + + toString() : String + + undoLastSpell() + } +} +Target --> "-size" Size +Wizard --> "-undoStack" Command +ShrinkSpell --> "-oldSize" Size +InvisibilitySpell --> "-target" Target +ShrinkSpell --> "-target" Target +Target --> "-visibility" Visibility +Goblin --|> Target +InvisibilitySpell --|> Command +ShrinkSpell --|> Command +@enduml \ No newline at end of file diff --git a/commander/etc/commander.urm.puml b/commander/etc/commander.urm.puml new file mode 100644 index 000000000000..959fbfadcf88 --- /dev/null +++ b/commander/etc/commander.urm.puml @@ -0,0 +1,329 @@ +@startuml +package com.iluwatar.commander.queue { + class Queue { + - front : Queue.Node + - rear : Queue.Node + - size : int + ~ Queue() + ~ dequeue() : T + ~ enqueue(obj : T) + ~ isEmpty() : boolean + ~ peek() : T + } + ~class Node { + ~ next : Queue.Node + ~ value : V + ~ Node(obj : V, b : Queue.Node) + } + class QueueDatabase { + - data : Queue + + exceptionsList : List + + QueueDatabase(exc : Exception[]) + + add(t : QueueTask) : QueueTask + + dequeue() : QueueTask + + get(taskId : String) : QueueTask + + peek() : QueueTask + } + class QueueTask { + + firstAttemptTime : long + + messageType : int + + order : Order + + taskType : TaskType + + QueueTask(o : Order, t : TaskType, messageType : int) + + getType() : String + } + enum TaskType { + + EmployeeDb {static} + + Messaging {static} + + Payment {static} + + valueOf(name : String) : TaskType {static} + + values() : TaskType[] {static} + } +} +package com.iluwatar.commander.messagingservice { + class MessagingDatabase { + - data : Hashtable + + MessagingDatabase() + + add(r : MessageRequest) : MessageRequest + + get(requestId : String) : MessageRequest + } + class MessagingService { + - LOGGER : Logger {static} + + MessagingService(db : MessagingDatabase, exc : Exception[]) + + receiveRequest(parameters : Object[]) : String + ~ sendMessage(m : MessageToSend) : String + # updateDb(parameters : Object[]) : String + } + ~class MessageRequest { + ~ msg : MessageToSend + ~ reqId : String + ~ MessageRequest(this$0 : String, reqId : MessageToSend) + } + ~enum MessageToSend { + + PaymentFail {static} + + PaymentSuccessful {static} + + PaymentTrying {static} + + valueOf(name : String) : MessageToSend {static} + + values() : MessageToSend[] {static} + } +} +package com.iluwatar.commander { + class AppEmployeeDbFailCases { + - employeeTime : long + - messageTime : long + - numOfRetries : int + - paymentTime : long + - queueTaskTime : long + - queueTime : long + - retryDuration : long + + AppEmployeeDbFailCases() + ~ employeeDatabaseUnavailableCase() + ~ employeeDbSuccessCase() + + main(args : String[]) {static} + } + class AppMessagingFailCases { + - employeeTime : long + - messageTime : long + - numOfRetries : int + - paymentTime : long + - queueTaskTime : long + - queueTime : long + - retryDuration : long + + AppMessagingFailCases() + + main(args : String[]) {static} + ~ messagingDatabaseUnavailableCasePaymentError() + ~ messagingDatabaseUnavailableCasePaymentFailure() + ~ messagingDatabaseUnavailableCasePaymentSuccess() + ~ messagingSuccessCase() + } + class AppPaymentFailCases { + - employeeTime : long + - messageTime : long + - numOfRetries : int + - paymentTime : long + - queueTaskTime : long + - queueTime : long + - retryDuration : long + + AppPaymentFailCases() + + main(args : String[]) {static} + ~ paymentDatabaseUnavailableCase() + ~ paymentNotPossibleCase() + ~ paymentSuccessCase() + } + class AppQueueFailCases { + - employeeTime : long + - messageTime : long + - numOfRetries : int + - paymentTime : long + - queueTaskTime : long + - queueTime : long + - retryDuration : long + + AppQueueFailCases() + + main(args : String[]) {static} + ~ queueEmployeeDbTaskDatabaseUnavailableCase() + ~ queueMessageTaskDatabaseUnavailableCase() + ~ queuePaymentTaskDatabaseUnavailableCase() + ~ queueSuccessCase() + } + class AppShippingFailCases { + - employeeTime : long + - messageTime : long + - numOfRetries : int + - paymentTime : long + - queueTaskTime : long + - queueTime : long + - retryDuration : long + + AppShippingFailCases() + ~ itemUnavailableCase() + + main(args : String[]) {static} + ~ shippingDatabaseUnavailableCase() + ~ shippingNotPossibleCase() + ~ shippingSuccessCase() + } + class Commander { + - LOG : Logger {static} + - employeeDb : EmployeeHandle + - employeeTime : long + - finalSiteMsgShown : boolean + - messageTime : long + - messagingService : MessagingService + - numOfRetries : int + - paymentService : PaymentService + - paymentTime : long + - queue : QueueDatabase + - queueItems : int + - queueTaskTime : long + - queueTime : long + - retryDuration : long + - shippingService : ShippingService + ~ Commander(empDb : EmployeeHandle, paymentService : PaymentService, shippingService : ShippingService, messagingService : MessagingService, qdb : QueueDatabase, numOfRetries : int, retryDuration : long, queueTime : long, queueTaskTime : long, paymentTime : long, messageTime : long, employeeTime : long) + - doTasksInQueue() + - employeeHandleIssue(order : Order) + ~ placeOrder(order : Order) + - sendPaymentFailureMessage(order : Order) + - sendPaymentPossibleErrorMsg(order : Order) + - sendPaymentRequest(order : Order) + - sendShippingRequest(order : Order) + - sendSuccessMessage(order : Order) + - tryDequeue() + - tryDoingTasksInQueue() + - updateQueue(qt : QueueTask) + } + abstract class Database { + + Database() + + add(T) : T {abstract} + + get(String) : T {abstract} + } + class Order { + - ALL_CHARS : String {static} + - RANDOM : Random {static} + - USED_IDS : Hashtable {static} + ~ addedToEmployeeHandle : boolean + ~ createdTime : long + + id : String + ~ item : String + ~ messageSent : MessageSent + ~ paid : PaymentStatus + ~ price : float + ~ user : User + ~ Order(user : User, item : String, price : float) + - createUniqueId() : String + } + ~enum MessageSent { + + NoneSent {static} + + PaymentFail {static} + + PaymentSuccessful {static} + + PaymentTrying {static} + + valueOf(name : String) : MessageSent {static} + + values() : MessageSent[] {static} + } + ~enum PaymentStatus { + + Done {static} + + NotDone {static} + + Trying {static} + + valueOf(name : String) : PaymentStatus {static} + + values() : PaymentStatus[] {static} + } + class Retry { + - RANDOM : Random {static} + - attempts : AtomicInteger + - errors : List + - handleError : Retry.HandleErrorIssue + - maxAttempts : int + - maxDelay : long + - op : Operation + - test : Predicate + ~ Retry(op : Operation, handleError : Retry.HandleErrorIssue, maxAttempts : int, maxDelay : long, ignoreTests : Predicate[]) + + perform(list : List, obj : T) + } + interface HandleErrorIssue { + + handleIssue(T, Exception) {abstract} + } + interface Operation { + + operation(List) {abstract} + } + abstract class Service { + - ALL_CHARS : String {static} + - RANDOM : Random {static} + - USED_IDS : Hashtable {static} + # database : Database + + exceptionsList : ArrayList + # Service(db : Database, exc : Exception[]) + # generateId() : String + + receiveRequest(Object[]) : String {abstract} + # updateDb(Object[]) : String {abstract} + } + class User { + ~ address : String + ~ name : String + ~ User(name : String, address : String) + } +} +package com.iluwatar.commander.shippingservice { + class ShippingDatabase { + - data : Hashtable + + ShippingDatabase() + + add(r : ShippingRequest) : ShippingRequest + + get(trasnactionId : String) : ShippingRequest + } + class ShippingService { + + ShippingService(db : ShippingDatabase, exc : Exception[]) + + receiveRequest(parameters : Object[]) : String + # updateDb(parameters : Object[]) : String + } + ~class ShippingRequest { + ~ address : String + ~ item : String + ~ transactionId : String + ~ ShippingRequest(transactionId : String, item : String, address : String) + } +} +package com.iluwatar.commander.paymentservice { + class PaymentDatabase { + - data : Hashtable + + PaymentDatabase() + + add(r : PaymentRequest) : PaymentRequest + + get(requestId : String) : PaymentRequest + } + class PaymentService { + + PaymentService(db : PaymentDatabase, exc : Exception[]) + + receiveRequest(parameters : Object[]) : String + # updateDb(parameters : Object[]) : String + } + ~class PaymentRequest { + ~ paid : boolean + ~ payment : float + ~ transactionId : String + ~ PaymentRequest(this$0 : String, transactionId : float) + } +} +package com.iluwatar.commander.employeehandle { + class EmployeeDatabase { + - data : Hashtable + + EmployeeDatabase() + + add(o : Order) : Order + + get(orderId : String) : Order + } + class EmployeeHandle { + + EmployeeHandle(db : EmployeeDatabase, exc : Exception[]) + + receiveRequest(parameters : Object[]) : String + # updateDb(parameters : Object[]) : String + } +} +Order --> "-messageSent" MessageSent +MessageSent ..+ Order +MessageToSend ..+ MessagingService +Retry --> "-op" Operation +Operation ..+ Retry +Service --> "-database" Database +Node --> "-next" Node +PaymentRequest --+ PaymentService +Commander --> "-messagingService" MessagingService +ShippingRequest ..+ ShippingService +Commander --> "-shippingService" ShippingService +Commander --> "-paymentService" PaymentService +MessageRequest --+ MessagingService +Commander --> "-employeeDb" EmployeeHandle +HandleErrorIssue ..+ Retry +Retry --> "-handleError" HandleErrorIssue +QueueTask --> "-taskType" TaskType +TaskType ..+ QueueTask +Order --> "-user" User +MessageRequest --> "-msg" MessageToSend +QueueTask --> "-order" Order +Commander --> "-queue" QueueDatabase +QueueDatabase --> "-data" Queue +Queue --> "-front" Node +Node ..+ Queue +Order --> "-paid" PaymentStatus +PaymentStatus ..+ Order +EmployeeDatabase --|> Database +EmployeeHandle --|> Service +MessagingDatabase --|> Database +MessagingService --|> Service +PaymentDatabase --|> Database +PaymentService --|> Service +QueueDatabase --|> Database +ShippingDatabase --|> Database +ShippingService --|> Service +@enduml \ No newline at end of file diff --git a/composite/etc/composite.urm.puml b/composite/etc/composite.urm.puml new file mode 100644 index 000000000000..6ff774711bcd --- /dev/null +++ b/composite/etc/composite.urm.puml @@ -0,0 +1,41 @@ +@startuml +package com.iluwatar.composite { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Letter { + - character : char + + Letter(c : char) + # printThisBefore() + } + abstract class LetterComposite { + - children : List + + LetterComposite() + + add(letter : LetterComposite) + + count() : int + + print() + # printThisAfter() + # printThisBefore() + } + class Messenger { + + Messenger() + ~ messageFromElves() : LetterComposite + ~ messageFromOrcs() : LetterComposite + } + class Sentence { + + Sentence(words : List) + # printThisAfter() + } + class Word { + + Word(letters : List) + + Word(letters : char[]) + # printThisBefore() + } +} +LetterComposite --> "-children" LetterComposite +Letter --|> LetterComposite +Sentence --|> LetterComposite +Word --|> LetterComposite +@enduml \ No newline at end of file diff --git a/converter/etc/converter.urm.puml b/converter/etc/converter.urm.puml new file mode 100644 index 000000000000..275af84e6bc8 --- /dev/null +++ b/converter/etc/converter.urm.puml @@ -0,0 +1,50 @@ +@startuml +package com.iluwatar.converter { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Converter { + - fromDto : Function + - fromEntity : Function + + Converter(fromDto : Function, fromEntity : Function) + + convertFromDto(dto : T) : U + + convertFromEntity(entity : U) : T + + createFromDtos(dtos : Collection) : List + + createFromEntities(entities : Collection) : List + } + class User { + - firstName : String + - isActive : boolean + - lastName : String + - userId : String + + User(firstName : String, lastName : String, isActive : boolean, userId : String) + + equals(o : Object) : boolean + + getFirstName() : String + + getLastName() : String + + getUserId() : String + + hashCode() : int + + isActive() : boolean + + toString() : String + } + class UserConverter { + + UserConverter() + } + class UserDto { + - email : String + - firstName : String + - isActive : boolean + - lastName : String + + UserDto(firstName : String, lastName : String, isActive : boolean, email : String) + + equals(o : Object) : boolean + + getEmail() : String + + getFirstName() : String + + getLastName() : String + + hashCode() : int + + isActive() : boolean + + toString() : String + } +} +UserConverter --|> Converter +@enduml \ No newline at end of file diff --git a/cqrs/etc/cqrs.urm.puml b/cqrs/etc/cqrs.urm.puml new file mode 100644 index 000000000000..2b06980983c5 --- /dev/null +++ b/cqrs/etc/cqrs.urm.puml @@ -0,0 +1,134 @@ +@startuml +package com.iluwatar.cqrs.util { + class HibernateUtil { + - LOGGER : Logger {static} + - SESSIONFACTORY : SessionFactory {static} + + HibernateUtil() + - buildSessionFactory() : SessionFactory {static} + + getSessionFactory() : SessionFactory {static} + } +} +package com.iluwatar.cqrs.app { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +package com.iluwatar.cqrs.dto { + class Author { + - email : String + - name : String + - username : String + + Author() + + Author(name : String, email : String, username : String) + + equals(obj : Object) : boolean + + getEmail() : String + + getName() : String + + getUsername() : String + + hashCode() : int + + toString() : String + } + class Book { + - price : double + - title : String + + Book() + + Book(title : String, price : double) + + equals(obj : Object) : boolean + + getPrice() : double + + getTitle() : String + + hashCode() : int + + toString() : String + } +} +package com.iluwatar.cqrs.commandes { + class CommandServiceImpl { + - sessionFactory : SessionFactory + + CommandServiceImpl() + + authorCreated(username : String, name : String, email : String) + + authorEmailUpdated(username : String, email : String) + + authorNameUpdated(username : String, name : String) + + authorUsernameUpdated(oldUsername : String, newUsername : String) + + bookAddedToAuthor(title : String, price : double, username : String) + + bookPriceUpdated(title : String, price : double) + + bookTitleUpdated(oldTitle : String, newTitle : String) + - getAuthorByUsername(username : String) : Author + - getBookByTitle(title : String) : Book + } + interface ICommandService { + + authorCreated(String, String, String) {abstract} + + authorEmailUpdated(String, String) {abstract} + + authorNameUpdated(String, String) {abstract} + + authorUsernameUpdated(String, String) {abstract} + + bookAddedToAuthor(String, double, String) {abstract} + + bookPriceUpdated(String, double) {abstract} + + bookTitleUpdated(String, String) {abstract} + } +} +package com.iluwatar.cqrs.queries { + interface IQueryService { + + getAuthorBooks(String) : List {abstract} + + getAuthorBooksCount(String) : BigInteger {abstract} + + getAuthorByUsername(String) : Author {abstract} + + getAuthorsCount() : BigInteger {abstract} + + getBook(String) : Book {abstract} + } + class QueryServiceImpl { + - sessionFactory : SessionFactory + + QueryServiceImpl() + + getAuthorBooks(username : String) : List + + getAuthorBooksCount(username : String) : BigInteger + + getAuthorByUsername(username : String) : Author + + getAuthorsCount() : BigInteger + + getBook(title : String) : Book + } +} +package com.iluwatar.cqrs.constants { + class AppConstants { + + E_EVANS : String {static} + + J_BLOCH : String {static} + + M_FOWLER : String {static} + + USER_NAME : String {static} + + AppConstants() + } +} +package com.iluwatar.cqrs.domain.model { + class Author { + - email : String + - id : long + - name : String + - username : String + # Author() + + Author(username : String, name : String, email : String) + + getEmail() : String + + getId() : long + + getName() : String + + getUsername() : String + + setEmail(email : String) + + setId(id : long) + + setName(name : String) + + setUsername(username : String) + + toString() : String + } + class Book { + - author : Author + - id : long + - price : double + - title : String + # Book() + + Book(title : String, price : double, author : Author) + + getAuthor() : Author + + getId() : long + + getPrice() : double + + getTitle() : String + + setAuthor(author : Author) + + setId(id : long) + + setPrice(price : double) + + setTitle(title : String) + + toString() : String + } +} +Book --> "-author" Author +CommandServiceImpl ..|> ICommandService +QueryServiceImpl ..|> IQueryService +@enduml \ No newline at end of file diff --git a/dao/etc/dao.urm.puml b/dao/etc/dao.urm.puml new file mode 100644 index 000000000000..12dfd5e51215 --- /dev/null +++ b/dao/etc/dao.urm.puml @@ -0,0 +1,68 @@ +@startuml +package com.iluwatar.dao { + class App { + - ALL_CUSTOMERS : String {static} + - DB_URL : String {static} + - log : Logger {static} + + App() + - addCustomers(customerDao : CustomerDao) {static} + - createDataSource() : DataSource {static} + - createSchema(dataSource : DataSource) {static} + - deleteSchema(dataSource : DataSource) {static} + + generateSampleCustomers() : List {static} + + main(args : String[]) {static} + - performOperationsUsing(customerDao : CustomerDao) {static} + } + class Customer { + - firstName : String + - id : int + - lastName : String + + Customer(id : int, firstName : String, lastName : String) + + equals(that : Object) : boolean + + getFirstName() : String + + getId() : int + + getLastName() : String + + hashCode() : int + + setFirstName(firstName : String) + + setId(id : int) + + setLastName(lastName : String) + + toString() : String + } + interface CustomerDao { + + add(Customer) : boolean {abstract} + + delete(Customer) : boolean {abstract} + + getAll() : Stream {abstract} + + getById(int) : Optional {abstract} + + update(Customer) : boolean {abstract} + } + class CustomerSchemaSql { + + CREATE_SCHEMA_SQL : String {static} + + DELETE_SCHEMA_SQL : String {static} + - CustomerSchemaSql() + } + class DbCustomerDao { + - LOGGER : Logger {static} + - dataSource : DataSource + + DbCustomerDao(dataSource : DataSource) + + add(customer : Customer) : boolean + - createCustomer(resultSet : ResultSet) : Customer + + delete(customer : Customer) : boolean + + getAll() : Stream + + getById(id : int) : Optional + - getConnection() : Connection + - mutedClose(connection : Connection, statement : PreparedStatement, resultSet : ResultSet) + + update(customer : Customer) : boolean + } + class InMemoryCustomerDao { + - idToCustomer : Map + + InMemoryCustomerDao() + + add(customer : Customer) : boolean + + delete(customer : Customer) : boolean + + getAll() : Stream + + getById(id : int) : Optional + + update(customer : Customer) : boolean + } +} +DbCustomerDao ..|> CustomerDao +InMemoryCustomerDao ..|> CustomerDao +@enduml \ No newline at end of file diff --git a/data-bus/etc/data-bus.urm.puml b/data-bus/etc/data-bus.urm.puml new file mode 100644 index 000000000000..8ca7f85efb11 --- /dev/null +++ b/data-bus/etc/data-bus.urm.puml @@ -0,0 +1,82 @@ +@startuml +package com.iluwatar.databus { + class AbstractDataType { + - dataBus : DataBus + + AbstractDataType() + + getDataBus() : DataBus + + setDataBus(dataBus : DataBus) + } + ~class App { + ~ App() + + main(args : String[]) {static} + } + class DataBus { + - INSTANCE : DataBus {static} + - listeners : Set + + DataBus() + + getInstance() : DataBus {static} + + publish(event : DataType) + + subscribe(member : Member) + + unsubscribe(member : Member) + } + interface DataType { + + getDataBus() : DataBus {abstract} + + setDataBus(DataBus) {abstract} + } + interface Member { + + accept(DataType) {abstract} + } +} +package com.iluwatar.databus.data { + class MessageData { + - message : String + + MessageData(message : String) + + getMessage() : String + + of(message : String) : DataType {static} + } + class StartingData { + - when : LocalDateTime + + StartingData(when : LocalDateTime) + + getWhen() : LocalDateTime + + of(when : LocalDateTime) : DataType {static} + } + class StoppingData { + - when : LocalDateTime + + StoppingData(when : LocalDateTime) + + getWhen() : LocalDateTime + + of(when : LocalDateTime) : DataType {static} + } +} +package com.iluwatar.databus.members { + class MessageCollectorMember { + - LOGGER : Logger {static} + - messages : List + - name : String + + MessageCollectorMember(name : String) + + accept(data : DataType) + + getMessages() : List + - handleEvent(data : MessageData) + } + class StatusMember { + - LOGGER : Logger {static} + - id : int + - started : LocalDateTime + - stopped : LocalDateTime + + StatusMember(id : int) + + accept(data : DataType) + + getStarted() : LocalDateTime + + getStopped() : LocalDateTime + - handleEvent(data : StartingData) + - handleEvent(data : StoppingData) + } +} +AbstractDataType --> "-dataBus" DataBus +DataBus --> "-INSTANCE" DataBus +DataBus --> "-listeners" Member +AbstractDataType ..|> DataType +MessageData --|> AbstractDataType +StartingData --|> AbstractDataType +StoppingData --|> AbstractDataType +MessageCollectorMember ..|> Member +StatusMember ..|> Member +@enduml \ No newline at end of file diff --git a/data-locality/etc/data-locality.urm.puml b/data-locality/etc/data-locality.urm.puml new file mode 100644 index 000000000000..1e2d3e6793cb --- /dev/null +++ b/data-locality/etc/data-locality.urm.puml @@ -0,0 +1,80 @@ +@startuml +package com.iluwatar.data.locality.game.component.manager { + class AiComponentManager { + - AI_COMPONENTS : Component[] {static} + - LOGGER : Logger {static} + - MAX_ENTITIES : int {static} + - numEntities : int + + AiComponentManager(numEntities : int) + + start() + + update() + } + class PhysicsComponentManager { + - LOGGER : Logger {static} + - MAX_ENTITIES : int {static} + - PHYSICS_COMPONENTS : Component[] {static} + - numEntities : int + + PhysicsComponentManager(numEntities : int) + + start() + + update() + } + class RenderComponentManager { + - LOGGER : Logger {static} + - MAX_ENTITIES : int {static} + - RENDER_COMPONENTS : Component[] {static} + - numEntities : int + + RenderComponentManager(numEntities : int) + + render() + + start() + } +} +package com.iluwatar.data.locality { + class Application { + - LOGGER : Logger {static} + - NUM_ENTITIES : int {static} + + Application() + + main(args : String[]) {static} + } +} +package com.iluwatar.data.locality.game { + class GameEntity { + - LOGGER : Logger {static} + - aiComponentManager : AiComponentManager + - physicsComponentManager : PhysicsComponentManager + - renderComponentManager : RenderComponentManager + + GameEntity(numEntities : int) + + start() + + update() + } +} +package com.iluwatar.data.locality.game.component { + class AiComponent { + - LOGGER : Logger {static} + + AiComponent() + + render() + + update() + } + interface Component { + + render() {abstract} + + update() {abstract} + } + class PhysicsComponent { + - LOGGER : Logger {static} + + PhysicsComponent() + + render() + + update() + } + class RenderComponent { + - LOGGER : Logger {static} + + RenderComponent() + + render() + + update() + } +} +GameEntity --> "-physicsComponentManager" PhysicsComponentManager +GameEntity --> "-aiComponentManager" AiComponentManager +GameEntity --> "-renderComponentManager" RenderComponentManager +AiComponent ..|> Component +PhysicsComponent ..|> Component +RenderComponent ..|> Component +@enduml \ No newline at end of file diff --git a/data-mapper/etc/data-mapper.urm.puml b/data-mapper/etc/data-mapper.urm.puml new file mode 100644 index 000000000000..3b32411d11c9 --- /dev/null +++ b/data-mapper/etc/data-mapper.urm.puml @@ -0,0 +1,43 @@ +@startuml +package com.iluwatar.datamapper { + class App { + - STUDENT_STRING : String {static} + - log : Logger {static} + - App() + + main(args : String[]) {static} + } + class Student { + - grade : char + - name : String + - serialVersionUID : long {static} + - studentId : int + + Student(studentId : int, name : String, grade : char) + + equals(inputObject : Object) : boolean + + getGrade() : char + + getName() : String + + getStudentId() : int + + hashCode() : int + + setGrade(grade : char) + + setName(name : String) + + setStudentId(studentId : int) + + toString() : String + } + interface StudentDataMapper { + + delete(Student) {abstract} + + find(int) : Optional {abstract} + + insert(Student) {abstract} + + update(Student) {abstract} + } + class StudentDataMapperImpl { + - students : List + + StudentDataMapperImpl() + + delete(studentToBeDeleted : Student) + + find(studentId : int) : Optional + + getStudents() : List + + insert(studentToBeInserted : Student) + + update(studentToBeUpdated : Student) + } +} +StudentDataMapperImpl --> "-students" Student +StudentDataMapperImpl ..|> StudentDataMapper +@enduml \ No newline at end of file diff --git a/data-transfer-object/etc/data-transfer-object.urm.puml b/data-transfer-object/etc/data-transfer-object.urm.puml new file mode 100644 index 000000000000..ee96c37ca967 --- /dev/null +++ b/data-transfer-object/etc/data-transfer-object.urm.puml @@ -0,0 +1,27 @@ +@startuml +package com.iluwatar.datatransfer { + class CustomerClientApp { + - LOGGER : Logger {static} + + CustomerClientApp() + + main(args : String[]) {static} + - printCustomerDetails(allCustomers : List) {static} + } + class CustomerDto { + - firstName : String + - id : String + - lastName : String + + CustomerDto(id : String, firstName : String, lastName : String) + + getFirstName() : String + + getId() : String + + getLastName() : String + } + class CustomerResource { + - customers : List + + CustomerResource(customers : List) + + delete(customerId : String) + + getAllCustomers() : List + + save(customer : CustomerDto) + } +} +CustomerResource --> "-customers" CustomerDto +@enduml \ No newline at end of file diff --git a/decorator/etc/decorator.urm.puml b/decorator/etc/decorator.urm.puml new file mode 100644 index 000000000000..edfd927600f5 --- /dev/null +++ b/decorator/etc/decorator.urm.puml @@ -0,0 +1,32 @@ +@startuml +package com.iluwatar.decorator { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class ClubbedTroll { + - LOGGER : Logger {static} + - decorated : Troll + + ClubbedTroll(decorated : Troll) + + attack() + + fleeBattle() + + getAttackPower() : int + } + class SimpleTroll { + - LOGGER : Logger {static} + + SimpleTroll() + + attack() + + fleeBattle() + + getAttackPower() : int + } + interface Troll { + + attack() {abstract} + + fleeBattle() {abstract} + + getAttackPower() : int {abstract} + } +} +ClubbedTroll --> "-decorated" Troll +ClubbedTroll ..|> Troll +SimpleTroll ..|> Troll +@enduml \ No newline at end of file diff --git a/delegation/etc/delegation.urm.puml b/delegation/etc/delegation.urm.puml new file mode 100644 index 000000000000..169f7103f061 --- /dev/null +++ b/delegation/etc/delegation.urm.puml @@ -0,0 +1,39 @@ +@startuml +package com.iluwatar.delegation.simple.printers { + class CanonPrinter { + - LOGGER : Logger {static} + + CanonPrinter() + + print(message : String) + } + class EpsonPrinter { + - LOGGER : Logger {static} + + EpsonPrinter() + + print(message : String) + } + class HpPrinter { + - LOGGER : Logger {static} + + HpPrinter() + + print(message : String) + } +} +package com.iluwatar.delegation.simple { + class App { + - MESSAGE_TO_PRINT : String {static} + + App() + + main(args : String[]) {static} + } + interface Printer { + + print(String) {abstract} + } + class PrinterController { + - printer : Printer + + PrinterController(printer : Printer) + + print(message : String) + } +} +PrinterController --> "-printer" Printer +PrinterController ..|> Printer +CanonPrinter ..|> Printer +EpsonPrinter ..|> Printer +HpPrinter ..|> Printer +@enduml \ No newline at end of file diff --git a/dependency-injection/etc/dependency-injection.urm.puml b/dependency-injection/etc/dependency-injection.urm.puml new file mode 100644 index 000000000000..84ed3c6dd321 --- /dev/null +++ b/dependency-injection/etc/dependency-injection.urm.puml @@ -0,0 +1,57 @@ +@startuml +package com.iluwatar.dependency.injection { + class AdvancedSorceress { + - tobacco : Tobacco + + AdvancedSorceress() + + setTobacco(tobacco : Tobacco) + + smoke() + } + class AdvancedWizard { + - tobacco : Tobacco + + AdvancedWizard(tobacco : Tobacco) + + smoke() + } + class App { + + App() + + main(args : String[]) {static} + } + class GuiceWizard { + - tobacco : Tobacco + + GuiceWizard(tobacco : Tobacco) + + smoke() + } + class OldTobyTobacco { + + OldTobyTobacco() + } + class RivendellTobacco { + + RivendellTobacco() + } + class SecondBreakfastTobacco { + + SecondBreakfastTobacco() + } + class SimpleWizard { + - tobacco : OldTobyTobacco + + SimpleWizard() + + smoke() + } + abstract class Tobacco { + - LOGGER : Logger {static} + + Tobacco() + + smoke(wizard : Wizard) + } + interface Wizard { + + smoke() {abstract} + } +} +AdvancedSorceress --> "-tobacco" Tobacco +SimpleWizard --> "-tobacco" OldTobyTobacco +AdvancedWizard --> "-tobacco" Tobacco +GuiceWizard --> "-tobacco" Tobacco +AdvancedSorceress ..|> Wizard +AdvancedWizard ..|> Wizard +GuiceWizard ..|> Wizard +OldTobyTobacco --|> Tobacco +RivendellTobacco --|> Tobacco +SecondBreakfastTobacco --|> Tobacco +SimpleWizard ..|> Wizard +@enduml \ No newline at end of file diff --git a/dirty-flag/etc/dirty-flag.urm.puml b/dirty-flag/etc/dirty-flag.urm.puml new file mode 100644 index 000000000000..9685d3fdfbe4 --- /dev/null +++ b/dirty-flag/etc/dirty-flag.urm.puml @@ -0,0 +1,25 @@ +@startuml +package com.iluwatar.dirtyflag { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + + run() + } + class DataFetcher { + - LOGGER : Logger {static} + - filename : String + - lastFetched : long + + DataFetcher() + + fetch() : List + - isDirty(fileLastModified : long) : boolean + } + class World { + - countries : List + - df : DataFetcher + + World() + + fetch() : List + } +} +World --> "-df" DataFetcher +@enduml \ No newline at end of file diff --git a/double-buffer/etc/double-buffer.urm.puml b/double-buffer/etc/double-buffer.urm.puml new file mode 100644 index 000000000000..7555c972b5ed --- /dev/null +++ b/double-buffer/etc/double-buffer.urm.puml @@ -0,0 +1,45 @@ +@startuml +package com.iluwatar.doublebuffer { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + - printBlackPixelCoordinate(buffer : Buffer) {static} + } + interface Buffer { + + clear(int, int) {abstract} + + clearAll() {abstract} + + draw(int, int) {abstract} + + getPixels() : Pixel[] {abstract} + } + class FrameBuffer { + + HEIGHT : int {static} + + WIDTH : int {static} + - pixels : Pixel[] + + FrameBuffer() + + clear(x : int, y : int) + + clearAll() + + draw(x : int, y : int) + - getIndex(x : int, y : int) : int + + getPixels() : Pixel[] + } + enum Pixel { + + BLACK {static} + + WHITE {static} + - color : int + + valueOf(name : String) : Pixel {static} + + values() : Pixel[] {static} + } + class Scene { + - LOGGER : Logger {static} + - current : int + - frameBuffers : Buffer[] + - next : int + + Scene() + + draw(coordinateList : List>) + + getBuffer() : Buffer + - swap() + } +} +FrameBuffer ..|> Buffer +@enduml \ No newline at end of file diff --git a/double-checked-locking/etc/double-checked-locking.urm.puml b/double-checked-locking/etc/double-checked-locking.urm.puml new file mode 100644 index 000000000000..242519fce77c --- /dev/null +++ b/double-checked-locking/etc/double-checked-locking.urm.puml @@ -0,0 +1,22 @@ +@startuml +package com.iluwatar.doublechecked.locking { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Inventory { + - LOGGER : Logger {static} + - inventorySize : int + - items : List + - lock : Lock + + Inventory(inventorySize : int) + + addItem(item : Item) : boolean + + getItems() : List + } + class Item { + + Item() + } +} +Inventory --> "-items" Item +@enduml \ No newline at end of file diff --git a/double-dispatch/etc/double-dispatch.urm.puml b/double-dispatch/etc/double-dispatch.urm.puml new file mode 100644 index 000000000000..17bcb1431bd6 --- /dev/null +++ b/double-dispatch/etc/double-dispatch.urm.puml @@ -0,0 +1,74 @@ +@startuml +package com.iluwatar.doubledispatch.constants { + class AppConstants { + + HITS : String {static} + + AppConstants() + } +} +package com.iluwatar.doubledispatch { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class FlamingAsteroid { + + FlamingAsteroid(left : int, top : int, right : int, bottom : int) + + collision(gameObject : GameObject) + } + abstract class GameObject { + - damaged : boolean + - onFire : boolean + + GameObject(left : int, top : int, right : int, bottom : int) + + collision(GameObject) {abstract} + + collisionResolve(FlamingAsteroid) {abstract} + + collisionResolve(Meteoroid) {abstract} + + collisionResolve(SpaceStationIss) {abstract} + + collisionResolve(SpaceStationMir) {abstract} + + isDamaged() : boolean + + isOnFire() : boolean + + setDamaged(damaged : boolean) + + setOnFire(onFire : boolean) + + toString() : String + } + class Meteoroid { + - LOGGER : Logger {static} + + Meteoroid(left : int, top : int, right : int, bottom : int) + + collision(gameObject : GameObject) + + collisionResolve(asteroid : FlamingAsteroid) + + collisionResolve(iss : SpaceStationIss) + + collisionResolve(meteoroid : Meteoroid) + + collisionResolve(mir : SpaceStationMir) + } + class Rectangle { + - bottom : int + - left : int + - right : int + - top : int + + Rectangle(left : int, top : int, right : int, bottom : int) + + getBottom() : int + + getLeft() : int + + getRight() : int + + getTop() : int + ~ intersectsWith(r : Rectangle) : boolean + + toString() : String + } + class SpaceStationIss { + + SpaceStationIss(left : int, top : int, right : int, bottom : int) + + collision(gameObject : GameObject) + } + class SpaceStationMir { + - LOGGER : Logger {static} + + SpaceStationMir(left : int, top : int, right : int, bottom : int) + + collision(gameObject : GameObject) + + collisionResolve(asteroid : FlamingAsteroid) + + collisionResolve(iss : SpaceStationIss) + + collisionResolve(meteoroid : Meteoroid) + + collisionResolve(mir : SpaceStationMir) + } +} +FlamingAsteroid --|> Meteoroid +GameObject --|> Rectangle +Meteoroid --|> GameObject +SpaceStationIss --|> SpaceStationMir +SpaceStationMir --|> GameObject +@enduml \ No newline at end of file diff --git a/eip-aggregator/etc/eip-aggregator.urm.puml b/eip-aggregator/etc/eip-aggregator.urm.puml new file mode 100644 index 000000000000..4d8661e210c2 --- /dev/null +++ b/eip-aggregator/etc/eip-aggregator.urm.puml @@ -0,0 +1,14 @@ +@startuml +package com.iluwatar.eip.aggregator { + class App { + + App() + + main(args : String[]) {static} + } +} +package com.iluwatar.eip.aggregator.routes { + class MessageAggregationStrategy { + + MessageAggregationStrategy() + + aggregate(oldExchange : Exchange, newExchange : Exchange) : Exchange + } +} +@enduml \ No newline at end of file diff --git a/eip-message-channel/etc/eip-message-channel.urm.puml b/eip-message-channel/etc/eip-message-channel.urm.puml new file mode 100644 index 000000000000..38e2369ce562 --- /dev/null +++ b/eip-message-channel/etc/eip-message-channel.urm.puml @@ -0,0 +1,9 @@ +@startuml +package com.iluwatar.eip.message.channel { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/eip-publish-subscribe/etc/eip-publish-subscribe.urm.puml b/eip-publish-subscribe/etc/eip-publish-subscribe.urm.puml new file mode 100644 index 000000000000..a201f59bba67 --- /dev/null +++ b/eip-publish-subscribe/etc/eip-publish-subscribe.urm.puml @@ -0,0 +1,9 @@ +@startuml +package com.iluwatar.eip.publish.subscribe { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/eip-splitter/etc/eip-splitter.urm.puml b/eip-splitter/etc/eip-splitter.urm.puml new file mode 100644 index 000000000000..ad063b709c3d --- /dev/null +++ b/eip-splitter/etc/eip-splitter.urm.puml @@ -0,0 +1,8 @@ +@startuml +package com.iluwatar.eip.splitter { + class App { + + App() + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/eip-wire-tap/etc/eip-wire-tap.urm.puml b/eip-wire-tap/etc/eip-wire-tap.urm.puml new file mode 100644 index 000000000000..51ee99723cc8 --- /dev/null +++ b/eip-wire-tap/etc/eip-wire-tap.urm.puml @@ -0,0 +1,8 @@ +@startuml +package com.iluwatar.eip.wiretap { + class App { + + App() + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/etc/java-design-patterns.urm.puml b/etc/java-design-patterns.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/etc/java-design-patterns.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/event-aggregator/etc/event-aggregator.urm.puml b/event-aggregator/etc/event-aggregator.urm.puml new file mode 100644 index 000000000000..341d7d65e02c --- /dev/null +++ b/event-aggregator/etc/event-aggregator.urm.puml @@ -0,0 +1,74 @@ +@startuml +package com.iluwatar.event.aggregator { + class App { + + App() + + main(args : String[]) {static} + } + enum Event { + + STARK_SIGHTED {static} + + TRAITOR_DETECTED {static} + + WARSHIPS_APPROACHING {static} + - description : String + + toString() : String + + valueOf(name : String) : Event {static} + + values() : Event[] {static} + } + abstract class EventEmitter { + - observers : List + + EventEmitter() + + EventEmitter(obs : EventObserver) + # notifyObservers(e : Event) + + registerObserver(obs : EventObserver) + + timePasses(Weekday) {abstract} + } + interface EventObserver { + + onEvent(Event) {abstract} + } + class KingJoffrey { + - LOGGER : Logger {static} + + KingJoffrey() + + onEvent(e : Event) + } + class KingsHand { + + KingsHand() + + KingsHand(obs : EventObserver) + + onEvent(e : Event) + + timePasses(day : Weekday) + } + class LordBaelish { + + LordBaelish() + + LordBaelish(obs : EventObserver) + + timePasses(day : Weekday) + } + class LordVarys { + + LordVarys() + + LordVarys(obs : EventObserver) + + timePasses(day : Weekday) + } + class Scout { + + Scout() + + Scout(obs : EventObserver) + + timePasses(day : Weekday) + } + enum Weekday { + + FRIDAY {static} + + MONDAY {static} + + SATURDAY {static} + + SUNDAY {static} + + THURSDAY {static} + + TUESDAY {static} + + WEDNESDAY {static} + - description : String + + toString() : String + + valueOf(name : String) : Weekday {static} + + values() : Weekday[] {static} + } +} +EventEmitter --> "-observers" EventObserver +KingJoffrey ..|> EventObserver +KingsHand ..|> EventObserver +KingsHand --|> EventEmitter +LordBaelish --|> EventEmitter +LordVarys --|> EventEmitter +Scout --|> EventEmitter +@enduml \ No newline at end of file diff --git a/event-asynchronous/etc/event-asynchronous.urm.puml b/event-asynchronous/etc/event-asynchronous.urm.puml new file mode 100644 index 000000000000..3a896c32f59f --- /dev/null +++ b/event-asynchronous/etc/event-asynchronous.urm.puml @@ -0,0 +1,70 @@ +@startuml +package com.iluwatar.event.asynchronous { + class App { + - LOGGER : Logger {static} + + PROP_FILE_NAME : String {static} + ~ interactiveMode : boolean + + App() + + main(args : String[]) {static} + - processOption1(eventManager : EventManager, s : Scanner) + - processOption2(eventManager : EventManager, s : Scanner) + - processOption3(eventManager : EventManager, s : Scanner) + + quickRun() + + run() + + runInteractiveMode() + + setUp() + } + class Event { + - LOGGER : Logger {static} + - eventId : int + - eventListener : ThreadCompleteListener + - eventTime : int + - isComplete : boolean + - isSynchronous : boolean + - thread : Thread + + Event(eventId : int, eventTime : int, isSynchronous : boolean) + + addListener(listener : ThreadCompleteListener) + - completed() + + isSynchronous() : boolean + + removeListener(listener : ThreadCompleteListener) + + run() + + start() + + status() + + stop() + } + class EventManager { + - DOES_NOT_EXIST : String {static} + + MAX_EVENT_TIME : int {static} + + MAX_ID : int {static} + + MAX_RUNNING_EVENTS : int {static} + + MIN_ID : int {static} + - currentlyRunningSyncEvent : int + - eventPool : Map + - rand : Random + + EventManager() + + cancel(eventId : int) + + completedEventHandler(eventId : int) + + create(eventTime : int) : int + + createAsync(eventTime : int) : int + - createEvent(eventTime : int, isSynchronous : boolean) : int + - generateId() : int + + getEventPool() : Map + + numOfCurrentlyRunningSyncEvent() : int + + shutdown() + + start(eventId : int) + + status(eventId : int) + + statusOfAllEvents() + } + interface IEvent { + + start() {abstract} + + status() {abstract} + + stop() {abstract} + } + interface ThreadCompleteListener { + + completedEventHandler(int) {abstract} + } +} +Event --> "-eventListener" ThreadCompleteListener +Event ..|> IEvent +EventManager ..|> ThreadCompleteListener +@enduml \ No newline at end of file diff --git a/event-driven-architecture/etc/event-driven-architecture.urm.puml b/event-driven-architecture/etc/event-driven-architecture.urm.puml new file mode 100644 index 000000000000..6b67f0a0e569 --- /dev/null +++ b/event-driven-architecture/etc/event-driven-architecture.urm.puml @@ -0,0 +1,64 @@ +@startuml +package com.iluwatar.eda.handler { + class UserCreatedEventHandler { + - LOGGER : Logger {static} + + UserCreatedEventHandler() + + onEvent(event : UserCreatedEvent) + } + class UserUpdatedEventHandler { + - LOGGER : Logger {static} + + UserUpdatedEventHandler() + + onEvent(event : UserUpdatedEvent) + } +} +package com.iluwatar.eda.event { + abstract class AbstractEvent { + + AbstractEvent() + + getType() : Class + } + class UserCreatedEvent { + - user : User + + UserCreatedEvent(user : User) + + getUser() : User + } + class UserUpdatedEvent { + - user : User + + UserUpdatedEvent(user : User) + + getUser() : User + } +} +package com.iluwatar.eda.framework { + interface Event { + + getType() : Class {abstract} + } + class EventDispatcher { + - handlers : Map, Handler> + + EventDispatcher() + + dispatch(event : E extends Event) + + registerHandler(eventType : Class, handler : Handler) + } + interface Handler { + + onEvent(E extends Event) {abstract} + } +} +package com.iluwatar.eda.model { + class User { + - username : String + + User(username : String) + + getUsername() : String + } +} +package com.iluwatar.eda { + class App { + + App() + + main(args : String[]) {static} + } +} +UserCreatedEvent --> "-user" User +UserUpdatedEvent --> "-user" User +AbstractEvent ..|> Event +UserCreatedEvent --|> AbstractEvent +UserUpdatedEvent --|> AbstractEvent +UserCreatedEventHandler ..|> Handler +UserUpdatedEventHandler ..|> Handler +@enduml \ No newline at end of file diff --git a/event-queue/etc/event-queue.urm.puml b/event-queue/etc/event-queue.urm.puml new file mode 100644 index 000000000000..de4390e4e599 --- /dev/null +++ b/event-queue/etc/event-queue.urm.puml @@ -0,0 +1,38 @@ +@startuml +package com.iluwatar.event.queue { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Audio { + - INSTANCE : Audio {static} + - LOGGER : Logger {static} + - MAX_PENDING : int {static} + - headIndex : int + - pendingAudio : PlayMessage[] + - tailIndex : int + - updateThread : Thread + ~ Audio() + + getAudioStream(filePath : String) : AudioInputStream + + getInstance() : Audio {static} + + getPendingAudio() : PlayMessage[] + + init() + + isServiceRunning() : boolean + + playSound(stream : AudioInputStream, volume : float) + - startThread() + + stopService() + - update() + } + class PlayMessage { + - stream : AudioInputStream + - volume : float + + PlayMessage(stream : AudioInputStream, volume : float) + + getStream() : AudioInputStream + + getVolume() : float + - setStream(stream : AudioInputStream) + + setVolume(volume : float) + } +} +Audio --> "-INSTANCE" Audio +@enduml \ No newline at end of file diff --git a/event-sourcing/etc/event-sourcing.urm.puml b/event-sourcing/etc/event-sourcing.urm.puml new file mode 100644 index 000000000000..363af9967012 --- /dev/null +++ b/event-sourcing/etc/event-sourcing.urm.puml @@ -0,0 +1,107 @@ +@startuml +package com.iluwatar.event.sourcing.processor { + class DomainEventProcessor { + - processorJournal : JsonFileJournal + + DomainEventProcessor() + + process(domainEvent : DomainEvent) + + recover() + + reset() + } + class JsonFileJournal { + - events : List + - file : File + - index : int + + JsonFileJournal() + + readNext() : DomainEvent + + reset() + + write(domainEvent : DomainEvent) + } +} +package com.iluwatar.event.sourcing.event { + class AccountCreateEvent { + - accountNo : int + - owner : String + + AccountCreateEvent(sequenceId : long, createdTime : long, accountNo : int, owner : String) + + getAccountNo() : int + + getOwner() : String + + process() + } + abstract class DomainEvent { + - createdTime : long + - eventClassName : String + - realTime : boolean + - sequenceId : long + + DomainEvent(sequenceId : long, createdTime : long, eventClassName : String) + + getCreatedTime() : long + + getEventClassName() : String + + getSequenceId() : long + + isRealTime() : boolean + + process() {abstract} + + setRealTime(realTime : boolean) + } + class MoneyDepositEvent { + - accountNo : int + - money : BigDecimal + + MoneyDepositEvent(sequenceId : long, createdTime : long, accountNo : int, money : BigDecimal) + + getAccountNo() : int + + getMoney() : BigDecimal + + process() + } + class MoneyTransferEvent { + - accountNoFrom : int + - accountNoTo : int + - money : BigDecimal + + MoneyTransferEvent(sequenceId : long, createdTime : long, money : BigDecimal, accountNoFrom : int, accountNoTo : int) + + getAccountNoFrom() : int + + getAccountNoTo() : int + + getMoney() : BigDecimal + + process() + } +} +package com.iluwatar.event.sourcing.app { + class App { + + ACCOUNT_OF_DAENERYS : int {static} + + ACCOUNT_OF_JON : int {static} + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +package com.iluwatar.event.sourcing.state { + class AccountAggregate { + - accounts : Map {static} + - AccountAggregate() + + getAccount(accountNo : int) : Account {static} + + putAccount(account : Account) {static} + + resetState() {static} + } +} +package com.iluwatar.event.sourcing.domain { + class Account { + - LOGGER : Logger {static} + - MSG : String {static} + - accountNo : int + - money : BigDecimal + - owner : String + + Account(accountNo : int, owner : String) + + copy() : Account + - depositMoney(money : BigDecimal) + + getAccountNo() : int + + getMoney() : BigDecimal + + getOwner() : String + - handleDeposit(money : BigDecimal, realTime : boolean) + + handleEvent(accountCreateEvent : AccountCreateEvent) + + handleEvent(moneyDepositEvent : MoneyDepositEvent) + + handleTransferFromEvent(moneyTransferEvent : MoneyTransferEvent) + + handleTransferToEvent(moneyTransferEvent : MoneyTransferEvent) + - handleWithdrawal(money : BigDecimal, realTime : boolean) + + setMoney(money : BigDecimal) + + toString() : String + - withdrawMoney(money : BigDecimal) + } +} +DomainEventProcessor --> "-processorJournal" JsonFileJournal +AccountCreateEvent --|> DomainEvent +MoneyDepositEvent --|> DomainEvent +MoneyTransferEvent --|> DomainEvent +@enduml \ No newline at end of file diff --git a/execute-around/etc/execute-around.urm.puml b/execute-around/etc/execute-around.urm.puml new file mode 100644 index 000000000000..fd01a5fe1fe9 --- /dev/null +++ b/execute-around/etc/execute-around.urm.puml @@ -0,0 +1,14 @@ +@startuml +package com.iluwatar.execute.around { + class App { + + App() + + main(args : String[]) {static} + } + interface FileWriterAction { + + writeFile(FileWriter) {abstract} + } + class SimpleFileWriter { + + SimpleFileWriter(filename : String, action : FileWriterAction) + } +} +@enduml \ No newline at end of file diff --git a/extension-objects/etc/extension-objects.urm.puml b/extension-objects/etc/extension-objects.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/extension-objects/etc/extension-objects.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/facade/etc/facade.urm.puml b/facade/etc/facade.urm.puml new file mode 100644 index 000000000000..477f9eee7e47 --- /dev/null +++ b/facade/etc/facade.urm.puml @@ -0,0 +1,60 @@ +@startuml +package com.iluwatar.facade { + class App { + + App() + + main(args : String[]) {static} + } + class DwarvenCartOperator { + - LOGGER : Logger {static} + + DwarvenCartOperator() + + name() : String + + work() + } + class DwarvenGoldDigger { + - LOGGER : Logger {static} + + DwarvenGoldDigger() + + name() : String + + work() + } + class DwarvenGoldmineFacade { + - workers : List + + DwarvenGoldmineFacade() + + digOutGold() + + endDay() + - makeActions(workers : Collection, actions : Action[]) {static} + + startNewDay() + } + abstract class DwarvenMineWorker { + - LOGGER : Logger {static} + + DwarvenMineWorker() + - action(action : Action) + + action(actions : Action[]) + + goHome() + + goToMine() + + goToSleep() + + name() : String {abstract} + + wakeUp() + + work() {abstract} + } + ~enum Action { + + GO_HOME {static} + + GO_TO_MINE {static} + + GO_TO_SLEEP {static} + + WAKE_UP {static} + + WORK {static} + + valueOf(name : String) : Action {static} + + values() : Action[] {static} + } + class DwarvenTunnelDigger { + - LOGGER : Logger {static} + + DwarvenTunnelDigger() + + name() : String + + work() + } +} +DwarvenGoldmineFacade --> "-workers" DwarvenMineWorker +Action ..+ DwarvenMineWorker +DwarvenCartOperator --|> DwarvenMineWorker +DwarvenGoldDigger --|> DwarvenMineWorker +DwarvenTunnelDigger --|> DwarvenMineWorker +@enduml \ No newline at end of file diff --git a/factory-kit/etc/factory-kit.urm.puml b/factory-kit/etc/factory-kit.urm.puml new file mode 100644 index 000000000000..23cf658f467e --- /dev/null +++ b/factory-kit/etc/factory-kit.urm.puml @@ -0,0 +1,46 @@ +@startuml +package com.iluwatar.factorykit { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Axe { + + Axe() + + toString() : String + } + class Bow { + + Bow() + + toString() : String + } + interface Builder { + + add(WeaponType, Supplier) {abstract} + } + class Spear { + + Spear() + + toString() : String + } + class Sword { + + Sword() + + toString() : String + } + interface Weapon { + } + interface WeaponFactory { + + create(WeaponType) : Weapon {abstract} + + factory(consumer : Consumer) : WeaponFactory {static} + } + enum WeaponType { + + AXE {static} + + BOW {static} + + SPEAR {static} + + SWORD {static} + + valueOf(name : String) : WeaponType {static} + + values() : WeaponType[] {static} + } +} +Axe ..|> Weapon +Bow ..|> Weapon +Spear ..|> Weapon +Sword ..|> Weapon +@enduml \ No newline at end of file diff --git a/factory-method/etc/factory-method.urm.puml b/factory-method/etc/factory-method.urm.puml new file mode 100644 index 000000000000..a5d8d4e22f7c --- /dev/null +++ b/factory-method/etc/factory-method.urm.puml @@ -0,0 +1,56 @@ +@startuml +package com.iluwatar.factory.method { + class App { + - LOGGER : Logger {static} + - blacksmith : Blacksmith + + App(blacksmith : Blacksmith) + + main(args : String[]) {static} + - manufactureWeapons() + } + interface Blacksmith { + + manufactureWeapon(WeaponType) : Weapon {abstract} + } + class ElfBlacksmith { + - ELFARSENAL : Map {static} + + ElfBlacksmith() + + manufactureWeapon(weaponType : WeaponType) : Weapon + } + class ElfWeapon { + - weaponType : WeaponType + + ElfWeapon(weaponType : WeaponType) + + getWeaponType() : WeaponType + + toString() : String + } + class OrcBlacksmith { + - ORCARSENAL : Map {static} + + OrcBlacksmith() + + manufactureWeapon(weaponType : WeaponType) : Weapon + } + class OrcWeapon { + - weaponType : WeaponType + + OrcWeapon(weaponType : WeaponType) + + getWeaponType() : WeaponType + + toString() : String + } + interface Weapon { + + getWeaponType() : WeaponType {abstract} + } + enum WeaponType { + + AXE {static} + + SHORT_SWORD {static} + + SPEAR {static} + + UNDEFINED {static} + - title : String + + toString() : String + + valueOf(name : String) : WeaponType {static} + + values() : WeaponType[] {static} + } +} +ElfWeapon --> "-weaponType" WeaponType +OrcWeapon --> "-weaponType" WeaponType +App --> "-blacksmith" Blacksmith +ElfBlacksmith ..|> Blacksmith +ElfWeapon ..|> Weapon +OrcBlacksmith ..|> Blacksmith +OrcWeapon ..|> Weapon +@enduml \ No newline at end of file diff --git a/feature-toggle/etc/feature-toggle.urm.puml b/feature-toggle/etc/feature-toggle.urm.puml new file mode 100644 index 000000000000..0febb26319d1 --- /dev/null +++ b/feature-toggle/etc/feature-toggle.urm.puml @@ -0,0 +1,48 @@ +@startuml +package com.iluwatar.featuretoggle.pattern { + interface Service { + + getWelcomeMessage(User) : String {abstract} + + isEnhanced() : boolean {abstract} + } +} +package com.iluwatar.featuretoggle.user { + class User { + - name : String + + User(name : String) + + toString() : String + } + class UserGroup { + - freeGroup : List {static} + - paidGroup : List {static} + + UserGroup() + + addUserToFreeGroup(user : User) {static} + + addUserToPaidGroup(user : User) {static} + + isPaid(user : User) : boolean {static} + } +} +package com.iluwatar.featuretoggle.pattern.tieredversion { + class TieredFeatureToggleVersion { + + TieredFeatureToggleVersion() + + getWelcomeMessage(user : User) : String + + isEnhanced() : boolean + } +} +package com.iluwatar.featuretoggle.pattern.propertiesversion { + class PropertiesFeatureToggleVersion { + - isEnhanced : boolean + + PropertiesFeatureToggleVersion(properties : Properties) + + getWelcomeMessage(user : User) : String + + isEnhanced() : boolean + } +} +package com.iluwatar.featuretoggle { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +UserGroup --> "-freeGroup" User +PropertiesFeatureToggleVersion ..|> Service +TieredFeatureToggleVersion ..|> Service +@enduml \ No newline at end of file diff --git a/fluentinterface/etc/fluentinterface.urm.puml b/fluentinterface/etc/fluentinterface.urm.puml new file mode 100644 index 000000000000..ef71a0f4bace --- /dev/null +++ b/fluentinterface/etc/fluentinterface.urm.puml @@ -0,0 +1,72 @@ +@startuml +package com.iluwatar.fluentinterface.fluentiterable.simple { + class SimpleFluentIterable { + - iterable : Iterable + # SimpleFluentIterable(iterable : Iterable) + + asList() : List + + filter(predicate : Predicate) : FluentIterable + + first() : Optional + + first(count : int) : FluentIterable + + forEach(action : Consumer) + + from(iterable : Iterable) : FluentIterable {static} + + fromCopyOf(iterable : Iterable) : FluentIterable {static} + + getRemainingElementsCount() : int + + iterator() : Iterator + + last() : Optional + + last(count : int) : FluentIterable + + map(function : Function) : FluentIterable + + spliterator() : Spliterator + + toList(iterator : Iterator) : List {static} + } +} +package com.iluwatar.fluentinterface.app { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + - negatives() : Predicate {static} + - positives() : Predicate {static} + - prettyPrint(delimiter : String, prefix : String, iterable : Iterable) {static} + - prettyPrint(prefix : String, iterable : Iterable) {static} + - transformToString() : Function {static} + } +} +package com.iluwatar.fluentinterface.fluentiterable.lazy { + abstract class DecoratingIterator { + # fromIterator : Iterator + - next : E + + DecoratingIterator(fromIterator : Iterator) + + computeNext() : E {abstract} + + hasNext() : boolean + + next() : E + } + class LazyFluentIterable { + - iterable : Iterable + # LazyFluentIterable() + # LazyFluentIterable(iterable : Iterable) + + asList() : List + + filter(predicate : Predicate) : FluentIterable + + first() : Optional + + first(count : int) : FluentIterable + + from(iterable : Iterable) : FluentIterable {static} + + iterator() : Iterator + + last() : Optional + + last(count : int) : FluentIterable + + map(function : Function) : FluentIterable + } +} +package com.iluwatar.fluentinterface.fluentiterable { + interface FluentIterable { + + asList() : List {abstract} + + copyToList(iterable : Iterable) : List {static} + + filter(Predicate) : FluentIterable {abstract} + + first() : Optional {abstract} + + first(int) : FluentIterable {abstract} + + last() : Optional {abstract} + + last(int) : FluentIterable {abstract} + + map(Function) : FluentIterable {abstract} + } +} +LazyFluentIterable ..|> FluentIterable +SimpleFluentIterable ..|> FluentIterable +@enduml \ No newline at end of file diff --git a/flux/etc/flux.urm.puml b/flux/etc/flux.urm.puml new file mode 100644 index 000000000000..300f179764cb --- /dev/null +++ b/flux/etc/flux.urm.puml @@ -0,0 +1,117 @@ +@startuml +package com.iluwatar.flux.view { + class ContentView { + - LOGGER : Logger {static} + - content : Content + + ContentView() + + render() + + storeChanged(store : Store) + } + class MenuView { + - LOGGER : Logger {static} + - selected : MenuItem + + MenuView() + + itemClicked(item : MenuItem) + + render() + + storeChanged(store : Store) + } + interface View { + + render() {abstract} + + storeChanged(Store) {abstract} + } +} +package com.iluwatar.flux.action { + abstract class Action { + - type : ActionType + + Action(type : ActionType) + + getType() : ActionType + } + enum ActionType { + + CONTENT_CHANGED {static} + + MENU_ITEM_SELECTED {static} + + valueOf(name : String) : ActionType {static} + + values() : ActionType[] {static} + } + enum Content { + + COMPANY {static} + + PRODUCTS {static} + - title : String + + toString() : String + + valueOf(name : String) : Content {static} + + values() : Content[] {static} + } + class ContentAction { + - content : Content + + ContentAction(content : Content) + + getContent() : Content + } + class MenuAction { + - menuItem : MenuItem + + MenuAction(menuItem : MenuItem) + + getMenuItem() : MenuItem + } + enum MenuItem { + + COMPANY {static} + + HOME {static} + + PRODUCTS {static} + - title : String + + toString() : String + + valueOf(name : String) : MenuItem {static} + + values() : MenuItem[] {static} + } +} +package com.iluwatar.flux.app { + class App { + + App() + + main(args : String[]) {static} + } +} +package com.iluwatar.flux.store { + class ContentStore { + - content : Content + + ContentStore() + + getContent() : Content + + onAction(action : Action) + } + class MenuStore { + - selected : MenuItem + + MenuStore() + + getSelected() : MenuItem + + onAction(action : Action) + } + abstract class Store { + - views : List + + Store() + # notifyChange() + + onAction(Action) {abstract} + + registerView(view : View) + } +} +package com.iluwatar.flux.dispatcher { + class Dispatcher { + - instance : Dispatcher {static} + - stores : List + - Dispatcher() + - dispatchAction(action : Action) + + getInstance() : Dispatcher {static} + + menuItemSelected(menuItem : MenuItem) + + registerStore(store : Store) + } +} +MenuAction --> "-menuItem" MenuItem +Action --> "-type" ActionType +MenuStore --> "-selected" MenuItem +Dispatcher --> "-instance" Dispatcher +ContentView --> "-content" Content +Dispatcher --> "-stores" Store +MenuView --> "-selected" MenuItem +Store --> "-views" View +ContentStore --> "-content" Content +ContentAction --> "-content" Content +ContentAction --|> Action +MenuAction --|> Action +ContentStore --|> Store +MenuStore --|> Store +ContentView ..|> View +MenuView ..|> View +@enduml \ No newline at end of file diff --git a/flyweight/etc/flyweight.urm.puml b/flyweight/etc/flyweight.urm.puml new file mode 100644 index 000000000000..61f2aa696eaf --- /dev/null +++ b/flyweight/etc/flyweight.urm.puml @@ -0,0 +1,65 @@ +@startuml +package com.iluwatar.flyweight { + class AlchemistShop { + - LOGGER : Logger {static} + - bottomShelf : List + - topShelf : List + + AlchemistShop() + + enumerate() + + getBottomShelf() : List + + getTopShelf() : List + } + class App { + + App() + + main(args : String[]) {static} + } + class HealingPotion { + - LOGGER : Logger {static} + + HealingPotion() + + drink() + } + class HolyWaterPotion { + - LOGGER : Logger {static} + + HolyWaterPotion() + + drink() + } + class InvisibilityPotion { + - LOGGER : Logger {static} + + InvisibilityPotion() + + drink() + } + class PoisonPotion { + - LOGGER : Logger {static} + + PoisonPotion() + + drink() + } + interface Potion { + + drink() {abstract} + } + class PotionFactory { + - potions : Map + + PotionFactory() + ~ createPotion(type : PotionType) : Potion + } + enum PotionType { + + HEALING {static} + + HOLY_WATER {static} + + INVISIBILITY {static} + + POISON {static} + + STRENGTH {static} + + valueOf(name : String) : PotionType {static} + + values() : PotionType[] {static} + } + class StrengthPotion { + - LOGGER : Logger {static} + + StrengthPotion() + + drink() + } +} +AlchemistShop --> "-topShelf" Potion +HealingPotion ..|> Potion +HolyWaterPotion ..|> Potion +InvisibilityPotion ..|> Potion +PoisonPotion ..|> Potion +StrengthPotion ..|> Potion +@enduml \ No newline at end of file diff --git a/front-controller/etc/front-controller.urm.puml b/front-controller/etc/front-controller.urm.puml new file mode 100644 index 000000000000..d2c21fc015a0 --- /dev/null +++ b/front-controller/etc/front-controller.urm.puml @@ -0,0 +1,53 @@ +@startuml +package com.iluwatar.front.controller { + class App { + + App() + + main(args : String[]) {static} + } + class ArcherCommand { + + ArcherCommand() + + process() + } + class ArcherView { + - LOGGER : Logger {static} + + ArcherView() + + display() + } + class CatapultCommand { + + CatapultCommand() + + process() + } + class CatapultView { + - LOGGER : Logger {static} + + CatapultView() + + display() + } + interface Command { + + process() {abstract} + } + class ErrorView { + - LOGGER : Logger {static} + + ErrorView() + + display() + } + class FrontController { + + FrontController() + - getCommand(request : String) : Command + - getCommandClass(request : String) : Class {static} + + handleRequest(request : String) + } + class UnknownCommand { + + UnknownCommand() + + process() + } + interface View { + + display() {abstract} + } +} +ArcherCommand ..|> Command +ArcherView ..|> View +CatapultCommand ..|> Command +CatapultView ..|> View +ErrorView ..|> View +UnknownCommand ..|> Command +@enduml \ No newline at end of file diff --git a/game-loop/etc/game-loop.urm.puml b/game-loop/etc/game-loop.urm.puml new file mode 100644 index 000000000000..d0704096f11e --- /dev/null +++ b/game-loop/etc/game-loop.urm.puml @@ -0,0 +1,63 @@ +@startuml +package com.iluwatar.gameloop { + class App { + - GAME_LOOP_DURATION_TIME : int {static} + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Bullet { + - position : float + + Bullet() + + getPosition() : float + + setPosition(position : float) + } + class FixedStepGameLoop { + - MS_PER_FRAME : long {static} + + FixedStepGameLoop() + # processGameLoop() + # update() + } + class FrameBasedGameLoop { + + FrameBasedGameLoop() + # processGameLoop() + # update() + } + class GameController { + # bullet : Bullet + + GameController() + + getBulletPosition() : float + + moveBullet(offset : float) + } + abstract class GameLoop { + # controller : GameController + - gameThread : Thread + # logger : Logger + # status : GameStatus + + GameLoop() + + isGameRunning() : boolean + # processGameLoop() {abstract} + # processInput() + # render() + + run() + + stop() + } + enum GameStatus { + + RUNNING {static} + + STOPPED {static} + + valueOf(name : String) : GameStatus {static} + + values() : GameStatus[] {static} + } + class VariableStepGameLoop { + + VariableStepGameLoop() + # processGameLoop() + # update(elapsedTime : Long) + } +} +GameLoop --> "-status" GameStatus +GameController --> "-bullet" Bullet +GameLoop --> "-controller" GameController +FixedStepGameLoop --|> GameLoop +FrameBasedGameLoop --|> GameLoop +VariableStepGameLoop --|> GameLoop +@enduml \ No newline at end of file diff --git a/guarded-suspension/etc/guarded-suspension.urm.puml b/guarded-suspension/etc/guarded-suspension.urm.puml new file mode 100644 index 000000000000..45a7d37904cb --- /dev/null +++ b/guarded-suspension/etc/guarded-suspension.urm.puml @@ -0,0 +1,15 @@ +@startuml +package com.iluwatar.guarded.suspension { + class App { + + App() + + main(args : String[]) {static} + } + class GuardedQueue { + - LOGGER : Logger {static} + - sourceList : Queue + + GuardedQueue() + + get() : Integer + + put(e : Integer) + } +} +@enduml \ No newline at end of file diff --git a/half-sync-half-async/etc/half-sync-half-async.urm.puml b/half-sync-half-async/etc/half-sync-half-async.urm.puml new file mode 100644 index 000000000000..64d8a5f8d87d --- /dev/null +++ b/half-sync-half-async/etc/half-sync-half-async.urm.puml @@ -0,0 +1,33 @@ +@startuml +package com.iluwatar.halfsynchalfasync { + class App { + - LOGGER : Logger {static} + + App() + - ap(i : long) : long {static} + + main(args : String[]) {static} + } + ~class ArithmeticSumTask { + - numberOfElements : long + + ArithmeticSumTask(numberOfElements : long) + + call() : Long + + onError(throwable : Throwable) + + onPostCall(result : Long) + + onPreCall() + } + interface AsyncTask { + + call() : O {abstract} + + onError(Throwable) {abstract} + + onPostCall(O) {abstract} + + onPreCall() {abstract} + } + class AsynchronousService { + - LOGGER : Logger {static} + - service : ExecutorService + + AsynchronousService(workQueue : BlockingQueue) + + close() + + execute(task : AsyncTask) + } +} +ArithmeticSumTask ..+ App +ArithmeticSumTask ..|> AsyncTask +@enduml \ No newline at end of file diff --git a/hexagonal/etc/hexagonal.urm.puml b/hexagonal/etc/hexagonal.urm.puml new file mode 100644 index 000000000000..10fcc7f6d71e --- /dev/null +++ b/hexagonal/etc/hexagonal.urm.puml @@ -0,0 +1,305 @@ +@startuml +package com.iluwatar.hexagonal.sampledata { + class SampleData { + - PLAYERS : List {static} + - RANDOM : Random {static} + + SampleData() + - getRandomPlayerDetails() : PlayerDetails {static} + + submitTickets(lotteryService : LotteryService, numTickets : int) {static} + } +} +package com.iluwatar.hexagonal.service { + class ConsoleLottery { + - LOGGER : Logger {static} + + ConsoleLottery() + + main(args : String[]) {static} + - printMainMenu() {static} + - readString(scanner : Scanner) : String {static} + } + interface LotteryConsoleService { + + addFundsToLotteryAccount(WireTransfers, Scanner) {abstract} + + checkTicket(LotteryService, Scanner) {abstract} + + queryLotteryAccountFunds(WireTransfers, Scanner) {abstract} + + submitTicket(LotteryService, Scanner) {abstract} + } + class LotteryConsoleServiceImpl { + - logger : Logger + + LotteryConsoleServiceImpl(logger : Logger) + + addFundsToLotteryAccount(bank : WireTransfers, scanner : Scanner) + + checkTicket(service : LotteryService, scanner : Scanner) + + queryLotteryAccountFunds(bank : WireTransfers, scanner : Scanner) + - readString(scanner : Scanner) : String + + submitTicket(service : LotteryService, scanner : Scanner) + } +} +package com.iluwatar.hexagonal.mongo { + class MongoConnectionPropertiesLoader { + - DEFAULT_HOST : String {static} + - DEFAULT_PORT : int {static} + + MongoConnectionPropertiesLoader() + + load() {static} + } +} +package com.iluwatar.hexagonal.domain { + class LotteryAdministration { + - notifications : LotteryEventLog + - repository : LotteryTicketRepository + - wireTransfers : WireTransfers + + LotteryAdministration(repository : LotteryTicketRepository, notifications : LotteryEventLog, wireTransfers : WireTransfers) + + getAllSubmittedTickets() : Map + + performLottery() : LotteryNumbers + + resetLottery() + } + class LotteryConstants { + + PLAYER_MAX_BALANCE : int {static} + + PRIZE_AMOUNT : int {static} + + SERVICE_BANK_ACCOUNT : String {static} + + SERVICE_BANK_ACCOUNT_BALANCE : int {static} + + TICKET_PRIZE : int {static} + - LotteryConstants() + } + class LotteryNumbers { + + MAX_NUMBER : int {static} + + MIN_NUMBER : int {static} + + NUM_NUMBERS : int {static} + - numbers : Set + - LotteryNumbers() + - LotteryNumbers(givenNumbers : Set) + + create(givenNumbers : Set) : LotteryNumbers {static} + + createRandom() : LotteryNumbers {static} + + equals(obj : Object) : boolean + - generateRandomNumbers() + + getNumbers() : Set + + getNumbersAsString() : String + + hashCode() : int + + toString() : String + } + -class RandomNumberGenerator { + - randomIterator : OfInt + + RandomNumberGenerator(min : int, max : int) + + nextInt() : int + } + class LotteryService { + - notifications : LotteryEventLog + - repository : LotteryTicketRepository + - wireTransfers : WireTransfers + + LotteryService(repository : LotteryTicketRepository, notifications : LotteryEventLog, wireTransfers : WireTransfers) + + checkTicketForPrize(id : LotteryTicketId, winningNumbers : LotteryNumbers) : LotteryTicketCheckResult + + submitTicket(ticket : LotteryTicket) : Optional + } + class LotteryTicket { + - id : LotteryTicketId + - lotteryNumbers : LotteryNumbers + - playerDetails : PlayerDetails + + LotteryTicket(id : LotteryTicketId, details : PlayerDetails, numbers : LotteryNumbers) + + equals(obj : Object) : boolean + + getId() : LotteryTicketId + + getNumbers() : LotteryNumbers + + getPlayerDetails() : PlayerDetails + + hashCode() : int + + setId(id : LotteryTicketId) + + toString() : String + } + class LotteryTicketCheckResult { + - checkResult : CheckResult + - prizeAmount : int + + LotteryTicketCheckResult(result : CheckResult) + + LotteryTicketCheckResult(result : CheckResult, amount : int) + + equals(obj : Object) : boolean + + getPrizeAmount() : int + + getResult() : CheckResult + + hashCode() : int + } + enum CheckResult { + + NO_PRIZE {static} + + TICKET_NOT_SUBMITTED {static} + + WIN_PRIZE {static} + + valueOf(name : String) : CheckResult {static} + + values() : CheckResult[] {static} + } + class LotteryTicketId { + - id : int + - numAllocated : AtomicInteger {static} + + LotteryTicketId() + + LotteryTicketId(id : int) + + equals(o : Object) : boolean + + getId() : int + + hashCode() : int + + toString() : String + } + class LotteryUtils { + - LotteryUtils() + + checkTicketForPrize(repository : LotteryTicketRepository, id : LotteryTicketId, winningNumbers : LotteryNumbers) : LotteryTicketCheckResult {static} + } + class PlayerDetails { + - bankAccountNumber : String + - emailAddress : String + - phoneNumber : String + + PlayerDetails(email : String, bankAccount : String, phone : String) + + equals(obj : Object) : boolean + + getBankAccount() : String + + getEmail() : String + + getPhoneNumber() : String + + hashCode() : int + + toString() : String + } +} +package com.iluwatar.hexagonal.banking { + class InMemoryBank { + - accounts : Map {static} + + InMemoryBank() + + getFunds(bankAccount : String) : int + + setFunds(bankAccount : String, amount : int) + + transferFunds(amount : int, sourceAccount : String, destinationAccount : String) : boolean + } + class MongoBank { + - DEFAULT_ACCOUNTS_COLLECTION : String {static} + - DEFAULT_DB : String {static} + - accountsCollection : MongoCollection + - database : MongoDatabase + - mongoClient : MongoClient + + MongoBank() + + MongoBank(dbName : String, accountsCollectionName : String) + + connect() + + connect(dbName : String, accountsCollectionName : String) + + getAccountsCollection() : MongoCollection + + getFunds(bankAccount : String) : int + + getMongoClient() : MongoClient + + getMongoDatabase() : MongoDatabase + + setFunds(bankAccount : String, amount : int) + + transferFunds(amount : int, sourceAccount : String, destinationAccount : String) : boolean + } + interface WireTransfers { + + getFunds(String) : int {abstract} + + setFunds(String, int) {abstract} + + transferFunds(int, String, String) : boolean {abstract} + } +} +package com.iluwatar.hexagonal.database { + class InMemoryTicketRepository { + - tickets : Map {static} + + InMemoryTicketRepository() + + deleteAll() + + findAll() : Map + + findById(id : LotteryTicketId) : Optional + + save(ticket : LotteryTicket) : Optional + } + interface LotteryTicketRepository { + + deleteAll() {abstract} + + findAll() : Map {abstract} + + findById(LotteryTicketId) : Optional {abstract} + + save(LotteryTicket) : Optional {abstract} + } + class MongoTicketRepository { + - DEFAULT_COUNTERS_COLLECTION : String {static} + - DEFAULT_DB : String {static} + - DEFAULT_TICKETS_COLLECTION : String {static} + - countersCollection : MongoCollection + - database : MongoDatabase + - mongoClient : MongoClient + - ticketsCollection : MongoCollection + + MongoTicketRepository() + + MongoTicketRepository(dbName : String, ticketsCollectionName : String, countersCollectionName : String) + + connect() + + connect(dbName : String, ticketsCollectionName : String, countersCollectionName : String) + + deleteAll() + - docToTicket(doc : Document) : LotteryTicket + + findAll() : Map + + findById(id : LotteryTicketId) : Optional + + getCountersCollection() : MongoCollection + + getNextId() : int + + getTicketsCollection() : MongoCollection + - initCounters() + + save(ticket : LotteryTicket) : Optional + } +} +package com.iluwatar.hexagonal { + class App { + + App() + + main(args : String[]) {static} + } +} +package com.iluwatar.hexagonal.administration { + class ConsoleAdministration { + - LOGGER : Logger {static} + + ConsoleAdministration() + + main(args : String[]) {static} + - printMainMenu() {static} + - readString(scanner : Scanner) : String {static} + } + interface ConsoleAdministrationSrv { + + getAllSubmittedTickets() {abstract} + + performLottery() {abstract} + + resetLottery() {abstract} + } + class ConsoleAdministrationSrvImpl { + - administration : LotteryAdministration + - logger : Logger + + ConsoleAdministrationSrvImpl(administration : LotteryAdministration, logger : Logger) + + getAllSubmittedTickets() + + performLottery() + + resetLottery() + } +} +package com.iluwatar.hexagonal.eventlog { + interface LotteryEventLog { + + prizeError(PlayerDetails, int) {abstract} + + ticketDidNotWin(PlayerDetails) {abstract} + + ticketSubmitError(PlayerDetails) {abstract} + + ticketSubmitted(PlayerDetails) {abstract} + + ticketWon(PlayerDetails, int) {abstract} + } + class MongoEventLog { + - DEFAULT_DB : String {static} + - DEFAULT_EVENTS_COLLECTION : String {static} + - database : MongoDatabase + - eventsCollection : MongoCollection + - mongoClient : MongoClient + - stdOutEventLog : StdOutEventLog + + MongoEventLog() + + MongoEventLog(dbName : String, eventsCollectionName : String) + + connect() + + connect(dbName : String, eventsCollectionName : String) + + getEventsCollection() : MongoCollection + + getMongoClient() : MongoClient + + getMongoDatabase() : MongoDatabase + + prizeError(details : PlayerDetails, prizeAmount : int) + + ticketDidNotWin(details : PlayerDetails) + + ticketSubmitError(details : PlayerDetails) + + ticketSubmitted(details : PlayerDetails) + + ticketWon(details : PlayerDetails, prizeAmount : int) + } + class StdOutEventLog { + - LOGGER : Logger {static} + + StdOutEventLog() + + prizeError(details : PlayerDetails, prizeAmount : int) + + ticketDidNotWin(details : PlayerDetails) + + ticketSubmitError(details : PlayerDetails) + + ticketSubmitted(details : PlayerDetails) + + ticketWon(details : PlayerDetails, prizeAmount : int) + } +} +LotteryTicket --> "-playerDetails" PlayerDetails +MongoEventLog --> "-stdOutEventLog" StdOutEventLog +LotteryService --> "-wireTransfers" WireTransfers +LotteryAdministration --> "-notifications" LotteryEventLog +LotteryAdministration --> "-wireTransfers" WireTransfers +LotteryTicket --> "-id" LotteryTicketId +LotteryAdministration --> "-repository" LotteryTicketRepository +LotteryService --> "-notifications" LotteryEventLog +LotteryTicket --> "-lotteryNumbers" LotteryNumbers +SampleData --> "-PLAYERS" PlayerDetails +ConsoleAdministrationSrvImpl --> "-administration" LotteryAdministration +RandomNumberGenerator ..+ LotteryNumbers +LotteryService --> "-repository" LotteryTicketRepository +CheckResult ..+ LotteryTicketCheckResult +LotteryTicketCheckResult --> "-checkResult" CheckResult +ConsoleAdministrationSrvImpl ..|> ConsoleAdministrationSrv +InMemoryBank ..|> WireTransfers +MongoBank ..|> WireTransfers +InMemoryTicketRepository ..|> LotteryTicketRepository +MongoTicketRepository ..|> LotteryTicketRepository +MongoEventLog ..|> LotteryEventLog +StdOutEventLog ..|> LotteryEventLog +LotteryConsoleServiceImpl ..|> LotteryConsoleService +@enduml \ No newline at end of file diff --git a/intercepting-filter/etc/intercepting-filter.urm.puml b/intercepting-filter/etc/intercepting-filter.urm.puml new file mode 100644 index 000000000000..6e565fd668c9 --- /dev/null +++ b/intercepting-filter/etc/intercepting-filter.urm.puml @@ -0,0 +1,88 @@ +@startuml +package com.iluwatar.intercepting.filter { + abstract class AbstractFilter { + - next : Filter + + AbstractFilter() + + AbstractFilter(next : Filter) + + execute(order : Order) : String + + getLast() : Filter + + getNext() : Filter + + setNext(filter : Filter) + } + class AddressFilter { + + AddressFilter() + + execute(order : Order) : String + } + class App { + + App() + + main(args : String[]) {static} + } + class ContactFilter { + + ContactFilter() + + execute(order : Order) : String + } + class DepositFilter { + + DepositFilter() + + execute(order : Order) : String + } + interface Filter { + + execute(Order) : String {abstract} + + getLast() : Filter {abstract} + + getNext() : Filter {abstract} + + setNext(Filter) {abstract} + } + class FilterChain { + - chain : Filter + + FilterChain() + + addFilter(filter : Filter) + + execute(order : Order) : String + } + class FilterManager { + - filterChain : FilterChain + + FilterManager() + + addFilter(filter : Filter) + + filterRequest(order : Order) : String + } + class NameFilter { + + NameFilter() + + execute(order : Order) : String + } + class Order { + - address : String + - contactNumber : String + - depositNumber : String + - name : String + - orderItem : String + + Order() + + Order(name : String, contactNumber : String, address : String, depositNumber : String, order : String) + + getAddress() : String + + getContactNumber() : String + + getDepositNumber() : String + + getName() : String + + getOrderItem() : String + + setAddress(address : String) + + setContactNumber(contactNumber : String) + + setDepositNumber(depositNumber : String) + + setName(name : String) + + setOrderItem(order : String) + } + class OrderFilter { + + OrderFilter() + + execute(order : Order) : String + } + ~class DListener { + ~ DListener() + + actionPerformed(e : ActionEvent) + } +} +AbstractFilter --> "-next" Filter +DListener --+ Target +FilterManager --> "-filterChain" FilterChain +FilterChain --> "-chain" Filter +AbstractFilter ..|> Filter +AddressFilter --|> AbstractFilter +ContactFilter --|> AbstractFilter +DepositFilter --|> AbstractFilter +NameFilter --|> AbstractFilter +OrderFilter --|> AbstractFilter +@enduml \ No newline at end of file diff --git a/interpreter/etc/interpreter.urm.puml b/interpreter/etc/interpreter.urm.puml new file mode 100644 index 000000000000..e79ad1989588 --- /dev/null +++ b/interpreter/etc/interpreter.urm.puml @@ -0,0 +1,51 @@ +@startuml +package com.iluwatar.interpreter { + class App { + - LOGGER : Logger {static} + + App() + + getOperatorInstance(s : String, left : Expression, right : Expression) : Expression {static} + + isOperator(s : String) : boolean {static} + + main(args : String[]) {static} + } + abstract class Expression { + + Expression() + + interpret() : int {abstract} + + toString() : String {abstract} + } + class MinusExpression { + - leftExpression : Expression + - rightExpression : Expression + + MinusExpression(leftExpression : Expression, rightExpression : Expression) + + interpret() : int + + toString() : String + } + class MultiplyExpression { + - leftExpression : Expression + - rightExpression : Expression + + MultiplyExpression(leftExpression : Expression, rightExpression : Expression) + + interpret() : int + + toString() : String + } + class NumberExpression { + - number : int + + NumberExpression(number : int) + + NumberExpression(s : String) + + interpret() : int + + toString() : String + } + class PlusExpression { + - leftExpression : Expression + - rightExpression : Expression + + PlusExpression(leftExpression : Expression, rightExpression : Expression) + + interpret() : int + + toString() : String + } +} +MultiplyExpression --> "-leftExpression" Expression +MinusExpression --> "-leftExpression" Expression +PlusExpression --> "-leftExpression" Expression +MinusExpression --|> Expression +MultiplyExpression --|> Expression +NumberExpression --|> Expression +PlusExpression --|> Expression +@enduml \ No newline at end of file diff --git a/iterator/etc/iterator.urm.puml b/iterator/etc/iterator.urm.puml new file mode 100644 index 000000000000..59cb93be26b6 --- /dev/null +++ b/iterator/etc/iterator.urm.puml @@ -0,0 +1,85 @@ +@startuml +package com.iluwatar.iterator { + class App { + - LOGGER : Logger {static} + - TREASURE_CHEST : TreasureChest {static} + + App() + - buildIntegerBst() : TreeNode {static} + - demonstrateBstIterator() {static} + - demonstrateTreasureChestIteratorForType(itemType : ItemType) {static} + + main(args : String[]) {static} + } + interface Iterator { + + hasNext() : boolean {abstract} + + next() : T {abstract} + } +} +package com.iluwatar.iterator.bst { + class BstIterator> { + - pathStack : ArrayDeque>> + + BstIterator>(root : TreeNode>) + + hasNext() : boolean + + next() : TreeNode> + - pushPathToNextSmallest(node : TreeNode>) + } + class TreeNode> { + - left : TreeNode> + - right : TreeNode> + - val : T extends Comparable + + TreeNode>(val : T extends Comparable) + + getLeft() : TreeNode> + - getParentNodeOfValueToBeInserted(valToInsert : T extends Comparable) : TreeNode> + + getRight() : TreeNode> + + getVal() : T extends Comparable + + insert(valToInsert : T extends Comparable) + - insertNewChild(valToInsert : T extends Comparable) + - isGreaterThan(val : T extends Comparable) : boolean + - isLessThanOrEqualTo(val : T extends Comparable) : boolean + - setLeft(left : TreeNode>) + - setRight(right : TreeNode>) + + toString() : String + - traverseOneLevelDown(value : T extends Comparable) : TreeNode> + } +} +package com.iluwatar.iterator.list { + class Item { + - name : String + - type : ItemType + + Item(type : ItemType, name : String) + + getType() : ItemType + + setType(type : ItemType) + + toString() : String + } + enum ItemType { + + ANY {static} + + POTION {static} + + RING {static} + + WEAPON {static} + + valueOf(name : String) : ItemType {static} + + values() : ItemType[] {static} + } + class TreasureChest { + - items : List + + TreasureChest() + + getItems() : List + + iterator(itemType : ItemType) : Iterator + } + class TreasureChestItemIterator { + - chest : TreasureChest + - idx : int + - type : ItemType + + TreasureChestItemIterator(chest : TreasureChest, type : ItemType) + - findNextIdx() : int + + hasNext() : boolean + + next() : Item + } +} +TreasureChestItemIterator --> "-type" ItemType +TreeNode --> "-left" TreeNode +TreasureChestItemIterator --> "-chest" TreasureChest +TreasureChest --> "-items" Item +Item --> "-type" ItemType +App --> "-TREASURE_CHEST" TreasureChest +BstIterator ..|> Iterator +TreasureChestItemIterator ..|> Iterator +@enduml \ No newline at end of file diff --git a/layers/etc/layers.urm.puml b/layers/etc/layers.urm.puml new file mode 100644 index 000000000000..f73b7964a0b4 --- /dev/null +++ b/layers/etc/layers.urm.puml @@ -0,0 +1,136 @@ +@startuml +package com.iluwatar.layers.dto { + class CakeInfo { + + cakeLayerInfos : List + + cakeToppingInfo : CakeToppingInfo + + id : Optional + + CakeInfo(cakeToppingInfo : CakeToppingInfo, cakeLayerInfos : List) + + CakeInfo(id : Long, cakeToppingInfo : CakeToppingInfo, cakeLayerInfos : List) + + calculateTotalCalories() : int + + toString() : String + } + class CakeLayerInfo { + + calories : int + + id : Optional + + name : String + + CakeLayerInfo(id : Long, name : String, calories : int) + + CakeLayerInfo(name : String, calories : int) + + toString() : String + } + class CakeToppingInfo { + + calories : int + + id : Optional + + name : String + + CakeToppingInfo(id : Long, name : String, calories : int) + + CakeToppingInfo(name : String, calories : int) + + toString() : String + } +} +package com.iluwatar.layers.entity { + class Cake { + - id : Long + - layers : Set + - topping : CakeTopping + + Cake() + + addLayer(layer : CakeLayer) + + getId() : Long + + getLayers() : Set + + getTopping() : CakeTopping + + setId(id : Long) + + setLayers(layers : Set) + + setTopping(topping : CakeTopping) + + toString() : String + } + class CakeLayer { + - cake : Cake + - calories : int + - id : Long + - name : String + + CakeLayer() + + CakeLayer(name : String, calories : int) + + getCake() : Cake + + getCalories() : int + + getId() : Long + + getName() : String + + setCake(cake : Cake) + + setCalories(calories : int) + + setId(id : Long) + + setName(name : String) + + toString() : String + } + class CakeTopping { + - cake : Cake + - calories : int + - id : Long + - name : String + + CakeTopping() + + CakeTopping(name : String, calories : int) + + getCake() : Cake + + getCalories() : int + + getId() : Long + + getName() : String + + setCake(cake : Cake) + + setCalories(calories : int) + + setId(id : Long) + + setName(name : String) + + toString() : String + } +} +package com.iluwatar.layers.view { + class CakeViewImpl { + - LOGGER : Logger {static} + - cakeBakingService : CakeBakingService + + CakeViewImpl(cakeBakingService : CakeBakingService) + + render() + } + interface View { + + render() {abstract} + } +} +package com.iluwatar.layers.app { + class App { + - cakeBakingService : CakeBakingService {static} + + App() + - initializeData(cakeBakingService : CakeBakingService) {static} + + main(args : String[]) {static} + } +} +package com.iluwatar.layers.dao { + interface CakeDao { + } + interface CakeLayerDao { + } + interface CakeToppingDao { + } +} +package com.iluwatar.layers.service { + interface CakeBakingService { + + bakeNewCake(CakeInfo) {abstract} + + getAllCakes() : List {abstract} + + getAvailableLayers() : List {abstract} + + getAvailableToppings() : List {abstract} + + saveNewLayer(CakeLayerInfo) {abstract} + + saveNewTopping(CakeToppingInfo) {abstract} + } + class CakeBakingServiceImpl { + - context : AbstractApplicationContext + + CakeBakingServiceImpl() + + bakeNewCake(cakeInfo : CakeInfo) + + getAllCakes() : List + - getAvailableLayerEntities() : List + + getAvailableLayers() : List + - getAvailableToppingEntities() : List + + getAvailableToppings() : List + + saveNewLayer(layerInfo : CakeLayerInfo) + + saveNewTopping(toppingInfo : CakeToppingInfo) + } +} +CakeInfo --> "-cakeLayerInfos" CakeLayerInfo +CakeInfo --> "-cakeToppingInfo" CakeToppingInfo +CakeViewImpl --> "-cakeBakingService" CakeBakingService +App --> "-cakeBakingService" CakeBakingService +Cake --> "-topping" CakeTopping +CakeLayer --> "-cake" Cake +CakeBakingServiceImpl ..|> CakeBakingService +CakeViewImpl ..|> View +@enduml \ No newline at end of file diff --git a/lazy-loading/etc/lazy-loading.urm.puml b/lazy-loading/etc/lazy-loading.urm.puml new file mode 100644 index 000000000000..aaf49f1df941 --- /dev/null +++ b/lazy-loading/etc/lazy-loading.urm.puml @@ -0,0 +1,40 @@ +@startuml +package com.iluwatar.lazy.loading { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Heavy { + - LOGGER : Logger {static} + + Heavy() + } + class HolderNaive { + - LOGGER : Logger {static} + - heavy : Heavy + + HolderNaive() + + getHeavy() : Heavy + } + class HolderThreadSafe { + - LOGGER : Logger {static} + - heavy : Heavy + + HolderThreadSafe() + + getHeavy() : Heavy + } + class Java8Holder { + - LOGGER : Logger {static} + - heavy : Supplier + + Java8Holder() + - createAndCacheHeavy() : Heavy + + getHeavy() : Heavy + } + ~class HeavyFactory { + - heavyInstance : Heavy + ~ HeavyFactory() + + get() : Heavy + } +} +HolderThreadSafe --> "-heavy" Heavy +HolderNaive --> "-heavy" Heavy +HeavyFactory --> "-heavyInstance" Heavy +@enduml \ No newline at end of file diff --git a/leader-election/etc/leader-election.urm.puml b/leader-election/etc/leader-election.urm.puml new file mode 100644 index 000000000000..c28066f31566 --- /dev/null +++ b/leader-election/etc/leader-election.urm.puml @@ -0,0 +1,120 @@ +@startuml +package com.iluwatar.leaderelection.ring { + class RingApp { + + RingApp() + + main(args : String[]) {static} + } + class RingInstance { + - LOGGER : Logger {static} + + RingInstance(messageManager : MessageManager, localId : int, leaderId : int) + # handleElectionInvokeMessage() + # handleElectionMessage(message : Message) + # handleHeartbeatInvokeMessage() + # handleHeartbeatMessage(message : Message) + # handleLeaderInvokeMessage() + # handleLeaderMessage(message : Message) + } + class RingMessageManager { + + RingMessageManager(instanceMap : Map) + + sendElectionMessage(currentId : int, content : String) : boolean + + sendHeartbeatInvokeMessage(currentId : int) + + sendHeartbeatMessage(leaderId : int) : boolean + + sendLeaderMessage(currentId : int, leaderId : int) : boolean + } +} +package com.iluwatar.leaderelection { + abstract class AbstractInstance { + # HEARTBEAT_INTERVAL : int {static} + - LOGGER : Logger {static} + # alive : boolean + # leaderId : int + # localId : int + # messageManager : MessageManager + # messageQueue : Queue + + AbstractInstance(messageManager : MessageManager, localId : int, leaderId : int) + # handleElectionInvokeMessage() {abstract} + # handleElectionMessage(Message) {abstract} + # handleHeartbeatInvokeMessage() {abstract} + # handleHeartbeatMessage(Message) {abstract} + # handleLeaderInvokeMessage() {abstract} + # handleLeaderMessage(Message) {abstract} + + isAlive() : boolean + + onMessage(message : Message) + - processMessage(message : Message) + + run() + + setAlive(alive : boolean) + } + abstract class AbstractMessageManager { + # instanceMap : Map + + AbstractMessageManager(instanceMap : Map) + # findNextInstance(currentId : int) : Instance + } + interface Instance { + + isAlive() : boolean {abstract} + + onMessage(Message) {abstract} + + setAlive(boolean) {abstract} + } + class Message { + - content : String + - type : MessageType + + Message() + + Message(type : MessageType, content : String) + + equals(o : Object) : boolean + + getContent() : String + + getType() : MessageType + + hashCode() : int + + setContent(content : String) + + setType(type : MessageType) + } + interface MessageManager { + + sendElectionMessage(int, String) : boolean {abstract} + + sendHeartbeatInvokeMessage(int) {abstract} + + sendHeartbeatMessage(int) : boolean {abstract} + + sendLeaderMessage(int, int) : boolean {abstract} + } + enum MessageType { + + ELECTION {static} + + ELECTION_INVOKE {static} + + HEARTBEAT {static} + + HEARTBEAT_INVOKE {static} + + LEADER {static} + + LEADER_INVOKE {static} + + valueOf(name : String) : MessageType {static} + + values() : MessageType[] {static} + } +} +package com.iluwatar.leaderelection.bully { + class BullyApp { + + BullyApp() + + main(args : String[]) {static} + } + class BullyInstance { + - LOGGER : Logger {static} + + BullyInstance(messageManager : MessageManager, localId : int, leaderId : int) + # handleElectionInvokeMessage() + # handleElectionMessage(message : Message) + # handleHeartbeatInvokeMessage() + # handleHeartbeatMessage(message : Message) + # handleLeaderInvokeMessage() + # handleLeaderMessage(message : Message) + - isLeader() : boolean + } + class BullyMessageManager { + + BullyMessageManager(instanceMap : Map) + - findElectionCandidateInstanceList(currentId : int) : List + + sendElectionMessage(currentId : int, content : String) : boolean + + sendHeartbeatInvokeMessage(currentId : int) + + sendHeartbeatMessage(leaderId : int) : boolean + + sendLeaderMessage(currentId : int, leaderId : int) : boolean + } +} +AbstractInstance --> "-messageQueue" Message +Message --> "-type" MessageType +AbstractInstance --> "-messageManager" MessageManager +AbstractInstance ..|> Instance +AbstractMessageManager ..|> MessageManager +BullyInstance --|> AbstractInstance +BullyMessageManager --|> AbstractMessageManager +RingInstance --|> AbstractInstance +RingMessageManager --|> AbstractMessageManager +@enduml \ No newline at end of file diff --git a/marker/etc/marker.urm.puml b/marker/etc/marker.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/marker/etc/marker.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/master-worker-pattern/etc/master-worker-pattern.urm.puml b/master-worker-pattern/etc/master-worker-pattern.urm.puml new file mode 100644 index 000000000000..b3b5add30671 --- /dev/null +++ b/master-worker-pattern/etc/master-worker-pattern.urm.puml @@ -0,0 +1,78 @@ +@startuml +package com.iluwatar.masterworker.system.systemmaster { + class ArrayTransposeMaster { + + ArrayTransposeMaster(numOfWorkers : int) + ~ aggregateData() : ArrayResult + ~ setWorkers(num : int) : ArrayList + } + abstract class Master { + - allResultData : Hashtable> + - expectedNumResults : int + - finalResult : Result + - numOfWorkers : int + - workers : ArrayList + ~ Master(numOfWorkers : int) + ~ aggregateData() : Result {abstract} + - collectResult(data : Result, workerId : int) + - divideWork(input : Input) + + doWork(input : Input) + ~ getAllResultData() : Hashtable> + ~ getExpectedNumResults() : int + + getFinalResult() : Result + ~ getWorkers() : ArrayList + + receiveData(data : Result, w : Worker) + ~ setWorkers(int) : ArrayList {abstract} + } +} +package com.iluwatar.masterworker.system { + class ArrayTransposeMasterWorker { + + ArrayTransposeMasterWorker() + ~ setMaster(numOfWorkers : int) : Master + } + abstract class MasterWorker { + - master : Master + + MasterWorker(numOfWorkers : int) + + getResult(input : Input) : Result + ~ setMaster(int) : Master {abstract} + } +} +package com.iluwatar.masterworker { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class ArrayInput { + + ArrayInput(data : int[][]) + + divideData(num : int) : ArrayList> + ~ makeDivisions(data : int[][], num : int) : int[] {static} + } + class ArrayResult { + + ArrayResult(data : int[][]) + } + class ArrayUtilityMethods { + - LOGGER : Logger {static} + - RANDOM : Random {static} + + ArrayUtilityMethods() + + arraysSame(a1 : int[], a2 : int[]) : boolean {static} + + createRandomIntMatrix(rows : int, columns : int) : int[][] {static} + + matricesSame(m1 : int[][], m2 : int[][]) : boolean {static} + + printMatrix(matrix : int[][]) {static} + } + abstract class Input { + + data : T + + Input(data : T) + + divideData(int) : ArrayList> {abstract} + } + abstract class Result { + + data : T + + Result(data : T) + } +} +Master --> "-finalResult" Result +MasterWorker --> "-master" Master +ArrayInput --|> Input +ArrayResult --|> Result +ArrayTransposeMasterWorker --|> MasterWorker +ArrayTransposeMaster --|> Master +@enduml \ No newline at end of file diff --git a/mediator/etc/mediator.urm.puml b/mediator/etc/mediator.urm.puml new file mode 100644 index 000000000000..04e75d2b8841 --- /dev/null +++ b/mediator/etc/mediator.urm.puml @@ -0,0 +1,69 @@ +@startuml +package com.iluwatar.mediator { + enum Action { + + ENEMY {static} + + GOLD {static} + + HUNT {static} + + NONE {static} + + TALE {static} + - description : String + - title : String + + getDescription() : String + + toString() : String + + valueOf(name : String) : Action {static} + + values() : Action[] {static} + } + class App { + + App() + + main(args : String[]) {static} + } + class Hobbit { + + Hobbit() + + toString() : String + } + class Hunter { + + Hunter() + + toString() : String + } + interface Party { + + act(PartyMember, Action) {abstract} + + addMember(PartyMember) {abstract} + } + class PartyImpl { + - members : List + + PartyImpl() + + act(actor : PartyMember, action : Action) + + addMember(member : PartyMember) + } + interface PartyMember { + + act(Action) {abstract} + + joinedParty(Party) {abstract} + + partyAction(Action) {abstract} + } + abstract class PartyMemberBase { + - LOGGER : Logger {static} + # party : Party + + PartyMemberBase() + + act(action : Action) + + joinedParty(party : Party) + + partyAction(action : Action) + + toString() : String {abstract} + } + class Rogue { + + Rogue() + + toString() : String + } + class Wizard { + + Wizard() + + toString() : String + } +} +PartyImpl --> "-members" PartyMember +PartyMemberBase --> "-party" Party +Hobbit --|> PartyMemberBase +Hunter --|> PartyMemberBase +PartyImpl ..|> Party +PartyMemberBase ..|> PartyMember +Rogue --|> PartyMemberBase +Wizard --|> PartyMemberBase +@enduml \ No newline at end of file diff --git a/memento/etc/memento.urm.puml b/memento/etc/memento.urm.puml new file mode 100644 index 000000000000..319227ad242c --- /dev/null +++ b/memento/etc/memento.urm.puml @@ -0,0 +1,49 @@ +@startuml +package com.iluwatar.memento { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Star { + - ageYears : int + - massTons : int + - type : StarType + + Star(startType : StarType, startAge : int, startMass : int) + ~ getMemento() : StarMemento + ~ setMemento(memento : StarMemento) + + timePasses() + + toString() : String + } + -class StarMementoInternal { + - ageYears : int + - massTons : int + - type : StarType + - StarMementoInternal() + + getAgeYears() : int + + getMassTons() : int + + getType() : StarType + + setAgeYears(ageYears : int) + + setMassTons(massTons : int) + + setType(type : StarType) + } + interface StarMemento { + } + enum StarType { + + DEAD {static} + + RED_GIANT {static} + + SUN {static} + + SUPERNOVA {static} + + UNDEFINED {static} + + WHITE_DWARF {static} + - title : String + + toString() : String + + valueOf(name : String) : StarType {static} + + values() : StarType[] {static} + } +} +StarMementoInternal --> "-type" StarType +Star --> "-type" StarType +StarMementoInternal ..+ Star +StarMementoInternal ..|> StarMemento +@enduml \ No newline at end of file diff --git a/model-view-controller/etc/model-view-controller.urm.puml b/model-view-controller/etc/model-view-controller.urm.puml new file mode 100644 index 000000000000..92ec1e949d83 --- /dev/null +++ b/model-view-controller/etc/model-view-controller.urm.puml @@ -0,0 +1,70 @@ +@startuml +package com.iluwatar.model.view.controller { + class App { + + App() + + main(args : String[]) {static} + } + enum Fatigue { + + ALERT {static} + + SLEEPING {static} + + TIRED {static} + - title : String + + toString() : String + + valueOf(name : String) : Fatigue {static} + + values() : Fatigue[] {static} + } + class GiantController { + - giant : GiantModel + - view : GiantView + + GiantController(giant : GiantModel, view : GiantView) + + getFatigue() : Fatigue + + getHealth() : Health + + getNourishment() : Nourishment + + setFatigue(fatigue : Fatigue) + + setHealth(health : Health) + + setNourishment(nourishment : Nourishment) + + updateView() + } + class GiantModel { + - fatigue : Fatigue + - health : Health + - nourishment : Nourishment + ~ GiantModel(health : Health, fatigue : Fatigue, nourishment : Nourishment) + + getFatigue() : Fatigue + + getHealth() : Health + + getNourishment() : Nourishment + + setFatigue(fatigue : Fatigue) + + setHealth(health : Health) + + setNourishment(nourishment : Nourishment) + + toString() : String + } + class GiantView { + - LOGGER : Logger {static} + + GiantView() + + displayGiant(giant : GiantModel) + } + enum Health { + + DEAD {static} + + HEALTHY {static} + + WOUNDED {static} + - title : String + + toString() : String + + valueOf(name : String) : Health {static} + + values() : Health[] {static} + } + enum Nourishment { + + HUNGRY {static} + + SATURATED {static} + + STARVING {static} + - title : String + + toString() : String + + valueOf(name : String) : Nourishment {static} + + values() : Nourishment[] {static} + } +} +GiantModel --> "-nourishment" Nourishment +GiantController --> "-giant" GiantModel +GiantModel --> "-fatigue" Fatigue +GiantModel --> "-health" Health +GiantController --> "-view" GiantView +@enduml \ No newline at end of file diff --git a/model-view-presenter/etc/model-view-presenter.urm.puml b/model-view-presenter/etc/model-view-presenter.urm.puml new file mode 100644 index 000000000000..bedb232cb5a7 --- /dev/null +++ b/model-view-presenter/etc/model-view-presenter.urm.puml @@ -0,0 +1,90 @@ +@startuml +package com.iluwatar.model.view.presenter { + class App { + + App() + + main(args : String[]) {static} + } + class FileLoader { + - LOGGER : Logger {static} + - fileName : String + - loaded : boolean + - serialVersionUID : long {static} + + FileLoader() + + fileExists() : boolean + + getFileName() : String + + isLoaded() : boolean + + loadData() : String + + setFileName(fileName : String) + } + class FileSelectorJFrame { + - area : JTextArea + - cancel : JButton + - contents : JLabel + - fileName : String + - info : JLabel + - input : JTextField + - ok : JButton + - panel : JPanel + - presenter : FileSelectorPresenter + - serialVersionUID : long {static} + + FileSelectorJFrame() + + actionPerformed(e : ActionEvent) + + close() + + displayData(data : String) + + getFileName() : String + + getPresenter() : FileSelectorPresenter + + isOpened() : boolean + + open() + + setFileName(name : String) + + setPresenter(presenter : FileSelectorPresenter) + + showMessage(message : String) + } + class FileSelectorPresenter { + - loader : FileLoader + - serialVersionUID : long {static} + - view : FileSelectorView + + FileSelectorPresenter(view : FileSelectorView) + + cancelled() + + confirmed() + + fileNameChanged() + + setLoader(loader : FileLoader) + + start() + } + class FileSelectorStub { + - dataDisplayed : boolean + - name : String + - numOfMessageSent : int + - opened : boolean + - presenter : FileSelectorPresenter + + FileSelectorStub() + + close() + + dataDisplayed() : boolean + + displayData(data : String) + + getFileName() : String + + getMessagesSent() : int + + getPresenter() : FileSelectorPresenter + + isOpened() : boolean + + open() + + setFileName(name : String) + + setPresenter(presenter : FileSelectorPresenter) + + showMessage(message : String) + } + interface FileSelectorView { + + close() {abstract} + + displayData(String) {abstract} + + getFileName() : String {abstract} + + getPresenter() : FileSelectorPresenter {abstract} + + isOpened() : boolean {abstract} + + open() {abstract} + + setFileName(String) {abstract} + + setPresenter(FileSelectorPresenter) {abstract} + + showMessage(String) {abstract} + } +} +FileSelectorJFrame --> "-presenter" FileSelectorPresenter +FileSelectorStub --> "-presenter" FileSelectorPresenter +FileSelectorPresenter --> "-view" FileSelectorView +FileSelectorPresenter --> "-loader" FileLoader +FileSelectorJFrame ..|> FileSelectorView +FileSelectorStub ..|> FileSelectorView +@enduml \ No newline at end of file diff --git a/module/etc/module.urm.puml b/module/etc/module.urm.puml new file mode 100644 index 000000000000..b92446ca14e7 --- /dev/null +++ b/module/etc/module.urm.puml @@ -0,0 +1,43 @@ +@startuml +package com.iluwatar.module { + class App { + + consoleLoggerModule : ConsoleLoggerModule {static} + + fileLoggerModule : FileLoggerModule {static} + + App() + + execute(args : String[]) {static} + + main(args : String[]) {static} + + prepare() {static} + + unprepare() {static} + } + class ConsoleLoggerModule { + - LOGGER : Logger {static} + + error : PrintStream + + output : PrintStream + - singleton : ConsoleLoggerModule {static} + - ConsoleLoggerModule() + + getSingleton() : ConsoleLoggerModule {static} + + prepare() : ConsoleLoggerModule + + printErrorString(value : String) + + printString(value : String) + + unprepare() + } + class FileLoggerModule { + - ERROR_FILE : String {static} + - LOGGER : Logger {static} + - OUTPUT_FILE : String {static} + + error : PrintStream + + output : PrintStream + - singleton : FileLoggerModule {static} + - FileLoggerModule() + + getSingleton() : FileLoggerModule {static} + + prepare() : FileLoggerModule + + printErrorString(value : String) + + printString(value : String) + + unprepare() + } +} +FileLoggerModule --> "-singleton" FileLoggerModule +App --> "-consoleLoggerModule" ConsoleLoggerModule +ConsoleLoggerModule --> "-singleton" ConsoleLoggerModule +App --> "-fileLoggerModule" FileLoggerModule +@enduml \ No newline at end of file diff --git a/monad/etc/monad.urm.puml b/monad/etc/monad.urm.puml new file mode 100644 index 000000000000..709ef269f66a --- /dev/null +++ b/monad/etc/monad.urm.puml @@ -0,0 +1,36 @@ +@startuml +package com.iluwatar.monad { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + enum Sex { + + FEMALE {static} + + MALE {static} + + valueOf(name : String) : Sex {static} + + values() : Sex[] {static} + } + class User { + - age : int + - email : String + - name : String + - sex : Sex + + User(name : String, age : int, sex : Sex, email : String) + + getAge() : int + + getEmail() : String + + getName() : String + + getSex() : Sex + } + class Validator { + - exceptions : List + - obj : T + - Validator(obj : T) + + get() : T + + of(t : T) : Validator {static} + + validate(projection : Function, validation : Predicate, message : String) : Validator + + validate(validation : Predicate, message : String) : Validator + } +} +User --> "-sex" Sex +@enduml \ No newline at end of file diff --git a/monostate/etc/monostate.urm.puml b/monostate/etc/monostate.urm.puml new file mode 100644 index 000000000000..c078fb7e712c --- /dev/null +++ b/monostate/etc/monostate.urm.puml @@ -0,0 +1,32 @@ +@startuml +package com.iluwatar.monostate { + class App { + + App() + + main(args : String[]) {static} + } + class LoadBalancer { + - SERVERS : List {static} + - lastServedId : int {static} + + LoadBalancer() + + addServer(server : Server) + + getLastServedId() : int + + getNoOfServers() : int + + serverRequest(request : Request) + } + class Request { + + value : String + + Request(value : String) + } + class Server { + - LOGGER : Logger {static} + + host : String + + id : int + + port : int + + Server(host : String, port : int, id : int) + + getHost() : String + + getPort() : int + + serve(request : Request) + } +} +LoadBalancer --> "-SERVERS" Server +@enduml \ No newline at end of file diff --git a/multiton/etc/multiton.urm.puml b/multiton/etc/multiton.urm.puml new file mode 100644 index 000000000000..5380d36c3146 --- /dev/null +++ b/multiton/etc/multiton.urm.puml @@ -0,0 +1,43 @@ +@startuml +package com.iluwatar.multiton { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Nazgul { + - name : NazgulName + - nazguls : Map {static} + - Nazgul(name : NazgulName) + + getInstance(name : NazgulName) : Nazgul {static} + + getName() : NazgulName + } + enum NazgulEnum { + + ADUNAPHEL {static} + + AKHORAHIL {static} + + DWAR {static} + + HOARMURATH {static} + + JI_INDUR {static} + + KHAMUL {static} + + MURAZOR {static} + + REN {static} + + UVATHA {static} + + valueOf(name : String) : NazgulEnum {static} + + values() : NazgulEnum[] {static} + } + enum NazgulName { + + ADUNAPHEL {static} + + AKHORAHIL {static} + + DWAR {static} + + HOARMURATH {static} + + JI_INDUR {static} + + KHAMUL {static} + + MURAZOR {static} + + REN {static} + + UVATHA {static} + + valueOf(name : String) : NazgulName {static} + + values() : NazgulName[] {static} + } +} +Nazgul --> "-name" NazgulName +@enduml \ No newline at end of file diff --git a/mute-idiom/etc/mute-idiom.urm.puml b/mute-idiom/etc/mute-idiom.urm.puml new file mode 100644 index 000000000000..32d036bc8144 --- /dev/null +++ b/mute-idiom/etc/mute-idiom.urm.puml @@ -0,0 +1,24 @@ +@startuml +package com.iluwatar.mute { + class App { + - LOGGER : Logger {static} + + App() + - acquireResource() : Resource {static} + - closeResource(resource : Resource) {static} + + main(args : String[]) {static} + - useOfLoggedMute() {static} + - useOfMute() {static} + - utilizeResource(resource : Resource) {static} + } + interface CheckedRunnable { + + run() {abstract} + } + class Mute { + - Mute() + + loggedMute(runnable : CheckedRunnable) {static} + + mute(runnable : CheckedRunnable) {static} + } + interface Resource { + } +} +@enduml \ No newline at end of file diff --git a/mutex/etc/mutex.urm.puml b/mutex/etc/mutex.urm.puml new file mode 100644 index 000000000000..08cf43b90795 --- /dev/null +++ b/mutex/etc/mutex.urm.puml @@ -0,0 +1,27 @@ +@startuml +package com.iluwatar.mutex { + class App { + + App() + + main(args : String[]) {static} + } + class Jar { + - beans : int + - lock : Lock + + Jar(beans : int, lock : Lock) + + takeBean() : boolean + } + interface Lock { + + acquire() {abstract} + + release() {abstract} + } + class Mutex { + - owner : Object + + Mutex() + + acquire() + + getOwner() : Object + + release() + } +} +Jar --> "-lock" Lock +Mutex ..|> Lock +@enduml \ No newline at end of file diff --git a/naked-objects/dom/etc/naked-objects-dom.urm.puml b/naked-objects/dom/etc/naked-objects-dom.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/naked-objects/dom/etc/naked-objects-dom.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/naked-objects/etc/naked-objects.urm.puml b/naked-objects/etc/naked-objects.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/naked-objects/etc/naked-objects.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/naked-objects/fixture/etc/naked-objects-fixture.urm.puml b/naked-objects/fixture/etc/naked-objects-fixture.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/naked-objects/fixture/etc/naked-objects-fixture.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/naked-objects/integtests/etc/naked-objects-integtests.urm.puml b/naked-objects/integtests/etc/naked-objects-integtests.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/naked-objects/integtests/etc/naked-objects-integtests.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/naked-objects/webapp/etc/naked-objects-webapp.urm.puml b/naked-objects/webapp/etc/naked-objects-webapp.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/naked-objects/webapp/etc/naked-objects-webapp.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/null-object/etc/null-object.urm.puml b/null-object/etc/null-object.urm.puml new file mode 100644 index 000000000000..a937a2b178e2 --- /dev/null +++ b/null-object/etc/null-object.urm.puml @@ -0,0 +1,41 @@ +@startuml +package com.iluwatar.nullobject { + class App { + + App() + + main(args : String[]) {static} + } + interface Node { + + getLeft() : Node {abstract} + + getName() : String {abstract} + + getRight() : Node {abstract} + + getTreeSize() : int {abstract} + + walk() {abstract} + } + class NodeImpl { + - LOGGER : Logger {static} + - left : Node + - name : String + - right : Node + + NodeImpl(name : String, left : Node, right : Node) + + getLeft() : Node + + getName() : String + + getRight() : Node + + getTreeSize() : int + + walk() + } + class NullNode { + - instance : NullNode {static} + - NullNode() + + getInstance() : NullNode {static} + + getLeft() : Node + + getName() : String + + getRight() : Node + + getTreeSize() : int + + walk() + } +} +NullNode --> "-instance" NullNode +NodeImpl --> "-left" Node +NodeImpl ..|> Node +NullNode ..|> Node +@enduml \ No newline at end of file diff --git a/object-mother/etc/object-mother.urm.puml b/object-mother/etc/object-mother.urm.puml new file mode 100644 index 000000000000..1bb52f2ed6c6 --- /dev/null +++ b/object-mother/etc/object-mother.urm.puml @@ -0,0 +1,45 @@ +@startuml +package com.iluwatar.objectmother { + class King { + ~ isDrunk : boolean + ~ isHappy : boolean + + King() + + flirt(queen : Queen) + + isHappy() : boolean + + makeDrunk() + + makeHappy() + + makeSober() + + makeUnhappy() + } + class Queen { + - isDrunk : boolean + - isFlirty : boolean + - isHappy : boolean + + Queen() + + getFlirted(king : King) : boolean + + isFlirty() : boolean + + makeDrunk() + + makeHappy() + + makeSober() + + makeUnhappy() + + setFlirtiness(flirtiness : boolean) + } + interface Royalty { + + makeDrunk() {abstract} + + makeHappy() {abstract} + + makeSober() {abstract} + + makeUnhappy() {abstract} + } + class RoyaltyObjectMother { + + RoyaltyObjectMother() + + createDrunkKing() : King {static} + + createFlirtyQueen() : Queen {static} + + createHappyDrunkKing() : King {static} + + createHappyKing() : King {static} + + createNotFlirtyQueen() : Queen {static} + + createSoberUnhappyKing() : King {static} + } +} +King ..|> Royalty +Queen ..|> Royalty +@enduml \ No newline at end of file diff --git a/object-pool/etc/object-pool.urm.puml b/object-pool/etc/object-pool.urm.puml new file mode 100644 index 000000000000..7f75ff248267 --- /dev/null +++ b/object-pool/etc/object-pool.urm.puml @@ -0,0 +1,30 @@ +@startuml +package com.iluwatar.object.pool { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + abstract class ObjectPool { + - available : Set + - inUse : Set + + ObjectPool() + + checkIn(instance : T) + + checkOut() : T + # create() : T {abstract} + + toString() : String + } + class Oliphaunt { + - counter : AtomicInteger {static} + - id : int + + Oliphaunt() + + getId() : int + + toString() : String + } + class OliphauntPool { + + OliphauntPool() + # create() : Oliphaunt + } +} +OliphauntPool --|> ObjectPool +@enduml \ No newline at end of file diff --git a/observer/etc/observer.urm.puml b/observer/etc/observer.urm.puml new file mode 100644 index 000000000000..bea9aab533d3 --- /dev/null +++ b/observer/etc/observer.urm.puml @@ -0,0 +1,80 @@ +@startuml +package com.iluwatar.observer { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Hobbits { + - LOGGER : Logger {static} + + Hobbits() + + update(currentWeather : WeatherType) + } + class Orcs { + - LOGGER : Logger {static} + + Orcs() + + update(currentWeather : WeatherType) + } + class Weather { + - LOGGER : Logger {static} + - currentWeather : WeatherType + - observers : List + + Weather() + + addObserver(obs : WeatherObserver) + - notifyObservers() + + removeObserver(obs : WeatherObserver) + + timePasses() + } + interface WeatherObserver { + + update(WeatherType) {abstract} + } + enum WeatherType { + + COLD {static} + + RAINY {static} + + SUNNY {static} + + WINDY {static} + + toString() : String + + valueOf(name : String) : WeatherType {static} + + values() : WeatherType[] {static} + } +} +package com.iluwatar.observer.generic { + class GHobbits { + - LOGGER : Logger {static} + + GHobbits() + + update(weather : GWeather, weatherType : WeatherType) + } + class GOrcs { + - LOGGER : Logger {static} + + GOrcs() + + update(weather : GWeather, weatherType : WeatherType) + } + class GWeather { + - LOGGER : Logger {static} + - currentWeather : WeatherType + + GWeather() + + timePasses() + } + abstract class Observable, A> { + # observers : List> + + Observable, A>() + + addObserver(observer : O extends Observer) + + notifyObservers(argument : A) + + removeObserver(observer : O extends Observer) + } + interface Observer, O extends Observer, A> { + + update(S extends Observable, A) {abstract} + } + interface Race { + } +} +Weather --> "-currentWeather" WeatherType +GWeather --> "-currentWeather" WeatherType +Weather --> "-observers" WeatherObserver +Hobbits ..|> WeatherObserver +Orcs ..|> WeatherObserver +GHobbits ..|> Race +GOrcs ..|> Race +GWeather --|> Observable +Race --|> Observer +@enduml \ No newline at end of file diff --git a/page-object/etc/page-object.urm.puml b/page-object/etc/page-object.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/page-object/etc/page-object.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/page-object/sample-application/etc/sample-application.urm.puml b/page-object/sample-application/etc/sample-application.urm.puml new file mode 100644 index 000000000000..306208a83610 --- /dev/null +++ b/page-object/sample-application/etc/sample-application.urm.puml @@ -0,0 +1,9 @@ +@startuml +package com.iluwatar.pageobject { + class App { + - LOGGER : Logger {static} + - App() + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/page-object/test-automation/etc/test-automation.urm.puml b/page-object/test-automation/etc/test-automation.urm.puml new file mode 100644 index 000000000000..7cfb56723a27 --- /dev/null +++ b/page-object/test-automation/etc/test-automation.urm.puml @@ -0,0 +1,51 @@ +@startuml +package com.iluwatar.pageobject { + class AlbumListPage { + - ALBUM_LIST_HTML_FILE : String {static} + - LOGGER : Logger {static} + - PAGE_URL : String {static} + - page : HtmlPage + + AlbumListPage(webClient : WebClient) + + isAt() : boolean + + navigateToPage() : AlbumListPage + + selectAlbum(albumTitle : String) : AlbumPage + } + class AlbumPage { + - ALBUM_PAGE_HTML_FILE : String {static} + - LOGGER : Logger {static} + - PAGE_URL : String {static} + - page : HtmlPage + + AlbumPage(webClient : WebClient) + + cancelChanges() : AlbumListPage + + changeAlbumRating(albumRating : String) : AlbumPage + + changeAlbumTitle(albumTitle : String) : AlbumPage + + changeAlbumYear(year : int) : AlbumPage + + changeArtist(artist : String) : AlbumPage + + changeNumberOfSongs(numberOfSongs : int) : AlbumPage + + isAt() : boolean + + navigateToPage() : AlbumPage + + saveChanges() : AlbumPage + } + class LoginPage { + - LOGGER : Logger {static} + - LOGIN_PAGE_HTML_FILE : String {static} + - PAGE_URL : String {static} + - page : HtmlPage + + LoginPage(webClient : WebClient) + + enterPassword(password : String) : LoginPage + + enterUsername(username : String) : LoginPage + + isAt() : boolean + + login() : AlbumListPage + + navigateToPage() : LoginPage + } + abstract class Page { + + AUT_PATH : String {static} + # webClient : WebClient + + Page(webClient : WebClient) + + isAt() : boolean {abstract} + } +} +AlbumListPage --|> Page +AlbumPage --|> Page +LoginPage --|> Page +@enduml \ No newline at end of file diff --git a/partial-response/etc/partial-response.urm.puml b/partial-response/etc/partial-response.urm.puml new file mode 100644 index 000000000000..4b041a8a0066 --- /dev/null +++ b/partial-response/etc/partial-response.urm.puml @@ -0,0 +1,31 @@ +@startuml +package com.iluwatar.partialresponse { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class FieldJsonMapper { + + FieldJsonMapper() + - getString(video : Video, declaredField : Field) : String + + toJson(video : Video, fields : String[]) : String + } + class Video { + - description : String + - director : String + - id : Integer + - language : String + - length : Integer + - title : String + + Video(id : Integer, title : String, len : Integer, desc : String, director : String, lang : String) + + toString() : String + } + class VideoResource { + - fieldJsonMapper : FieldJsonMapper + - videos : Map + + VideoResource(fieldJsonMapper : FieldJsonMapper, videos : Map) + + getDetails(id : Integer, fields : String[]) : String + } +} +VideoResource --> "-fieldJsonMapper" FieldJsonMapper +@enduml \ No newline at end of file diff --git a/pipeline/etc/pipeline.urm.puml b/pipeline/etc/pipeline.urm.puml new file mode 100644 index 000000000000..50bee48c567e --- /dev/null +++ b/pipeline/etc/pipeline.urm.puml @@ -0,0 +1,36 @@ +@startuml +package com.iluwatar.pipeline { + class App { + + App() + + main(args : String[]) {static} + } + ~class ConvertToCharArrayHandler { + - LOGGER : Logger {static} + ~ ConvertToCharArrayHandler() + + process(input : String) : char[] + } + ~interface Handler { + + process(I) : O {abstract} + } + ~class Pipeline { + - currentHandler : Handler + ~ Pipeline(currentHandler : Handler) + ~ addHandler(newHandler : Handler) : Pipeline + ~ execute(input : I) : O + } + ~class RemoveAlphabetsHandler { + - LOGGER : Logger {static} + ~ RemoveAlphabetsHandler() + + process(input : String) : String + } + ~class RemoveDigitsHandler { + - LOGGER : Logger {static} + ~ RemoveDigitsHandler() + + process(input : String) : String + } +} +Pipeline --> "-currentHandler" Handler +ConvertToCharArrayHandler ..|> Handler +RemoveAlphabetsHandler ..|> Handler +RemoveDigitsHandler ..|> Handler +@enduml \ No newline at end of file diff --git a/poison-pill/etc/poison-pill.urm.puml b/poison-pill/etc/poison-pill.urm.puml new file mode 100644 index 000000000000..923449e10b4a --- /dev/null +++ b/poison-pill/etc/poison-pill.urm.puml @@ -0,0 +1,71 @@ +@startuml +package com.iluwatar.poison.pill { + class App { + + App() + + main(args : String[]) {static} + } + class Consumer { + - LOGGER : Logger {static} + - name : String + - queue : MqSubscribePoint + + Consumer(name : String, queue : MqSubscribePoint) + + consume() + } + interface Message { + + POISON_PILL : Message {static} + + addHeader(Headers, String) {abstract} + + getBody() : String {abstract} + + getHeader(Headers) : String {abstract} + + getHeaders() : Map {abstract} + + setBody(String) {abstract} + } + enum Headers { + + DATE {static} + + SENDER {static} + + valueOf(name : String) : Headers {static} + + values() : Headers[] {static} + } + interface MessageQueue { + } + interface MqPublishPoint { + + put(Message) {abstract} + } + interface MqSubscribePoint { + + take() : Message {abstract} + } + class Producer { + - LOGGER : Logger {static} + - isStopped : boolean + - name : String + - queue : MqPublishPoint + + Producer(name : String, queue : MqPublishPoint) + + send(body : String) + + stop() + } + class SimpleMessage { + - body : String + - headers : Map + + SimpleMessage() + + addHeader(header : Headers, value : String) + + getBody() : String + + getHeader(header : Headers) : String + + getHeaders() : Map + + setBody(body : String) + } + class SimpleMessageQueue { + - queue : BlockingQueue + + SimpleMessageQueue(bound : int) + + put(msg : Message) + + take() : Message + } +} +SimpleMessageQueue --> "-queue" Message +Headers ..+ Message +Consumer --> "-queue" MqSubscribePoint +Producer --> "-queue" MqPublishPoint +Message --> "-POISON_PILL" Message +MessageQueue --|> MqPublishPoint +MessageQueue --|> MqSubscribePoint +SimpleMessage ..|> Message +SimpleMessageQueue ..|> MessageQueue +@enduml \ No newline at end of file diff --git a/pom.xml b/pom.xml index 63cef06f5a35..7c2789da5346 100644 --- a/pom.xml +++ b/pom.xml @@ -53,6 +53,7 @@ 2.3.2 1.3.2 1.19.0 + 1.4.8 abstract-factory @@ -498,6 +499,31 @@ + + + com.iluwatar.urm + urm-maven-plugin + 1.4.8 + + + ${project.basedir}/etc + + com.iluwatar + + true + false + plantuml + + + + process-classes + + map + + + + + diff --git a/priority-queue/etc/priority-queue.urm.puml b/priority-queue/etc/priority-queue.urm.puml new file mode 100644 index 000000000000..cee118f57671 --- /dev/null +++ b/priority-queue/etc/priority-queue.urm.puml @@ -0,0 +1,54 @@ +@startuml +package com.iluwatar.priority.queue { + class Application { + + Application() + + main(args : String[]) {static} + } + class Message { + - message : String + - priority : int + + Message(message : String, priority : int) + + compareTo(o : Message) : int + + toString() : String + } + class PriorityMessageQueue { + - LOGGER : Logger {static} + - capacity : int + - queue : T[] + - size : int + + PriorityMessageQueue(queue : T[]) + + add(t : T extends Comparable) + - ensureCapacity() + - hasLeftChild(index : int) : boolean + - hasParent(index : int) : boolean + - hasRightChild(index : int) : boolean + + isEmpty() : boolean + - left(parentIndex : int) : T extends Comparable + - leftChildIndex(parentPos : int) : int + - maxHeapifyDown() + - maxHeapifyUp() + - parent(childIndex : int) : T extends Comparable + - parentIndex(pos : int) : int + + print() + + remove() : T extends Comparable + - right(parentIndex : int) : T extends Comparable + - rightChildIndex(parentPos : int) : int + - swap(fpos : int, tpos : int) + } + class QueueManager { + - messagePriorityMessageQueue : PriorityMessageQueue + + QueueManager(initialCapacity : int) + + publishMessage(message : Message) + + receiveMessage() : Message + } + class Worker { + - LOGGER : Logger {static} + - queueManager : QueueManager + + Worker(queueManager : QueueManager) + - processMessage(message : Message) + + run() + } +} +QueueManager --> "-messagePriorityMessageQueue" PriorityMessageQueue +Worker --> "-queueManager" QueueManager +@enduml \ No newline at end of file diff --git a/private-class-data/etc/private-class-data.urm.puml b/private-class-data/etc/private-class-data.urm.puml new file mode 100644 index 000000000000..990b53342521 --- /dev/null +++ b/private-class-data/etc/private-class-data.urm.puml @@ -0,0 +1,36 @@ +@startuml +package com.iluwatar.privateclassdata { + class App { + + App() + + main(args : String[]) {static} + } + class ImmutableStew { + - LOGGER : Logger {static} + - data : StewData + + ImmutableStew(numPotatoes : int, numCarrots : int, numMeat : int, numPeppers : int) + + mix() + } + class Stew { + - LOGGER : Logger {static} + - numCarrots : int + - numMeat : int + - numPeppers : int + - numPotatoes : int + + Stew(numPotatoes : int, numCarrots : int, numMeat : int, numPeppers : int) + + mix() + + taste() + } + class StewData { + - numCarrots : int + - numMeat : int + - numPeppers : int + - numPotatoes : int + + StewData(numPotatoes : int, numCarrots : int, numMeat : int, numPeppers : int) + + getNumCarrots() : int + + getNumMeat() : int + + getNumPeppers() : int + + getNumPotatoes() : int + } +} +ImmutableStew --> "-data" StewData +@enduml \ No newline at end of file diff --git a/producer-consumer/etc/producer-consumer.urm.puml b/producer-consumer/etc/producer-consumer.urm.puml new file mode 100644 index 000000000000..e36374b2fdd2 --- /dev/null +++ b/producer-consumer/etc/producer-consumer.urm.puml @@ -0,0 +1,40 @@ +@startuml +package com.iluwatar.producer.consumer { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Consumer { + - LOGGER : Logger {static} + - name : String + - queue : ItemQueue + + Consumer(name : String, queue : ItemQueue) + + consume() + } + class Item { + - id : int + - producer : String + + Item(producer : String, id : int) + + getId() : int + + getProducer() : String + } + class ItemQueue { + - queue : BlockingQueue + + ItemQueue() + + put(item : Item) + + take() : Item + } + class Producer { + - RANDOM : Random {static} + - itemId : int + - name : String + - queue : ItemQueue + + Producer(name : String, queue : ItemQueue) + + produce() + } +} +Consumer --> "-queue" ItemQueue +Producer --> "-queue" ItemQueue +ItemQueue --> "-queue" Item +@enduml \ No newline at end of file diff --git a/promise/etc/promise.urm.puml b/promise/etc/promise.urm.puml new file mode 100644 index 000000000000..f3a28718e43b --- /dev/null +++ b/promise/etc/promise.urm.puml @@ -0,0 +1,79 @@ +@startuml +package com.iluwatar.promise { + class App { + - DEFAULT_URL : String {static} + - LOGGER : Logger {static} + - executor : ExecutorService + - stopLatch : CountDownLatch + - App() + - calculateLineCount() + - calculateLowestFrequencyChar() + - characterFrequency() : Promise> + - countLines() : Promise + - download(urlString : String) : Promise + - lowestFrequencyChar() : Promise + + main(args : String[]) {static} + - promiseUsage() + - stop() + - taskCompleted() + } + class Promise { + - exceptionHandler : Consumer + - fulfillmentAction : Runnable + + Promise() + + fulfill(value : T) + + fulfillExceptionally(exception : Exception) + + fulfillInAsync(task : Callable, executor : Executor) : Promise + - handleException(exception : Exception) + + onError(exceptionHandler : Consumer) : Promise + - postFulfillment() + + thenAccept(action : Consumer) : Promise + + thenApply(func : Function) : Promise + } + -class ConsumeAction { + - action : Consumer + - dest : Promise + - src : Promise + - ConsumeAction(src : Promise, dest : Promise, action : Consumer) + + run() + } + -class TransformAction { + - dest : Promise + - func : Function + - src : Promise + - TransformAction(src : Promise, dest : Promise, func : Function) + + run() + } + ~class PromiseSupport { + - COMPLETED : int {static} + - FAILED : int {static} + - LOGGER : Logger {static} + - RUNNING : int {static} + - exception : Exception + - lock : Object + - state : int + - value : T + ~ PromiseSupport() + + cancel(mayInterruptIfRunning : boolean) : boolean + ~ fulfill(value : T) + ~ fulfillExceptionally(exception : Exception) + + get() : T + + get(timeout : long, unit : TimeUnit) : T + + isCancelled() : boolean + + isDone() : boolean + } + class Utility { + - LOGGER : Logger {static} + + Utility() + + characterFrequency(fileLocation : String) : Map {static} + + countLines(fileLocation : String) : Integer {static} + + downloadFile(urlString : String) : String {static} + + lowestFrequencyChar(charFrequency : Map) : Character {static} + } +} +TransformAction --+ Promise +TransformAction --> "-src" Promise +ConsumeAction --+ Promise +ConsumeAction --> "-src" Promise +Promise --|> PromiseSupport +@enduml \ No newline at end of file diff --git a/property/etc/property.urm.puml b/property/etc/property.urm.puml new file mode 100644 index 000000000000..f281cd87319f --- /dev/null +++ b/property/etc/property.urm.puml @@ -0,0 +1,54 @@ +@startuml +package com.iluwatar.property { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Character { + - name : String + - properties : Map + - prototype : Prototype + - type : Type + + Character() + + Character(name : String, prototype : Character) + + Character(type : Type, prototype : Prototype) + + get(stat : Stats) : Integer + + has(stat : Stats) : boolean + + name() : String + + remove(stat : Stats) + + set(stat : Stats, val : Integer) + + toString() : String + + type() : Type + } + enum Type { + + MAGE {static} + + ROGUE {static} + + WARRIOR {static} + + valueOf(name : String) : Type {static} + + values() : Type[] {static} + } + interface Prototype { + + get(Stats) : Integer {abstract} + + has(Stats) : boolean {abstract} + + remove(Stats) {abstract} + + set(Stats, Integer) {abstract} + } + enum Stats { + + AGILITY {static} + + ARMOR {static} + + ATTACK_POWER {static} + + ENERGY {static} + + INTELLECT {static} + + RAGE {static} + + SPIRIT {static} + + STRENGTH {static} + + valueOf(name : String) : Stats {static} + + values() : Stats[] {static} + } +} +Character --> "-prototype" Prototype +Type ..+ Character +Character --> "-type" Type +Character ..|> Prototype +@enduml \ No newline at end of file diff --git a/prototype/etc/prototype.urm.puml b/prototype/etc/prototype.urm.puml new file mode 100644 index 000000000000..bd1576f3bfe2 --- /dev/null +++ b/prototype/etc/prototype.urm.puml @@ -0,0 +1,105 @@ +@startuml +package com.iluwatar.prototype { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + abstract class Beast { + + Beast() + + Beast(source : Beast) + + copy() : Beast {abstract} + + equals(obj : Object) : boolean + } + class ElfBeast { + - helpType : String + + ElfBeast(elfBeast : ElfBeast) + + ElfBeast(helpType : String) + + copy() : ElfBeast + + equals(obj : Object) : boolean + + toString() : String + } + class ElfMage { + - helpType : String + + ElfMage(elfMage : ElfMage) + + ElfMage(helpType : String) + + copy() : ElfMage + + equals(obj : Object) : boolean + + toString() : String + } + class ElfWarlord { + - helpType : String + + ElfWarlord(elfWarlord : ElfWarlord) + + ElfWarlord(helpType : String) + + copy() : ElfWarlord + + equals(obj : Object) : boolean + + toString() : String + } + interface HeroFactory { + + createBeast() : Beast {abstract} + + createMage() : Mage {abstract} + + createWarlord() : Warlord {abstract} + } + class HeroFactoryImpl { + - beast : Beast + - mage : Mage + - warlord : Warlord + + HeroFactoryImpl(mage : Mage, warlord : Warlord, beast : Beast) + + createBeast() : Beast + + createMage() : Mage + + createWarlord() : Warlord + } + abstract class Mage { + + Mage() + + Mage(source : Mage) + + copy() : Mage {abstract} + + equals(obj : Object) : boolean + } + class OrcBeast { + - weapon : String + + OrcBeast(orcBeast : OrcBeast) + + OrcBeast(weapon : String) + + copy() : OrcBeast + + equals(obj : Object) : boolean + + toString() : String + } + class OrcMage { + - weapon : String + + OrcMage(orcMage : OrcMage) + + OrcMage(weapon : String) + + copy() : OrcMage + + equals(obj : Object) : boolean + + toString() : String + } + class OrcWarlord { + - weapon : String + + OrcWarlord(orcWarlord : OrcWarlord) + + OrcWarlord(weapon : String) + + copy() : OrcWarlord + + equals(obj : Object) : boolean + + toString() : String + } + interface Prototype { + + copy() : Object {abstract} + } + abstract class Warlord { + + Warlord() + + Warlord(source : Warlord) + + copy() : Warlord {abstract} + + equals(obj : Object) : boolean + } +} +HeroFactoryImpl --> "-beast" Beast +HeroFactoryImpl --> "-warlord" Warlord +HeroFactoryImpl --> "-mage" Mage +Beast ..|> Prototype +ElfBeast --|> Beast +ElfMage --|> Mage +ElfWarlord --|> Warlord +HeroFactoryImpl ..|> HeroFactory +Mage ..|> Prototype +OrcBeast --|> Beast +OrcMage --|> Mage +OrcWarlord --|> Warlord +Warlord ..|> Prototype +@enduml \ No newline at end of file diff --git a/proxy/etc/proxy.urm.puml b/proxy/etc/proxy.urm.puml new file mode 100644 index 000000000000..ffe0fa446074 --- /dev/null +++ b/proxy/etc/proxy.urm.puml @@ -0,0 +1,32 @@ +@startuml +package com.iluwatar.proxy { + class App { + + App() + + main(args : String[]) {static} + } + class IvoryTower { + - LOGGER : Logger {static} + + IvoryTower() + + enter(wizard : Wizard) + } + class Wizard { + - name : String + + Wizard(name : String) + + toString() : String + } + interface WizardTower { + + enter(Wizard) {abstract} + } + class WizardTowerProxy { + - LOGGER : Logger {static} + - NUM_WIZARDS_ALLOWED : int {static} + - numWizards : int + - tower : WizardTower + + WizardTowerProxy(tower : WizardTower) + + enter(wizard : Wizard) + } +} +WizardTowerProxy --> "-tower" WizardTower +IvoryTower ..|> WizardTower +WizardTowerProxy ..|> WizardTower +@enduml \ No newline at end of file diff --git a/queue-load-leveling/etc/queue-load-leveling.urm.puml b/queue-load-leveling/etc/queue-load-leveling.urm.puml new file mode 100644 index 000000000000..ca90842d92dd --- /dev/null +++ b/queue-load-leveling/etc/queue-load-leveling.urm.puml @@ -0,0 +1,44 @@ +@startuml +package com.iluwatar.queue.load.leveling { + class App { + - LOGGER : Logger {static} + - SHUTDOWN_TIME : int {static} + + App() + + main(args : String[]) {static} + } + class Message { + - msg : String + + Message(msg : String) + + getMsg() : String + + toString() : String + } + class MessageQueue { + - LOGGER : Logger {static} + - blkQueue : BlockingQueue + + MessageQueue() + + retrieveMsg() : Message + + submitMsg(msg : Message) + } + class ServiceExecutor { + - LOGGER : Logger {static} + - msgQueue : MessageQueue + + ServiceExecutor(msgQueue : MessageQueue) + + run() + } + interface Task { + + submit(Message) {abstract} + } + class TaskGenerator { + - LOGGER : Logger {static} + - msgCount : int + - msgQueue : MessageQueue + + TaskGenerator(msgQueue : MessageQueue, msgCount : int) + + run() + + submit(msg : Message) + } +} +MessageQueue --> "-blkQueue" Message +ServiceExecutor --> "-msgQueue" MessageQueue +TaskGenerator --> "-msgQueue" MessageQueue +TaskGenerator ..|> Task +@enduml \ No newline at end of file diff --git a/reactor/etc/reactor.urm.puml b/reactor/etc/reactor.urm.puml new file mode 100644 index 000000000000..cc56eae7a1c8 --- /dev/null +++ b/reactor/etc/reactor.urm.puml @@ -0,0 +1,155 @@ +@startuml +package com.iluwatar.reactor.framework { + abstract class AbstractNioChannel { + - channel : SelectableChannel + - channelToPendingWrites : Map> + - handler : ChannelHandler + - reactor : NioReactor + + AbstractNioChannel(handler : ChannelHandler, channel : SelectableChannel) + + bind() {abstract} + # doWrite(Object, SelectionKey) {abstract} + ~ flush(key : SelectionKey) + + getHandler() : ChannelHandler + + getInterestedOps() : int {abstract} + + getJavaChannel() : SelectableChannel + + read(SelectionKey) : Object {abstract} + ~ setReactor(reactor : NioReactor) + + write(data : Object, key : SelectionKey) + } + interface ChannelHandler { + + handleChannelRead(AbstractNioChannel, Object, SelectionKey) {abstract} + } + interface Dispatcher { + + onChannelReadEvent(AbstractNioChannel, Object, SelectionKey) {abstract} + + stop() {abstract} + } + class NioDatagramChannel { + - LOGGER : Logger {static} + - port : int + + NioDatagramChannel(port : int, handler : ChannelHandler) + + bind() + # doWrite(pendingWrite : Object, key : SelectionKey) + + getInterestedOps() : int + + getJavaChannel() : DatagramChannel + + read(key : SelectionKey) : DatagramPacket + + write(data : Object, key : SelectionKey) + } + class DatagramPacket { + - data : ByteBuffer + - receiver : SocketAddress + - sender : SocketAddress + + DatagramPacket(data : ByteBuffer) + + getData() : ByteBuffer + + getReceiver() : SocketAddress + + getSender() : SocketAddress + + setReceiver(receiver : SocketAddress) + + setSender(sender : SocketAddress) + } + class NioReactor { + - LOGGER : Logger {static} + - dispatcher : Dispatcher + - pendingCommands : Queue + - reactorMain : ExecutorService + - selector : Selector + + NioReactor(dispatcher : Dispatcher) + + changeOps(key : SelectionKey, interestedOps : int) + - dispatchReadEvent(key : SelectionKey, readObject : Object) + - eventLoop() + - onChannelAcceptable(key : SelectionKey) + - onChannelReadable(key : SelectionKey) + - onChannelWritable(key : SelectionKey) {static} + - processKey(key : SelectionKey) + - processPendingCommands() + + registerChannel(channel : AbstractNioChannel) : NioReactor + + start() + + stop() + } + ~class ChangeKeyOpsCommand { + - interestedOps : int + - key : SelectionKey + + ChangeKeyOpsCommand(this$0 : SelectionKey, key : int) + + run() + + toString() : String + } + class NioServerSocketChannel { + - LOGGER : Logger {static} + - port : int + + NioServerSocketChannel(port : int, handler : ChannelHandler) + + bind() + # doWrite(pendingWrite : Object, key : SelectionKey) + + getInterestedOps() : int + + getJavaChannel() : ServerSocketChannel + + read(key : SelectionKey) : ByteBuffer + } + class SameThreadDispatcher { + + SameThreadDispatcher() + + onChannelReadEvent(channel : AbstractNioChannel, readObject : Object, key : SelectionKey) + + stop() + } + class ThreadPoolDispatcher { + - executorService : ExecutorService + + ThreadPoolDispatcher(poolSize : int) + + onChannelReadEvent(channel : AbstractNioChannel, readObject : Object, key : SelectionKey) + + stop() + } +} +package com.iluwatar.reactor.app { + class App { + - channels : List + - dispatcher : Dispatcher + - reactor : NioReactor + + App(dispatcher : Dispatcher) + + main(args : String[]) {static} + + start() + + stop() + - tcpChannel(port : int, handler : ChannelHandler) : AbstractNioChannel + - udpChannel(port : int, handler : ChannelHandler) : AbstractNioChannel + } + class AppClient { + - LOGGER : Logger {static} + - service : ExecutorService + + AppClient() + - artificialDelayOf(millis : long) {static} + + main(args : String[]) {static} + + start() + + stop() + } + ~class TcpLoggingClient { + - clientName : String + - serverPort : int + + TcpLoggingClient(clientName : String, serverPort : int) + + run() + - sendLogRequests(writer : PrintWriter, inputStream : InputStream) + } + ~class UdpLoggingClient { + - clientName : String + - remoteAddress : InetSocketAddress + + UdpLoggingClient(clientName : String, port : int) + + run() + } + class LoggingHandler { + - ACK : byte[] {static} + - LOGGER : Logger {static} + + LoggingHandler() + - doLogging(data : ByteBuffer) {static} + + handleChannelRead(channel : AbstractNioChannel, readObject : Object, key : SelectionKey) + - sendReply(channel : AbstractNioChannel, incomingPacket : DatagramPacket, key : SelectionKey) {static} + - sendReply(channel : AbstractNioChannel, key : SelectionKey) {static} + } +} +AbstractNioChannel --> "-handler" ChannelHandler +UdpLoggingClient ..+ AppClient +TcpLoggingClient ..+ AppClient +AbstractNioChannel --> "-reactor" NioReactor +NioReactor --> "-dispatcher" Dispatcher +App --> "-reactor" NioReactor +App --> "-channels" AbstractNioChannel +DatagramPacket ..+ NioDatagramChannel +App --> "-dispatcher" Dispatcher +ChangeKeyOpsCommand --+ NioReactor +LoggingHandler ..|> ChannelHandler +NioDatagramChannel --|> AbstractNioChannel +NioServerSocketChannel --|> AbstractNioChannel +SameThreadDispatcher ..|> Dispatcher +ThreadPoolDispatcher ..|> Dispatcher +@enduml \ No newline at end of file diff --git a/reader-writer-lock/etc/reader-writer-lock.urm.puml b/reader-writer-lock/etc/reader-writer-lock.urm.puml new file mode 100644 index 000000000000..f0e33ab3cb40 --- /dev/null +++ b/reader-writer-lock/etc/reader-writer-lock.urm.puml @@ -0,0 +1,65 @@ +@startuml +package com.iluwatar.reader.writer.lock { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Reader { + - LOGGER : Logger {static} + - name : String + - readLock : Lock + - readingTime : long + + Reader(name : String, readLock : Lock) + + Reader(name : String, readLock : Lock, readingTime : long) + + read() + + run() + } + class ReaderWriterLock { + - LOGGER : Logger {static} + - currentReaderCount : int + - globalMutex : Set + - readerLock : ReadLock + - readerMutex : Object + - writerLock : WriteLock + + ReaderWriterLock() + - doesWriterOwnThisLock() : boolean + - isLockFree() : boolean + + readLock() : Lock + + writeLock() : Lock + } + -class ReadLock { + - ReadLock() + - acquireForReaders() + + lock() + + lockInterruptibly() + + newCondition() : Condition + + tryLock() : boolean + + tryLock(time : long, unit : TimeUnit) : boolean + + unlock() + } + -class WriteLock { + - WriteLock() + + lock() + + lockInterruptibly() + + newCondition() : Condition + + tryLock() : boolean + + tryLock(time : long, unit : TimeUnit) : boolean + + unlock() + } + class Writer { + - LOGGER : Logger {static} + - name : String + - writeLock : Lock + - writingTime : long + + Writer(name : String, writeLock : Lock) + + Writer(name : String, writeLock : Lock, writingTime : long) + + run() + + write() + } +} +ReaderWriterLock --> "-readerLock" ReadLock +ReadLock --+ ReaderWriterLock +WriteLock --+ ReaderWriterLock +ReaderWriterLock --> "-writerLock" WriteLock +@enduml \ No newline at end of file diff --git a/repository/etc/repository.urm.puml b/repository/etc/repository.urm.puml new file mode 100644 index 000000000000..10768260cefc --- /dev/null +++ b/repository/etc/repository.urm.puml @@ -0,0 +1,56 @@ +@startuml +package com.iluwatar.repository { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class AppConfig { + - LOGGER : Logger {static} + + AppConfig() + + dataSource() : DataSource + + entityManagerFactory() : LocalContainerEntityManagerFactoryBean + - jpaProperties() : Properties {static} + + main(args : String[]) {static} + + transactionManager() : JpaTransactionManager + } + class Person { + - age : int + - id : Long + - name : String + - surname : String + + Person() + + Person(name : String, surname : String, age : int) + + equals(obj : Object) : boolean + + getAge() : int + + getId() : Long + + getName() : String + + getSurname() : String + + hashCode() : int + + setAge(age : int) + + setId(id : Long) + + setName(name : String) + + setSurname(surname : String) + + toString() : String + } + interface PersonRepository { + + findByName(String) : Person {abstract} + } + class PersonSpecifications { + + PersonSpecifications() + } + class AgeBetweenSpec { + - from : int + - to : int + + AgeBetweenSpec(from : int, to : int) + + toPredicate(root : Root, query : CriteriaQuery, cb : CriteriaBuilder) : Predicate + } + class NameEqualSpec { + + name : String + + NameEqualSpec(name : String) + + toPredicate(root : Root, query : CriteriaQuery, cb : CriteriaBuilder) : Predicate + } +} +NameEqualSpec ..+ PersonSpecifications +AgeBetweenSpec ..+ PersonSpecifications +@enduml \ No newline at end of file diff --git a/resource-acquisition-is-initialization/etc/resource-acquisition-is-initialization.urm.puml b/resource-acquisition-is-initialization/etc/resource-acquisition-is-initialization.urm.puml new file mode 100644 index 000000000000..11309f0a6230 --- /dev/null +++ b/resource-acquisition-is-initialization/etc/resource-acquisition-is-initialization.urm.puml @@ -0,0 +1,19 @@ +@startuml +package com.iluwatar.resource.acquisition.is.initialization { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class SlidingDoor { + - LOGGER : Logger {static} + + SlidingDoor() + + close() + } + class TreasureChest { + - LOGGER : Logger {static} + + TreasureChest() + + close() + } +} +@enduml \ No newline at end of file diff --git a/retry/etc/retry.urm.puml b/retry/etc/retry.urm.puml new file mode 100644 index 000000000000..ab2f7cf3a65f --- /dev/null +++ b/retry/etc/retry.urm.puml @@ -0,0 +1,54 @@ +@startuml +package com.iluwatar.retry { + class App { + - LOG : Logger {static} + - op : BusinessOperation {static} + + App() + - errorNoRetry() {static} + - errorWithRetry() {static} + - errorWithRetryExponentialBackoff() {static} + + main(args : String[]) {static} + - noErrors() {static} + } + interface BusinessOperation { + + perform() : T {abstract} + } + class FindCustomer { + - customerId : String + - errors : Deque + + FindCustomer(customerId : String, errors : BusinessException[]) + + perform() : String + } + class Retry { + - attempts : AtomicInteger + - delay : long + - errors : List + - maxAttempts : int + - op : BusinessOperation + - test : Predicate + + Retry(op : BusinessOperation, maxAttempts : int, delay : long, ignoreTests : Predicate[]) + + attempts() : int + + errors() : List + + perform() : T + } + class RetryExponentialBackoff { + - RANDOM : Random {static} + - attempts : AtomicInteger + - errors : List + - maxAttempts : int + - maxDelay : long + - op : BusinessOperation + - test : Predicate + + RetryExponentialBackoff(op : BusinessOperation, maxAttempts : int, maxDelay : long, ignoreTests : Predicate[]) + + attempts() : int + + errors() : List + + perform() : T + } +} +RetryExponentialBackoff --> "-op" BusinessOperation +Retry --> "-op" BusinessOperation +App --> "-op" BusinessOperation +FindCustomer ..|> BusinessOperation +Retry ..|> BusinessOperation +RetryExponentialBackoff ..|> BusinessOperation +@enduml \ No newline at end of file diff --git a/role-object/etc/role-object.urm.puml b/role-object/etc/role-object.urm.puml new file mode 100644 index 000000000000..241a146f0b9f --- /dev/null +++ b/role-object/etc/role-object.urm.puml @@ -0,0 +1,60 @@ +@startuml +package com.iluwatar.roleobject { + class ApplicationRoleObject { + - logger : Logger {static} + + ApplicationRoleObject() + + main(args : String[]) {static} + } + class BorrowerRole { + - name : String + + BorrowerRole() + + borrow() : String + + getName() : String + + setName(name : String) + } + abstract class Customer { + + Customer() + + addRole(Role) : boolean {abstract} + + getRole(Role, Class) : Optional {abstract} + + hasRole(Role) : boolean {abstract} + + newCustomer() : Customer {static} + + newCustomer(role : Role[]) : Customer {static} + + remRole(Role) : boolean {abstract} + } + class CustomerCore { + - roles : Map + + CustomerCore() + + addRole(role : Role) : boolean + + getRole(role : Role, expectedRole : Class) : Optional + + hasRole(role : Role) : boolean + + remRole(role : Role) : boolean + + toString() : String + } + abstract class CustomerRole { + + CustomerRole() + } + class InvestorRole { + - amountToInvest : long + - name : String + + InvestorRole() + + getAmountToInvest() : long + + getName() : String + + invest() : String + + setAmountToInvest(amountToInvest : long) + + setName(name : String) + } + enum Role { + + Borrower {static} + + Investor {static} + - logger : Logger {static} + - typeCst : Class + + instance() : Optional + + valueOf(name : String) : Role {static} + + values() : Role[] {static} + } +} +BorrowerRole --|> CustomerRole +CustomerCore --|> Customer +CustomerRole --|> CustomerCore +InvestorRole --|> CustomerRole +@enduml \ No newline at end of file diff --git a/saga/etc/saga.urm.puml b/saga/etc/saga.urm.puml new file mode 100644 index 000000000000..e44b5366b021 --- /dev/null +++ b/saga/etc/saga.urm.puml @@ -0,0 +1,222 @@ +@startuml +package com.iluwatar.saga.orchestration { + class ChapterResult { + - state : State + - value : K + ~ ChapterResult(value : K, state : State) + + failure(val : K) : ChapterResult {static} + + getValue() : K + + isSuccess() : boolean + + success(val : K) : ChapterResult {static} + } + enum State { + + FAILURE {static} + + SUCCESS {static} + + valueOf(name : String) : State {static} + + values() : State[] {static} + } + class FlyBookingService { + + FlyBookingService() + + getName() : String + } + class HotelBookingService { + + HotelBookingService() + + getName() : String + + rollback(value : String) : ChapterResult + } + interface OrchestrationChapter { + + getName() : String {abstract} + + process(K) : ChapterResult {abstract} + + rollback(K) : ChapterResult {abstract} + } + class OrderService { + + OrderService() + + getName() : String + } + class Saga { + - chapters : List + - Saga() + + chapter(name : String) : Saga + + create() : Saga {static} + + get(idx : int) : Chapter + + isPresent(idx : int) : boolean + } + class Chapter { + ~ name : String + + Chapter(name : String) + + getName() : String + } + enum Result { + + CRASHED {static} + + FINISHED {static} + + ROLLBACK {static} + + valueOf(name : String) : Result {static} + + values() : Result[] {static} + } + class SagaApplication { + - LOGGER : Logger {static} + + SagaApplication() + + main(args : String[]) {static} + - newSaga() : Saga {static} + - serviceDiscovery() : ServiceDiscoveryService {static} + } + class SagaOrchestrator { + - LOGGER : Logger {static} + - saga : Saga + - sd : ServiceDiscoveryService + - state : CurrentState + + SagaOrchestrator(saga : Saga, sd : ServiceDiscoveryService) + + execute(value : K) : Result + } + -class CurrentState { + ~ currentNumber : int + ~ isForward : boolean + ~ CurrentState() + ~ back() : int + ~ cleanUp() + ~ current() : int + ~ directionToBack() + ~ forward() : int + ~ isForward() : boolean + } + abstract class Service { + # LOGGER : Logger {static} + + Service() + + getName() : String {abstract} + + process(value : K) : ChapterResult + + rollback(value : K) : ChapterResult + } + class ServiceDiscoveryService { + - services : Map> + + ServiceDiscoveryService() + + discover(orchestrationChapterService : OrchestrationChapter) : ServiceDiscoveryService + + find(service : String) : Optional> + } + class WithdrawMoneyService { + + WithdrawMoneyService() + + getName() : String + + process(value : String) : ChapterResult + } +} +package com.iluwatar.saga.choreography { + interface ChoreographyChapter { + + execute(Saga) : Saga {abstract} + + getName() : String {abstract} + + process(Saga) : Saga {abstract} + + rollback(Saga) : Saga {abstract} + } + class FlyBookingService { + + FlyBookingService(service : ServiceDiscoveryService) + + getName() : String + } + class HotelBookingService { + + HotelBookingService(service : ServiceDiscoveryService) + + getName() : String + } + class OrderService { + + OrderService(service : ServiceDiscoveryService) + + getName() : String + } + class Saga { + - chapters : List + - finished : boolean + - forward : boolean + - pos : int + - Saga() + ~ back() : int + + chapter(name : String) : Saga + + create() : Saga {static} + ~ forward() : int + ~ getCurrent() : Chapter + + getCurrentValue() : Object + + getResult() : SagaResult + ~ isCurrentSuccess() : boolean + ~ isForward() : boolean + ~ isPresent() : boolean + + setCurrentStatus(result : ChapterResult) + + setCurrentValue(value : Object) + ~ setFinished(finished : boolean) + + setInValue(value : Object) : Saga + + toString() : String + } + class Chapter { + - inValue : Object + - name : String + - result : ChapterResult + + Chapter(name : String) + + getInValue() : Object + + getName() : String + + isSuccess() : boolean + + setInValue(object : Object) + + setResult(result : ChapterResult) + } + enum ChapterResult { + + INIT {static} + + ROLLBACK {static} + + SUCCESS {static} + + valueOf(name : String) : ChapterResult {static} + + values() : ChapterResult[] {static} + } + enum SagaResult { + + FINISHED {static} + + PROGRESS {static} + + ROLLBACKED {static} + + valueOf(name : String) : SagaResult {static} + + values() : SagaResult[] {static} + } + class SagaApplication { + - LOGGER : Logger {static} + + SagaApplication() + + main(args : String[]) {static} + - newSaga(value : Object) : Saga {static} + - serviceDiscovery() : ServiceDiscoveryService {static} + } + abstract class Service { + # LOGGER : Logger {static} + - sd : ServiceDiscoveryService + + Service(service : ServiceDiscoveryService) + + execute(saga : Saga) : Saga + - isSagaFinished(saga : Saga) : boolean + + process(saga : Saga) : Saga + + rollback(saga : Saga) : Saga + - serviceNotFoundException(chServiceName : String) : Supplier + } + class ServiceDiscoveryService { + - services : Map + + ServiceDiscoveryService() + + discover(chapterService : ChoreographyChapter) : ServiceDiscoveryService + + find(service : String) : Optional + + findAny() : ChoreographyChapter + } + class WithdrawMoneyService { + + WithdrawMoneyService(service : ServiceDiscoveryService) + + getName() : String + + process(saga : Saga) : Saga + } +} +SagaOrchestrator --> "-saga" Saga +SagaOrchestrator --> "-sd" ServiceDiscoveryService +SagaOrchestrator --> "-state" CurrentState +CurrentState ..+ SagaOrchestrator +Chapter ..+ Saga +Saga --> "-chapters" Chapter +Chapter --> "-result" ChapterResult +ChapterResult ..+ Saga +ChapterResult --> "-state" State +State ..+ ChapterResult +Result ..+ Saga +Service --> "-sd" ServiceDiscoveryService +SagaResult ..+ Saga +Saga --> "-chapters" Chapter +Chapter ..+ Saga +FlyBookingService --|> Service +HotelBookingService --|> Service +OrderService --|> Service +Service ..|> ChoreographyChapter +WithdrawMoneyService --|> Service +FlyBookingService --|> Service +HotelBookingService --|> Service +OrderService --|> Service +Service ..|> OrchestrationChapter +WithdrawMoneyService --|> Service +@enduml \ No newline at end of file diff --git a/semaphore/etc/semaphore.urm.puml b/semaphore/etc/semaphore.urm.puml new file mode 100644 index 000000000000..168fd17e711a --- /dev/null +++ b/semaphore/etc/semaphore.urm.puml @@ -0,0 +1,56 @@ +@startuml +package com.iluwatar.semaphore { + class App { + + App() + + main(args : String[]) {static} + } + class Fruit { + - type : FruitType + + Fruit(type : FruitType) + + getType() : FruitType + + toString() : String + } + enum FruitType { + + APPLE {static} + + LEMON {static} + + ORANGE {static} + + valueOf(name : String) : FruitType {static} + + values() : FruitType[] {static} + } + class FruitBowl { + - fruit : List + + FruitBowl() + + countFruit() : int + + put(f : Fruit) + + take() : Fruit + + toString() : String + } + class FruitShop { + - available : boolean[] + - bowls : FruitBowl[] + - semaphore : Semaphore + + FruitShop() + + countFruit() : int + + returnBowl(bowl : FruitBowl) + + takeBowl() : FruitBowl + } + interface Lock { + + acquire() {abstract} + + release() {abstract} + } + class Semaphore { + - counter : int + - licenses : int + + Semaphore(licenses : int) + + acquire() + + getAvailableLicenses() : int + + getNumLicenses() : int + + release() + } +} +FruitType ..+ Fruit +Fruit --> "-type" FruitType +FruitShop --> "-semaphore" Semaphore +FruitBowl --> "-fruit" Fruit +Semaphore ..|> Lock +@enduml \ No newline at end of file diff --git a/servant/etc/servant.urm.puml b/servant/etc/servant.urm.puml new file mode 100644 index 000000000000..26ea0c28530d --- /dev/null +++ b/servant/etc/servant.urm.puml @@ -0,0 +1,56 @@ +@startuml +package com.iluwatar.servant { + class App { + - LOGGER : Logger {static} + - jenkins : Servant {static} + - travis : Servant {static} + + App() + + main(args : String[]) {static} + + scenario(servant : Servant, compliment : int) {static} + } + class King { + - complimentReceived : boolean + - isDrunk : boolean + - isHappy : boolean + - isHungry : boolean + + King() + + changeMood() + + getDrink() + + getFed() + + getMood() : boolean + + receiveCompliments() + } + class Queen { + - complimentReceived : boolean + - isDrunk : boolean + - isFlirty : boolean + - isHappy : boolean + - isHungry : boolean + + Queen() + + changeMood() + + getDrink() + + getFed() + + getMood() : boolean + + receiveCompliments() + + setFlirtiness(f : boolean) + } + ~interface Royalty { + + changeMood() {abstract} + + getDrink() {abstract} + + getFed() {abstract} + + getMood() : boolean {abstract} + + receiveCompliments() {abstract} + } + class Servant { + + name : String + + Servant(name : String) + + checkIfYouWillBeHanged(tableGuests : List) : boolean + + feed(r : Royalty) + + giveCompliments(r : Royalty) + + giveWine(r : Royalty) + } +} +App --> "-jenkins" Servant +King ..|> Royalty +Queen ..|> Royalty +@enduml \ No newline at end of file diff --git a/serverless/etc/serverless.urm.puml b/serverless/etc/serverless.urm.puml new file mode 100644 index 000000000000..27ff043fd6a8 --- /dev/null +++ b/serverless/etc/serverless.urm.puml @@ -0,0 +1,138 @@ +@startuml +package com.iluwatar.serverless.faas.api { + class LambdaInfoApiHandler { + - LOG : Logger {static} + - SUCCESS_STATUS_CODE : Integer {static} + + LambdaInfoApiHandler() + + handleRequest(input : Map, context : Context) : ApiGatewayResponse + - headers() : Map + - lambdaInfo(context : Context) : LambdaInfo + } +} +package com.iluwatar.serverless.baas.model { + class Address { + - addressLineOne : String + - addressLineTwo : String + - city : String + - serialVersionUID : long {static} + - state : String + - zipCode : String + + Address() + + equals(o : Object) : boolean + + getAddressLineOne() : String + + getAddressLineTwo() : String + + getCity() : String + + getState() : String + + getZipCode() : String + + hashCode() : int + + setAddressLineOne(addressLineOne : String) + + setAddressLineTwo(addressLineTwo : String) + + setCity(city : String) + + setState(state : String) + + setZipCode(zipCode : String) + + toString() : String + } + class Person { + - address : Address + - firstName : String + - id : String + - lastName : String + - serialVersionUID : long {static} + + Person() + + equals(o : Object) : boolean + + getAddress() : Address + + getFirstName() : String + + getId() : String + + getLastName() : String + + hashCode() : int + + setAddress(address : Address) + + setFirstName(firstName : String) + + setId(id : String) + + setLastName(lastName : String) + + toString() : String + } +} +package com.iluwatar.serverless.faas { + class ApiGatewayResponse { + - body : String + - headers : Map + - isBase64Encoded : Boolean + - serialVersionUID : long {static} + - statusCode : Integer + + ApiGatewayResponse(statusCode : Integer, body : String, headers : Map, isBase64Encoded : Boolean) + + getBody() : String + + getHeaders() : Map + + getStatusCode() : Integer + + isBase64Encoded() : Boolean + } + class ApiGatewayResponseBuilder { + - OBJECT_MAPPER : ObjectMapper {static} + - body : T extends Serializable + - headers : Map + - isBase64Encoded : Boolean + - statusCode : Integer + + ApiGatewayResponseBuilder() + + base64Encoded(isBase64Encoded : Boolean) : ApiGatewayResponseBuilder + + body(body : T extends Serializable) : ApiGatewayResponseBuilder + + build() : ApiGatewayResponse + + headers(headers : Map) : ApiGatewayResponseBuilder + + statusCode(statusCode : Integer) : ApiGatewayResponseBuilder + } + class LambdaInfo { + - awsRequestId : String + - functionName : String + - functionVersion : String + - logGroupName : String + - logStreamName : String + - memoryLimitInMb : Integer + - serialVersionUID : long {static} + + LambdaInfo() + + equals(o : Object) : boolean + + getAwsRequestId() : String + + getFunctionName() : String + + getFunctionVersion() : String + + getLogGroupName() : String + + getLogStreamName() : String + + getMemoryLimitInMb() : Integer + + hashCode() : int + + setAwsRequestId(awsRequestId : String) + + setFunctionName(functionName : String) + + setFunctionVersion(functionVersion : String) + + setLogGroupName(logGroupName : String) + + setLogStreamName(logStreamName : String) + + setMemoryLimitInMb(memoryLimitInMb : Integer) + + toString() : String + } +} +package com.iluwatar.serverless.baas.api { + abstract class AbstractDynamoDbHandler { + - dynamoDbMapper : DynamoDBMapper + - objectMapper : ObjectMapper + + AbstractDynamoDbHandler() + # apiGatewayProxyResponseEvent(statusCode : Integer, body : T extends Serializable) : APIGatewayProxyResponseEvent + # getDynamoDbMapper() : DynamoDBMapper + # getObjectMapper() : ObjectMapper + # headers() : Map + - initAmazonDynamoDb() + + setDynamoDbMapper(dynamoDbMapper : DynamoDBMapper) + } + class FindPersonApiHandler { + - LOG : Logger {static} + - SUCCESS_STATUS_CODE : Integer {static} + + FindPersonApiHandler() + + handleRequest(apiGatewayProxyRequestEvent : APIGatewayProxyRequestEvent, context : Context) : APIGatewayProxyResponseEvent + } + class SavePersonApiHandler { + - BAD_REQUEST_STATUS_CODE : Integer {static} + - CREATED_STATUS_CODE : Integer {static} + - LOG : Logger {static} + + SavePersonApiHandler() + + handleRequest(apiGatewayProxyRequestEvent : APIGatewayProxyRequestEvent, context : Context) : APIGatewayProxyResponseEvent + } +} +ApiGatewayResponseBuilder ..+ ApiGatewayResponse +Person --> "-address" Address +Access ..+ JsonProperty +FindPersonApiHandler --|> AbstractDynamoDbHandler +SavePersonApiHandler --|> AbstractDynamoDbHandler +@enduml \ No newline at end of file diff --git a/service-layer/etc/service-layer.urm.puml b/service-layer/etc/service-layer.urm.puml new file mode 100644 index 000000000000..e663e6c4a678 --- /dev/null +++ b/service-layer/etc/service-layer.urm.puml @@ -0,0 +1,159 @@ +@startuml +package com.iluwatar.servicelayer.hibernate { + class HibernateUtil { + - LOGGER : Logger {static} + - sessionFactory : SessionFactory {static} + - HibernateUtil() + + dropSession() {static} + + getSessionFactory() : SessionFactory {static} + } +} +package com.iluwatar.servicelayer.common { + abstract class BaseEntity { + + BaseEntity() + + getId() : Long {abstract} + + getName() : String {abstract} + + setId(Long) {abstract} + + setName(String) {abstract} + } + interface Dao { + + delete(E extends BaseEntity) {abstract} + + find(Long) : E extends BaseEntity {abstract} + + findAll() : List {abstract} + + merge(E extends BaseEntity) : E extends BaseEntity {abstract} + + persist(E extends BaseEntity) {abstract} + } + abstract class DaoBaseImpl { + # persistentClass : Class + + DaoBaseImpl() + + delete(entity : E extends BaseEntity) + + find(id : Long) : E extends BaseEntity + + findAll() : List + # getSessionFactory() : SessionFactory + + merge(entity : E extends BaseEntity) : E extends BaseEntity + + persist(entity : E extends BaseEntity) + } +} +package com.iluwatar.servicelayer.magic { + interface MagicService { + + findAllSpellbooks() : List {abstract} + + findAllSpells() : List {abstract} + + findAllWizards() : List {abstract} + + findWizardsWithSpell(String) : List {abstract} + + findWizardsWithSpellbook(String) : List {abstract} + } + class MagicServiceImpl { + - spellDao : SpellDao + - spellbookDao : SpellbookDao + - wizardDao : WizardDao + + MagicServiceImpl(wizardDao : WizardDao, spellbookDao : SpellbookDao, spellDao : SpellDao) + + findAllSpellbooks() : List + + findAllSpells() : List + + findAllWizards() : List + + findWizardsWithSpell(name : String) : List + + findWizardsWithSpellbook(name : String) : List + } +} +package com.iluwatar.servicelayer.wizard { + class Wizard { + - id : Long + - name : String + - spellbooks : Set + + Wizard() + + Wizard(name : String) + + addSpellbook(spellbook : Spellbook) + + getId() : Long + + getName() : String + + getSpellbooks() : Set + + setId(id : Long) + + setName(name : String) + + setSpellbooks(spellbooks : Set) + + toString() : String + } + interface WizardDao { + + findByName(String) : Wizard {abstract} + } + class WizardDaoImpl { + + WizardDaoImpl() + + findByName(name : String) : Wizard + } +} +package com.iluwatar.servicelayer.spellbook { + class Spellbook { + - id : Long + - name : String + - spells : Set + - wizards : Set + + Spellbook() + + Spellbook(name : String) + + addSpell(spell : Spell) + + getId() : Long + + getName() : String + + getSpells() : Set + + getWizards() : Set + + setId(id : Long) + + setName(name : String) + + setSpells(spells : Set) + + setWizards(wizards : Set) + + toString() : String + } + interface SpellbookDao { + + findByName(String) : Spellbook {abstract} + } + class SpellbookDaoImpl { + + SpellbookDaoImpl() + + findByName(name : String) : Spellbook + } +} +package com.iluwatar.servicelayer.spell { + class Spell { + - id : Long + - name : String + - spellbook : Spellbook + + Spell() + + Spell(name : String) + + getId() : Long + + getName() : String + + getSpellbook() : Spellbook + + setId(id : Long) + + setName(name : String) + + setSpellbook(spellbook : Spellbook) + + toString() : String + } + interface SpellDao { + + findByName(String) : Spell {abstract} + } + class SpellDaoImpl { + + SpellDaoImpl() + + findByName(name : String) : Spell + } +} +package com.iluwatar.servicelayer.app { + class App { + - LOGGER : Logger {static} + + App() + + initData() {static} + + main(args : String[]) {static} + + queryData() {static} + } +} +MagicServiceImpl --> "-wizardDao" WizardDao +MagicServiceImpl --> "-spellbookDao" SpellbookDao +MagicServiceImpl --> "-spellDao" SpellDao +Spellbook --> "-spells" Spell +Spellbook --> "-wizards" Wizard +DaoBaseImpl ..|> Dao +MagicServiceImpl ..|> MagicService +Spell --|> BaseEntity +SpellDao --|> Dao +SpellDaoImpl ..|> SpellDao +SpellDaoImpl --|> DaoBaseImpl +Spellbook --|> BaseEntity +SpellbookDao --|> Dao +SpellbookDaoImpl ..|> SpellbookDao +SpellbookDaoImpl --|> DaoBaseImpl +Wizard --|> BaseEntity +WizardDao --|> Dao +WizardDaoImpl ..|> WizardDao +WizardDaoImpl --|> DaoBaseImpl +@enduml \ No newline at end of file diff --git a/service-locator/etc/service-locator.urm.puml b/service-locator/etc/service-locator.urm.puml new file mode 100644 index 000000000000..38fe7ea1b0d0 --- /dev/null +++ b/service-locator/etc/service-locator.urm.puml @@ -0,0 +1,41 @@ +@startuml +package com.iluwatar.servicelocator { + class App { + + App() + + main(args : String[]) {static} + } + class InitContext { + - LOGGER : Logger {static} + + InitContext() + + lookup(serviceName : String) : Object + } + interface Service { + + execute() {abstract} + + getId() : int {abstract} + + getName() : String {abstract} + } + class ServiceCache { + - LOGGER : Logger {static} + - serviceCache : Map + + ServiceCache() + + addService(newService : Service) + + getService(serviceName : String) : Service + } + class ServiceImpl { + - LOGGER : Logger {static} + - id : int + - serviceName : String + + ServiceImpl(serviceName : String) + + execute() + + getId() : int + + getName() : String + } + class ServiceLocator { + - serviceCache : ServiceCache {static} + - ServiceLocator() + + getService(serviceJndiName : String) : Service {static} + } +} +ServiceLocator --> "-serviceCache" ServiceCache +ServiceImpl ..|> Service +@enduml \ No newline at end of file diff --git a/sharding/etc/sharding.urm.puml b/sharding/etc/sharding.urm.puml new file mode 100644 index 000000000000..a51d027d5d5e --- /dev/null +++ b/sharding/etc/sharding.urm.puml @@ -0,0 +1,71 @@ +@startuml +package com.iluwatar.sharding { + class App { + + App() + + main(args : String[]) {static} + } + class Data { + - key : int + - type : DataType + - value : String + + Data(key : int, value : String, type : DataType) + + getKey() : int + + getType() : DataType + + getValue() : String + + setKey(key : int) + + setType(type : DataType) + + setValue(value : String) + + toString() : String + } + ~enum DataType { + + type1 {static} + + type2 {static} + + type3 {static} + + valueOf(name : String) : DataType {static} + + values() : DataType[] {static} + } + class HashShardManager { + - LOGGER : Logger {static} + + HashShardManager() + # allocateShard(data : Data) : int + + storeData(data : Data) : int + } + class LookupShardManager { + - LOGGER : Logger {static} + - lookupMap : Map + + LookupShardManager() + # allocateShard(data : Data) : int + + storeData(data : Data) : int + } + class RangeShardManager { + - LOGGER : Logger {static} + + RangeShardManager() + # allocateShard(data : Data) : int + + storeData(data : Data) : int + } + class Shard { + - dataStore : Map + - id : int + + Shard(id : int) + + clearData() + + getDataById(id : int) : Data + + getId() : int + + storeData(data : Data) + } + abstract class ShardManager { + - LOGGER : Logger {static} + # shardMap : Map + + ShardManager() + + addNewShard(shard : Shard) : boolean + # allocateShard(Data) : int {abstract} + + getShardById(shardId : int) : Shard + + removeShardById(shardId : int) : boolean + + storeData(Data) : int {abstract} + } +} +DataType ..+ Data +Data --> "-type" DataType +HashShardManager --|> ShardManager +LookupShardManager --|> ShardManager +RangeShardManager --|> ShardManager +@enduml \ No newline at end of file diff --git a/singleton/etc/singleton.urm.puml b/singleton/etc/singleton.urm.puml new file mode 100644 index 000000000000..371c9e2393d1 --- /dev/null +++ b/singleton/etc/singleton.urm.puml @@ -0,0 +1,44 @@ +@startuml +package com.iluwatar.singleton { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + enum EnumIvoryTower { + + INSTANCE {static} + + toString() : String + + valueOf(name : String) : EnumIvoryTower {static} + + values() : EnumIvoryTower[] {static} + } + class InitializingOnDemandHolderIdiom { + - InitializingOnDemandHolderIdiom() + + getInstance() : InitializingOnDemandHolderIdiom {static} + } + -class HelperHolder { + - INSTANCE : InitializingOnDemandHolderIdiom {static} + - HelperHolder() + } + class IvoryTower { + - INSTANCE : IvoryTower {static} + - IvoryTower() + + getInstance() : IvoryTower {static} + } + class ThreadSafeDoubleCheckLocking { + - flag : boolean {static} + - instance : ThreadSafeDoubleCheckLocking {static} + - ThreadSafeDoubleCheckLocking() + + getInstance() : ThreadSafeDoubleCheckLocking {static} + } + class ThreadSafeLazyLoadedIvoryTower { + - instance : ThreadSafeLazyLoadedIvoryTower {static} + - ThreadSafeLazyLoadedIvoryTower() + + getInstance() : ThreadSafeLazyLoadedIvoryTower {static} + } +} +IvoryTower --> "-INSTANCE" IvoryTower +ThreadSafeDoubleCheckLocking --> "-instance" ThreadSafeDoubleCheckLocking +ThreadSafeLazyLoadedIvoryTower --> "-instance" ThreadSafeLazyLoadedIvoryTower +HelperHolder ..+ InitializingOnDemandHolderIdiom +HelperHolder --> "-INSTANCE" InitializingOnDemandHolderIdiom +@enduml \ No newline at end of file diff --git a/spatial-partition/etc/spatial-partition.urm.puml b/spatial-partition/etc/spatial-partition.urm.puml new file mode 100644 index 000000000000..5962fcc4baca --- /dev/null +++ b/spatial-partition/etc/spatial-partition.urm.puml @@ -0,0 +1,72 @@ +@startuml +package com.iluwatar.spatialpartition { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + ~ noSpatialPartition(height : int, width : int, numOfMovements : int, bubbles : Hashtable) {static} + ~ withSpatialPartition(height : int, width : int, numOfMovements : int, bubbles : Hashtable) {static} + } + class Bubble { + - LOGGER : Logger {static} + - RANDOM : Random {static} + ~ radius : int + ~ Bubble(x : int, y : int, id : int, radius : int) + ~ handleCollision(bubblesToCheck : ArrayList>, allBubbles : Hashtable) + ~ move() + ~ pop(allBubbles : Hashtable) + ~ touches(b : Bubble) : boolean + } + abstract class Point { + + coordinateX : int + + coordinateY : int + + id : int + ~ Point(x : int, y : int, id : int) + ~ handleCollision(ArrayList>, Hashtable) {abstract} + ~ move() {abstract} + ~ touches(T) : boolean {abstract} + } + class QuadTree { + ~ boundary : Rect + ~ capacity : int + ~ divided : boolean + ~ northeast : QuadTree + ~ northwest : QuadTree + ~ points : Hashtable> + ~ southeast : QuadTree + ~ southwest : QuadTree + ~ QuadTree(boundary : Rect, capacity : int) + ~ divide() + ~ insert(p : Point) + ~ query(r : Rect, relevantPoints : ArrayList>) : ArrayList> + } + class Rect { + ~ coordinateX : double + ~ coordinateY : double + ~ height : double + ~ width : double + ~ Rect(x : double, y : double, width : double, height : double) + ~ contains(p : Point) : boolean + ~ intersects(other : Rect) : boolean + } + class SpatialPartitionBubbles { + ~ bubbles : Hashtable + ~ quadTree : QuadTree + ~ SpatialPartitionBubbles(bubbles : Hashtable, quadTree : QuadTree) + ~ handleCollisionsUsingQt(b : Bubble) + } + abstract class SpatialPartitionGeneric { + ~ playerPositions : Hashtable + ~ quadTree : QuadTree + + SpatialPartitionGeneric() + ~ handleCollisionsUsingQt(T) {abstract} + } +} +SpatialPartitionBubbles --> "-quadTree" QuadTree +SpatialPartitionGeneric --> "-quadTree" QuadTree +QuadTree --> "-boundary" Rect +QuadTree --> "-northwest" QuadTree +QuadTree --> "-southwest" QuadTree +Bubble --|> Point +SpatialPartitionBubbles --|> SpatialPartitionGeneric +@enduml \ No newline at end of file diff --git a/specification/etc/specification.urm.puml b/specification/etc/specification.urm.puml new file mode 100644 index 000000000000..21cae1c3c2a4 --- /dev/null +++ b/specification/etc/specification.urm.puml @@ -0,0 +1,177 @@ +@startuml +package com.iluwatar.specification.creature { + abstract class AbstractCreature { + - color : Color + - mass : Mass + - movement : Movement + - name : String + - size : Size + + AbstractCreature(name : String, size : Size, movement : Movement, color : Color, mass : Mass) + + getColor() : Color + + getMass() : Mass + + getMovement() : Movement + + getName() : String + + getSize() : Size + + toString() : String + } + interface Creature { + + getColor() : Color {abstract} + + getMass() : Mass {abstract} + + getMovement() : Movement {abstract} + + getName() : String {abstract} + + getSize() : Size {abstract} + } + class Dragon { + + Dragon() + + Dragon(mass : Mass) + } + class Goblin { + + Goblin() + + Goblin(mass : Mass) + } + class KillerBee { + + KillerBee() + + KillerBee(mass : Mass) + } + class Octopus { + + Octopus() + + Octopus(mass : Mass) + } + class Shark { + + Shark() + + Shark(mass : Mass) + } + class Troll { + + Troll() + + Troll(mass : Mass) + } +} +package com.iluwatar.specification.property { + enum Color { + + DARK {static} + + GREEN {static} + + LIGHT {static} + + RED {static} + - title : String + + toString() : String + + valueOf(name : String) : Color {static} + + values() : Color[] {static} + } + class Mass { + - title : String + - value : double + + Mass(value : double) + + equals(obj : Object) : boolean + + greaterThan(other : Mass) : boolean + + greaterThanOrEq(other : Mass) : boolean + + smallerThan(other : Mass) : boolean + + smallerThanOrEq(other : Mass) : boolean + + toString() : String + } + enum Movement { + + FLYING {static} + + SWIMMING {static} + + WALKING {static} + - title : String + + toString() : String + + valueOf(name : String) : Movement {static} + + values() : Movement[] {static} + } + enum Size { + + LARGE {static} + + NORMAL {static} + + SMALL {static} + - title : String + + toString() : String + + valueOf(name : String) : Size {static} + + values() : Size[] {static} + } +} +package com.iluwatar.specification.selector { + abstract class AbstractSelector { + + AbstractSelector() + + and(other : AbstractSelector) : AbstractSelector + + not() : AbstractSelector + + or(other : AbstractSelector) : AbstractSelector + } + class ColorSelector { + - color : Color + + ColorSelector(c : Color) + + test(t : Creature) : boolean + } + class ConjunctionSelector { + - leafComponents : List> + ~ ConjunctionSelector(selectors : AbstractSelector[]) + + test(t : T) : boolean + } + class DisjunctionSelector { + - leafComponents : List> + ~ DisjunctionSelector(selectors : AbstractSelector[]) + + test(t : T) : boolean + } + class MassEqualSelector { + - mass : Mass + + MassEqualSelector(mass : double) + + test(t : Creature) : boolean + } + class MassGreaterThanSelector { + - mass : Mass + + MassGreaterThanSelector(mass : double) + + test(t : Creature) : boolean + } + class MassSmallerThanOrEqSelector { + - mass : Mass + + MassSmallerThanOrEqSelector(mass : double) + + test(t : Creature) : boolean + } + class MovementSelector { + - movement : Movement + + MovementSelector(m : Movement) + + test(t : Creature) : boolean + } + class NegationSelector { + - component : AbstractSelector + ~ NegationSelector(selector : AbstractSelector) + + test(t : T) : boolean + } + class SizeSelector { + - size : Size + + SizeSelector(s : Size) + + test(t : Creature) : boolean + } +} +package com.iluwatar.specification.app { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } +} +SizeSelector --> "-size" Size +AbstractCreature --> "-mass" Mass +MassEqualSelector --> "-mass" Mass +AbstractCreature --> "-color" Color +MassGreaterThanSelector --> "-mass" Mass +MovementSelector --> "-movement" Movement +NegationSelector --> "-component" AbstractSelector +AbstractCreature --> "-movement" Movement +MassSmallerThanOrEqSelector --> "-mass" Mass +AbstractCreature --> "-size" Size +ColorSelector --> "-color" Color +AbstractCreature ..|> Creature +Dragon --|> AbstractCreature +Goblin --|> AbstractCreature +KillerBee --|> AbstractCreature +Octopus --|> AbstractCreature +Shark --|> AbstractCreature +Troll --|> AbstractCreature +ColorSelector --|> AbstractSelector +ConjunctionSelector --|> AbstractSelector +DisjunctionSelector --|> AbstractSelector +MassEqualSelector --|> AbstractSelector +MassGreaterThanSelector --|> AbstractSelector +MassSmallerThanOrEqSelector --|> AbstractSelector +MovementSelector --|> AbstractSelector +NegationSelector --|> AbstractSelector +SizeSelector --|> AbstractSelector +@enduml \ No newline at end of file diff --git a/state/etc/state.urm.puml b/state/etc/state.urm.puml new file mode 100644 index 000000000000..207a227d83d7 --- /dev/null +++ b/state/etc/state.urm.puml @@ -0,0 +1,39 @@ +@startuml +package com.iluwatar.state { + class AngryState { + - LOGGER : Logger {static} + - mammoth : Mammoth + + AngryState(mammoth : Mammoth) + + observe() + + onEnterState() + } + class App { + + App() + + main(args : String[]) {static} + } + class Mammoth { + - state : State + + Mammoth() + - changeStateTo(newState : State) + + observe() + + timePasses() + + toString() : String + } + class PeacefulState { + - LOGGER : Logger {static} + - mammoth : Mammoth + + PeacefulState(mammoth : Mammoth) + + observe() + + onEnterState() + } + interface State { + + observe() {abstract} + + onEnterState() {abstract} + } +} +PeacefulState --> "-mammoth" Mammoth +AngryState --> "-mammoth" Mammoth +Mammoth --> "-state" State +AngryState ..|> State +PeacefulState ..|> State +@enduml \ No newline at end of file diff --git a/step-builder/etc/step-builder.urm.puml b/step-builder/etc/step-builder.urm.puml new file mode 100644 index 000000000000..4a56e1e9bdbe --- /dev/null +++ b/step-builder/etc/step-builder.urm.puml @@ -0,0 +1,91 @@ +@startuml +package com.iluwatar.stepbuilder { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Character { + - abilities : List + - fighterClass : String + - name : String + - spell : String + - weapon : String + - wizardClass : String + + Character(name : String) + + getAbilities() : List + + getFighterClass() : String + + getName() : String + + getSpell() : String + + getWeapon() : String + + getWizardClass() : String + + setAbilities(abilities : List) + + setFighterClass(fighterClass : String) + + setName(name : String) + + setSpell(spell : String) + + setWeapon(weapon : String) + + setWizardClass(wizardClass : String) + + toString() : String + } + class CharacterStepBuilder { + - CharacterStepBuilder() + + newBuilder() : NameStep {static} + } + interface AbilityStep { + + noAbilities() : BuildStep {abstract} + + noMoreAbilities() : BuildStep {abstract} + + withAbility(String) : AbilityStep {abstract} + } + interface BuildStep { + + build() : Character {abstract} + } + -class CharacterSteps { + - abilities : List + - fighterClass : String + - name : String + - spell : String + - weapon : String + - wizardClass : String + - CharacterSteps() + + build() : Character + + fighterClass(fighterClass : String) : WeaponStep + + name(name : String) : ClassStep + + noAbilities() : BuildStep + + noMoreAbilities() : BuildStep + + noSpell() : BuildStep + + noWeapon() : BuildStep + + withAbility(ability : String) : AbilityStep + + withSpell(spell : String) : AbilityStep + + withWeapon(weapon : String) : AbilityStep + + wizardClass(wizardClass : String) : SpellStep + } + interface ClassStep { + + fighterClass(String) : WeaponStep {abstract} + + wizardClass(String) : SpellStep {abstract} + } + interface NameStep { + + name(String) : ClassStep {abstract} + } + interface SpellStep { + + noSpell() : BuildStep {abstract} + + withSpell(String) : AbilityStep {abstract} + } + interface WeaponStep { + + noWeapon() : BuildStep {abstract} + + withWeapon(String) : AbilityStep {abstract} + } +} +WeaponStep ..+ CharacterStepBuilder +AbilityStep ..+ CharacterStepBuilder +ClassStep ..+ CharacterStepBuilder +CharacterSteps ..+ CharacterStepBuilder +SpellStep ..+ CharacterStepBuilder +BuildStep ..+ CharacterStepBuilder +NameStep ..+ CharacterStepBuilder +CharacterSteps ..|> NameStep +CharacterSteps ..|> ClassStep +CharacterSteps ..|> WeaponStep +CharacterSteps ..|> SpellStep +CharacterSteps ..|> AbilityStep +CharacterSteps ..|> BuildStep +@enduml \ No newline at end of file diff --git a/strategy/etc/strategy.urm.puml b/strategy/etc/strategy.urm.puml new file mode 100644 index 000000000000..8b9daabb9db4 --- /dev/null +++ b/strategy/etc/strategy.urm.puml @@ -0,0 +1,37 @@ +@startuml +package com.iluwatar.strategy { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class DragonSlayer { + - strategy : DragonSlayingStrategy + + DragonSlayer(strategy : DragonSlayingStrategy) + + changeStrategy(strategy : DragonSlayingStrategy) + + goToBattle() + } + interface DragonSlayingStrategy { + + execute() {abstract} + } + class MeleeStrategy { + - LOGGER : Logger {static} + + MeleeStrategy() + + execute() + } + class ProjectileStrategy { + - LOGGER : Logger {static} + + ProjectileStrategy() + + execute() + } + class SpellStrategy { + - LOGGER : Logger {static} + + SpellStrategy() + + execute() + } +} +DragonSlayer --> "-strategy" DragonSlayingStrategy +MeleeStrategy ..|> DragonSlayingStrategy +ProjectileStrategy ..|> DragonSlayingStrategy +SpellStrategy ..|> DragonSlayingStrategy +@enduml \ No newline at end of file diff --git a/subclass-sandbox/etc/subclass-sandbox.urm.puml b/subclass-sandbox/etc/subclass-sandbox.urm.puml new file mode 100644 index 000000000000..a1f863b697c9 --- /dev/null +++ b/subclass-sandbox/etc/subclass-sandbox.urm.puml @@ -0,0 +1,27 @@ +@startuml +package com.iluwatar.subclasssandbox { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class GroundDive { + + GroundDive() + # activate() + } + class SkyLaunch { + + SkyLaunch() + # activate() + } + abstract class Superpower { + # logger : Logger + + Superpower() + # activate() {abstract} + # move(x : double, y : double, z : double) + # playSound(soundName : String, volumn : int) + # spawnParticles(particleType : String, count : int) + } +} +GroundDive --|> Superpower +SkyLaunch --|> Superpower +@enduml \ No newline at end of file diff --git a/template-method/etc/template-method.urm.puml b/template-method/etc/template-method.urm.puml new file mode 100644 index 000000000000..a6e2dc3d20fd --- /dev/null +++ b/template-method/etc/template-method.urm.puml @@ -0,0 +1,39 @@ +@startuml +package com.iluwatar.templatemethod { + class App { + + App() + + main(args : String[]) {static} + } + class HalflingThief { + - method : StealingMethod + + HalflingThief(method : StealingMethod) + + changeMethod(method : StealingMethod) + + steal() + } + class HitAndRunMethod { + - LOGGER : Logger {static} + + HitAndRunMethod() + # confuseTarget(target : String) + # pickTarget() : String + # stealTheItem(target : String) + } + abstract class StealingMethod { + - LOGGER : Logger {static} + + StealingMethod() + # confuseTarget(String) {abstract} + # pickTarget() : String {abstract} + + steal() + # stealTheItem(String) {abstract} + } + class SubtleMethod { + - LOGGER : Logger {static} + + SubtleMethod() + # confuseTarget(target : String) + # pickTarget() : String + # stealTheItem(target : String) + } +} +HalflingThief --> "-method" StealingMethod +HitAndRunMethod --|> StealingMethod +SubtleMethod --|> StealingMethod +@enduml \ No newline at end of file diff --git a/thread-pool/etc/thread-pool.urm.puml b/thread-pool/etc/thread-pool.urm.puml new file mode 100644 index 000000000000..251033c8157c --- /dev/null +++ b/thread-pool/etc/thread-pool.urm.puml @@ -0,0 +1,37 @@ +@startuml +package com.iluwatar.threadpool { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class CoffeeMakingTask { + - TIME_PER_CUP : int {static} + + CoffeeMakingTask(numCups : int) + + toString() : String + } + class PotatoPeelingTask { + - TIME_PER_POTATO : int {static} + + PotatoPeelingTask(numPotatoes : int) + + toString() : String + } + abstract class Task { + - ID_GENERATOR : AtomicInteger {static} + - id : int + - timeMs : int + + Task(timeMs : int) + + getId() : int + + getTimeMs() : int + + toString() : String + } + class Worker { + - LOGGER : Logger {static} + - task : Task + + Worker(task : Task) + + run() + } +} +Worker --> "-task" Task +CoffeeMakingTask --|> Task +PotatoPeelingTask --|> Task +@enduml \ No newline at end of file diff --git a/throttling/etc/throttling.urm.puml b/throttling/etc/throttling.urm.puml new file mode 100644 index 000000000000..797006627b84 --- /dev/null +++ b/throttling/etc/throttling.urm.puml @@ -0,0 +1,47 @@ +@startuml +package com.iluwatar.throttling { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + - makeServiceCalls(tenant : Tenant, callsCount : CallsCount) {static} + } + ~class B2BService { + - LOGGER : Logger {static} + - callsCount : CallsCount + + B2BService(timer : Throttler, callsCount : CallsCount) + + dummyCustomerApi(tenant : Tenant) : int + - getRandomCustomerId() : int + } + class CallsCount { + - LOGGER : Logger {static} + - tenantCallsCount : Map + + CallsCount() + + addTenant(tenantName : String) + + getCount(tenantName : String) : long + + incrementCount(tenantName : String) + + reset() + } + class Tenant { + - allowedCallsPerSecond : int + - name : String + + Tenant(name : String, allowedCallsPerSecond : int, callsCount : CallsCount) + + getAllowedCallsPerSecond() : int + + getName() : String + } +} +package com.iluwatar.throttling.timer { + class ThrottleTimerImpl { + - callsCount : CallsCount + - throttlePeriod : int + + ThrottleTimerImpl(throttlePeriod : int, callsCount : CallsCount) + + start() + } + interface Throttler { + + start() {abstract} + } +} +B2BService --> "-callsCount" CallsCount +ThrottleTimerImpl --> "-callsCount" CallsCount +ThrottleTimerImpl ..|> Throttler +@enduml \ No newline at end of file diff --git a/tls/etc/tls.urm.puml b/tls/etc/tls.urm.puml new file mode 100644 index 000000000000..12bcea0643b6 --- /dev/null +++ b/tls/etc/tls.urm.puml @@ -0,0 +1,25 @@ +@startuml +package com.iluwatar.tls { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + - printAndCountDates(res : Result) : int {static} + - printAndCountExceptions(res : Result) : int {static} + } + class DateFormatCallable { + - LOGGER : Logger {static} + - dateValue : String + - df : ThreadLocal + + DateFormatCallable(inDateFormat : String, inDateValue : String) + + call() : Result + } + class Result { + - dateList : List + - exceptionList : List + + Result() + + getDateList() : List + + getExceptionList() : List + } +} +@enduml \ No newline at end of file diff --git a/tolerant-reader/etc/tolerant-reader.urm.puml b/tolerant-reader/etc/tolerant-reader.urm.puml new file mode 100644 index 000000000000..a73394a4ed7d --- /dev/null +++ b/tolerant-reader/etc/tolerant-reader.urm.puml @@ -0,0 +1,39 @@ +@startuml +package com.iluwatar.tolerantreader { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class RainbowFish { + - age : int + - lengthMeters : int + - name : String + - serialVersionUID : long {static} + - weightTons : int + + RainbowFish(name : String, age : int, lengthMeters : int, weightTons : int) + + getAge() : int + + getLengthMeters() : int + + getName() : String + + getWeightTons() : int + } + class RainbowFishSerializer { + - RainbowFishSerializer() + + readV1(filename : String) : RainbowFish {static} + + writeV1(rainbowFish : RainbowFish, filename : String) {static} + + writeV2(rainbowFish : RainbowFishV2, filename : String) {static} + } + class RainbowFishV2 { + - angry : boolean + - hungry : boolean + - serialVersionUID : long {static} + - sleeping : boolean + + RainbowFishV2(name : String, age : int, lengthMeters : int, weightTons : int) + + RainbowFishV2(name : String, age : int, lengthMeters : int, weightTons : int, sleeping : boolean, hungry : boolean, angry : boolean) + + getAngry() : boolean + + getHungry() : boolean + + getSleeping() : boolean + } +} +RainbowFishV2 --|> RainbowFish +@enduml \ No newline at end of file diff --git a/trampoline/etc/trampoline.urm.puml b/trampoline/etc/trampoline.urm.puml new file mode 100644 index 000000000000..31ca84b6da4a --- /dev/null +++ b/trampoline/etc/trampoline.urm.puml @@ -0,0 +1,18 @@ +@startuml +package com.iluwatar.trampoline { + interface Trampoline { + + complete() : boolean + + done(result : T) : Trampoline {static} + + get() : T {abstract} + + jump() : Trampoline + + more(trampoline : Trampoline>) : Trampoline {static} + + result() : T + } + class TrampolineApp { + - log : Logger {static} + + TrampolineApp() + + loop(times : int, prod : int) : Trampoline {static} + + main(args : String[]) {static} + } +} +@enduml \ No newline at end of file diff --git a/twin/etc/twin.urm.puml b/twin/etc/twin.urm.puml new file mode 100644 index 000000000000..e48298f18262 --- /dev/null +++ b/twin/etc/twin.urm.puml @@ -0,0 +1,27 @@ +@startuml +package com.iluwatar.twin { + class App { + + App() + + main(args : String[]) {static} + - waiting() {static} + } + class BallItem { + - LOGGER : Logger {static} + - isSuspended : boolean + - twin : BallThread + + BallItem() + + click() + + doDraw() + + move() + + setTwin(twin : BallThread) + } + abstract class GameItem { + - LOGGER : Logger {static} + + GameItem() + + click() {abstract} + + doDraw() {abstract} + + draw() + } +} +BallItem --|> GameItem +@enduml \ No newline at end of file diff --git a/typeobjectpattern/etc/typeobjectpattern.urm.puml b/typeobjectpattern/etc/typeobjectpattern.urm.puml new file mode 100644 index 000000000000..80a95b0b4a9a --- /dev/null +++ b/typeobjectpattern/etc/typeobjectpattern.urm.puml @@ -0,0 +1,72 @@ +@startuml +package com.iluwatar.typeobject { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Candy { + ~ name : String + ~ parent : Candy + ~ parentName : String + - points : int + - type : Type + ~ Candy(name : String, parentName : String, type : Type, points : int) + ~ getPoints() : int + ~ getType() : Type + ~ setPoints(a : int) + } + ~enum Type { + + crushableCandy {static} + + rewardFruit {static} + + valueOf(name : String) : Type {static} + + values() : Type[] {static} + } + class CandyGame { + - LOGGER : Logger {static} + ~ cells : Cell[][] + ~ pool : CellPool + ~ totalPoints : int + ~ CandyGame(num : int, pool : CellPool) + ~ adjacentCells(y : int, x : int) : List + ~ continueRound() : boolean + ~ handleChange(points : int) + ~ numOfSpaces(num : int) : String {static} + ~ printGameStatus() + ~ round(timeSoFar : int, totalTime : int) + } + class Cell { + ~ candy : Candy + ~ positionX : int + ~ positionY : int + ~ Cell() + ~ Cell(candy : Candy, positionX : int, positionY : int) + ~ crush(pool : CellPool, cellMatrix : Cell[][]) + ~ fillThisSpace(pool : CellPool, cellMatrix : Cell[][]) + ~ handleCrush(c : Cell, pool : CellPool, cellMatrix : Cell[][]) + ~ interact(c : Cell, pool : CellPool, cellMatrix : Cell[][]) : int + } + class CellPool { + - RANDOM : Random {static} + ~ pointer : int + ~ pool : List + ~ randomCode : Candy[] + ~ CellPool(num : int) + ~ addNewCell(c : Cell) + ~ assignRandomCandytypes() : Candy[] + ~ getNewCell() : Cell + } + class JsonParser { + ~ candies : Hashtable + ~ JsonParser() + ~ parse() + ~ setParentAndPoints() + } +} +Cell --> "-candy" Candy +Type ..+ Candy +Candy --> "-type" Type +Candy --> "-parent" Candy +CandyGame --> "-pool" CellPool +CellPool --> "-pool" Cell +@enduml \ No newline at end of file diff --git a/update-method/etc/update-method.urm.puml b/update-method/etc/update-method.urm.puml new file mode 100644 index 000000000000..53d2a6eb6a2e --- /dev/null +++ b/update-method/etc/update-method.urm.puml @@ -0,0 +1,51 @@ +@startuml +package com.iluwatar.updatemethod { + class App { + - GAME_RUNNING_TIME : int {static} + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + abstract class Entity { + # id : int + # logger : Logger + # position : int + + Entity(id : int) + + getPosition() : int + + setPosition(position : int) + + update() {abstract} + } + class Skeleton { + - PATROLLING_LEFT_BOUNDING : int {static} + - PATROLLING_RIGHT_BOUNDING : int {static} + # patrollingLeft : boolean + + Skeleton(id : int) + + Skeleton(id : int, postition : int) + + update() + } + class Statue { + # delay : int + # frames : int + + Statue(id : int) + + Statue(id : int, delay : int) + - shootLightning() + + update() + } + class World { + - LOGGER : Logger {static} + # entities : List + # isRunning : boolean + + World() + + addEntity(entity : Entity) + - gameLoop() + - processInput() + - render() + + run() + + stop() + - update() + } +} +World --> "-entities" Entity +Skeleton --|> Entity +Statue --|> Entity +@enduml \ No newline at end of file diff --git a/value-object/etc/value-object.urm.puml b/value-object/etc/value-object.urm.puml new file mode 100644 index 000000000000..6149ead9ba36 --- /dev/null +++ b/value-object/etc/value-object.urm.puml @@ -0,0 +1,22 @@ +@startuml +package com.iluwatar.value.object { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class HeroStat { + - intelligence : int + - luck : int + - strength : int + - HeroStat(strength : int, intelligence : int, luck : int) + + equals(obj : Object) : boolean + + getIntelligence() : int + + getLuck() : int + + getStrength() : int + + hashCode() : int + + toString() : String + + valueOf(strength : int, intelligence : int, luck : int) : HeroStat {static} + } +} +@enduml \ No newline at end of file diff --git a/visitor/etc/visitor.urm.puml b/visitor/etc/visitor.urm.puml new file mode 100644 index 000000000000..36a67b41514b --- /dev/null +++ b/visitor/etc/visitor.urm.puml @@ -0,0 +1,60 @@ +@startuml +package com.iluwatar.visitor { + class App { + + App() + + main(args : String[]) {static} + } + class Commander { + + Commander(children : Unit[]) + + accept(visitor : UnitVisitor) + + toString() : String + } + class CommanderVisitor { + - LOGGER : Logger {static} + + CommanderVisitor() + + visitCommander(commander : Commander) + + visitSergeant(sergeant : Sergeant) + + visitSoldier(soldier : Soldier) + } + class Sergeant { + + Sergeant(children : Unit[]) + + accept(visitor : UnitVisitor) + + toString() : String + } + class SergeantVisitor { + - LOGGER : Logger {static} + + SergeantVisitor() + + visitCommander(commander : Commander) + + visitSergeant(sergeant : Sergeant) + + visitSoldier(soldier : Soldier) + } + class Soldier { + + Soldier(children : Unit[]) + + accept(visitor : UnitVisitor) + + toString() : String + } + class SoldierVisitor { + - LOGGER : Logger {static} + + SoldierVisitor() + + visitCommander(commander : Commander) + + visitSergeant(sergeant : Sergeant) + + visitSoldier(soldier : Soldier) + } + abstract class Unit { + - children : Unit[] + + Unit(children : Unit[]) + + accept(visitor : UnitVisitor) + } + interface UnitVisitor { + + visitCommander(Commander) {abstract} + + visitSergeant(Sergeant) {abstract} + + visitSoldier(Soldier) {abstract} + } +} +Commander --|> Unit +CommanderVisitor ..|> UnitVisitor +Sergeant --|> Unit +SergeantVisitor ..|> UnitVisitor +Soldier --|> Unit +SoldierVisitor ..|> UnitVisitor +@enduml \ No newline at end of file From b09b10061465b00a708d6a24a22e0a99873792f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?= Date: Sat, 7 Dec 2019 20:01:13 +0200 Subject: [PATCH 2/3] #1113 Link uml-reverse-mapper created class diagrams to readme, where needed --- abstract-document/README.md | 3 ++- abstract-factory/README.md | 3 +++ abstract-factory/etc/abstract-factory.urm.png | Bin 0 -> 82368 bytes acyclic-visitor/README.md | 5 +++-- adapter/README.md | 3 +++ adapter/etc/adapter.urm.png | Bin 0 -> 25425 bytes aggregator-microservices/README.md | 2 ++ ambassador/README.md | 3 +++ ambassador/etc/ambassador.urm.png | Bin 0 -> 49248 bytes api-gateway/README.md | 1 + async-method-invocation/README.md | 1 + balking/README.md | 1 + bridge/README.md | 3 +++ bridge/etc/bridge.urm.png | Bin 0 -> 43639 bytes builder/README.md | 3 +++ builder/etc/builder.urm.png | Bin 0 -> 94868 bytes business-delegate/README.md | 1 + bytecode/README.md | 3 +++ bytecode/etc/bytecode.urm.png | Bin 0 -> 68283 bytes caching/README.md | 1 + callback/README.md | 1 + chain/README.md | 3 +++ chain/etc/chain.urm.png | Bin 0 -> 60093 bytes circuit-breaker/README.md | 2 ++ circuit-breaker/etc/circuit-breaker.urm.png | Bin 0 -> 44822 bytes collection-pipeline/README.md | 1 + combinator/README.md | 2 ++ combinator/etc/combinator.urm.png | Bin 0 -> 22657 bytes command/README.md | 1 + commander/README.md | 3 +++ commander/etc/commander.urm.png | Bin 0 -> 322274 bytes composite/README.md | 3 +++ composite/etc/composite.urm.png | Bin 0 -> 35715 bytes converter/README.md | 5 +++-- cqrs/README.md | 1 + dao/README.md | 1 + data-bus/README.md | 1 + data-locality/README.md | 2 ++ data-locality/etc/data-locality.urm.png | Bin 0 -> 68133 bytes data-mapper/README.md | 1 + data-transfer-object/README.md | 1 + decorator/README.md | 3 +++ decorator/etc/decorator.urm.png | Bin 0 -> 23530 bytes delegation/README.md | 1 + dependency-injection/README.md | 1 + dirty-flag/README.md | 1 + double-buffer/README.md | 5 ++++- double-buffer/etc/double-buffer.urm.png | Bin 0 -> 35073 bytes double-checked-locking/README.md | 1 + double-dispatch/README.md | 1 + eip-aggregator/README.md | 4 ++-- eip-message-channel/README.md | 1 + eip-publish-subscribe/README.md | 1 + eip-splitter/README.md | 2 +- eip-wire-tap/README.md | 1 + event-aggregator/README.md | 1 + event-asynchronous/README.md | 1 + event-driven-architecture/README.md | 1 + event-queue/README.md | 1 + event-sourcing/README.md | 1 + execute-around/README.md | 1 + extension-objects/README.md | 1 + facade/README.md | 3 +++ facade/etc/facade.urm.png | Bin 0 -> 62013 bytes factory-kit/README.md | 1 + factory-method/README.md | 3 +++ factory-method/etc/factory-method.urm.png | Bin 0 -> 53024 bytes feature-toggle/README.md | 3 ++- fluentinterface/README.md | 1 + flux/README.md | 1 + flyweight/README.md | 3 +++ flyweight/etc/flyweight.urm.png | Bin 0 -> 54844 bytes front-controller/README.md | 1 + game-loop/README.md | 4 +++- game-loop/etc/game-loop.urm.png | Bin 0 -> 57585 bytes guarded-suspension/README.md | 1 + half-sync-half-async/README.md | 1 + hexagonal/README.md | 1 + intercepting-filter/README.md | 5 ++--- interpreter/README.md | 1 + iterator/README.md | 1 + layers/README.md | 19 +++++++++--------- lazy-loading/README.md | 1 + leader-election/README.md | 3 +++ leader-election/etc/leader-election.urm.png | Bin 0 -> 173701 bytes marker/README.md | 1 + master-worker-pattern/README.md | 3 +++ .../etc/master-worker-pattern.urm.png | Bin 0 -> 103285 bytes mediator/README.md | 1 + memento/README.md | 1 + model-view-controller/README.md | 1 + model-view-presenter/README.md | 1 + module/README.md | 1 + monad/README.md | 3 ++- monostate/README.md | 1 + multiton/README.md | 1 + mute-idiom/README.md | 2 +- mutex/README.md | 1 + naked-objects/README.md | 1 + null-object/README.md | 1 + object-mother/README.md | 1 + object-pool/README.md | 1 + observer/README.md | 1 + page-object/README.md | 2 +- partial-response/README.md | 1 + pipeline/README.md | 5 ++++- pipeline/etc/pipeline.urm.png | Bin 0 -> 31882 bytes poison-pill/README.md | 1 + priority-queue/README.md | 3 +++ priority-queue/etc/priority-queue.urm.png | Bin 0 -> 52777 bytes private-class-data/README.md | 1 + producer-consumer/README.md | 1 + promise/README.md | 1 + property/README.md | 1 + prototype/README.md | 3 +++ prototype/etc/prototype.urm.png | Bin 0 -> 81144 bytes proxy/README.md | 3 +++ proxy/etc/proxy.urm.png | Bin 0 -> 28797 bytes queue-load-leveling/README.md | 2 +- reactor/README.md | 1 + reader-writer-lock/README.md | 9 +++++---- repository/README.md | 3 ++- .../README.md | 1 + retry/README.md | 5 +++-- role-object/README.md | 3 +++ role-object/etc/role-object.urm.png | Bin 0 -> 64455 bytes saga/README.md | 3 +++ saga/etc/saga.urm.png | Bin 0 -> 273181 bytes semaphore/README.md | 1 + servant/README.md | 1 + serverless/README.md | 3 +++ serverless/etc/serverless.urm.png | Bin 0 -> 219522 bytes service-layer/README.md | 1 + service-locator/README.md | 1 + sharding/README.md | 5 ++++- sharding/etc/sharding.urm.png | Bin 0 -> 63822 bytes singleton/README.md | 3 +++ singleton/etc/singleton.urm.png | Bin 0 -> 46739 bytes spatial-partition/README.md | 14 +++++++------ .../etc/spatial-partition.urm.png | Bin 0 -> 102875 bytes specification/README.md | 17 ++++++++-------- state/README.md | 1 + step-builder/README.md | 1 + strategy/README.md | 1 + subclass-sandbox/README.md | 3 +++ subclass-sandbox/etc/subclass-sandbox.urm.png | Bin 0 -> 22259 bytes template-method/README.md | 1 + thread-pool/README.md | 1 + throttling/README.md | 3 +++ tls/README.md | 1 + tolerant-reader/README.md | 1 + trampoline/README.md | 5 ++--- trampoline/etc/trampoline.urm.png | Bin 0 -> 15316 bytes twin/README.md | 1 + typeobjectpattern/README.md | 13 +++++++----- .../etc/typeobjectpattern.urm.png | Bin 0 -> 67712 bytes unit-of-work/README.md | 1 + update-method/README.md | 15 ++++++++------ update-method/etc/update-method.urm.png | Bin 0 -> 39843 bytes value-object/README.md | 1 + visitor/README.md | 1 + 161 files changed, 246 insertions(+), 64 deletions(-) create mode 100644 abstract-factory/etc/abstract-factory.urm.png create mode 100644 adapter/etc/adapter.urm.png create mode 100644 ambassador/etc/ambassador.urm.png create mode 100644 bridge/etc/bridge.urm.png create mode 100644 builder/etc/builder.urm.png create mode 100644 bytecode/etc/bytecode.urm.png create mode 100644 chain/etc/chain.urm.png create mode 100644 circuit-breaker/etc/circuit-breaker.urm.png create mode 100644 combinator/etc/combinator.urm.png create mode 100644 commander/etc/commander.urm.png create mode 100644 composite/etc/composite.urm.png create mode 100644 data-locality/etc/data-locality.urm.png create mode 100644 decorator/etc/decorator.urm.png create mode 100644 double-buffer/etc/double-buffer.urm.png create mode 100644 facade/etc/facade.urm.png create mode 100644 factory-method/etc/factory-method.urm.png create mode 100644 flyweight/etc/flyweight.urm.png create mode 100644 game-loop/etc/game-loop.urm.png create mode 100644 leader-election/etc/leader-election.urm.png create mode 100644 master-worker-pattern/etc/master-worker-pattern.urm.png create mode 100644 pipeline/etc/pipeline.urm.png create mode 100644 priority-queue/etc/priority-queue.urm.png create mode 100644 prototype/etc/prototype.urm.png create mode 100644 proxy/etc/proxy.urm.png create mode 100644 role-object/etc/role-object.urm.png create mode 100644 saga/etc/saga.urm.png create mode 100644 serverless/etc/serverless.urm.png create mode 100644 sharding/etc/sharding.urm.png create mode 100644 singleton/etc/singleton.urm.png create mode 100644 spatial-partition/etc/spatial-partition.urm.png create mode 100644 subclass-sandbox/etc/subclass-sandbox.urm.png create mode 100644 trampoline/etc/trampoline.urm.png create mode 100644 typeobjectpattern/etc/typeobjectpattern.urm.png create mode 100644 update-method/etc/update-method.urm.png diff --git a/abstract-document/README.md b/abstract-document/README.md index 2adb3732b822..e9a2bed94fd8 100644 --- a/abstract-document/README.md +++ b/abstract-document/README.md @@ -12,6 +12,7 @@ tags: ## Intent Achieve flexibility of untyped languages and keep the type-safety +## Class diagram ![alt text](./etc/abstract-document.png "Abstract Document Traits and Domain") @@ -26,4 +27,4 @@ Use the Abstract Document Pattern when ## Credits * [Wikipedia: Abstract Document Pattern](https://en.wikipedia.org/wiki/Abstract_Document_Pattern) -* [Martin Fowler: Dealing with properties](http://martinfowler.com/apsupp/properties.pdf) \ No newline at end of file +* [Martin Fowler: Dealing with properties](http://martinfowler.com/apsupp/properties.pdf) diff --git a/abstract-factory/README.md b/abstract-factory/README.md index f6719af45ad6..a4fc5cc746da 100644 --- a/abstract-factory/README.md +++ b/abstract-factory/README.md @@ -157,6 +157,9 @@ public static void main(String[] args) { } ``` +## Class diagram +![alt text](./etc/abstract-factory.urm.png "Abstract Factory class diagram") + ## Applicability Use the Abstract Factory pattern when diff --git a/abstract-factory/etc/abstract-factory.urm.png b/abstract-factory/etc/abstract-factory.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..836858a2c652f55723cff879d1058248e1d2799c GIT binary patch literal 82368 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 MUHx3vIVCg!0PQSJ00000 literal 0 HcmV?d00001 diff --git a/acyclic-visitor/README.md b/acyclic-visitor/README.md index 83b618601fb2..d855cfd73659 100644 --- a/acyclic-visitor/README.md +++ b/acyclic-visitor/README.md @@ -9,11 +9,12 @@ tags: - Difficulty-Intermediate --- -![alt text](./etc/acyclic-visitor.png "Acyclic Visitor") - ## Intent Allow new functions to be added to existing class hierarchies without affecting those hierarchies, and without creating the troublesome dependency cycles that are inherent to the GOF VISITOR Pattern. +## Class diagram +![alt text](./etc/acyclic-visitor.png "Acyclic Visitor") + ## Applicability This pattern can be used: * When you need to add a new function to an existing hierarchy without the need to alter or affect that hierarchy. diff --git a/adapter/README.md b/adapter/README.md index 0076e962c36c..b1ad775cf3e3 100644 --- a/adapter/README.md +++ b/adapter/README.md @@ -97,6 +97,9 @@ var captain = new Captain(new FishingBoatAdapter()); captain.row(); ``` +## Class diagram +![alt text](./etc/adapter.urm.png "Adapter class diagram") + ## Applicability Use the Adapter pattern when diff --git a/adapter/etc/adapter.urm.png b/adapter/etc/adapter.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..341ad67699d9d965433e169c91793e9fd164beb5 GIT binary patch literal 25425 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 A%m4rY literal 0 HcmV?d00001 diff --git a/aggregator-microservices/README.md b/aggregator-microservices/README.md index e65f26d9a38a..c3498d315ab0 100644 --- a/aggregator-microservices/README.md +++ b/aggregator-microservices/README.md @@ -18,6 +18,8 @@ More variations of the aggregator are: - Chained Microservice Design Pattern: In this case each microservice is dependent/ chained to a series of other microservices. +## Class diagram + ![alt text](./etc/aggregator-microservice.png "Aggregator Microservice") ## Applicability diff --git a/ambassador/README.md b/ambassador/README.md index 2d3edeafa0fd..862c579a0ec9 100644 --- a/ambassador/README.md +++ b/ambassador/README.md @@ -150,6 +150,9 @@ public class App { } ``` +## Class diagram +![alt text](./etc/ambassador.urm.png "Ambassador class diagram") + ## Applicability Ambassador is applicable when working with a legacy remote service that cannot be modified or would be extremely difficult to modify. Connectivity features can diff --git a/ambassador/etc/ambassador.urm.png b/ambassador/etc/ambassador.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..9b50a02ad356106d5bde0979fcef0bbcafabb1f0 GIT binary patch literal 49248 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 Ae*gdg literal 0 HcmV?d00001 diff --git a/builder/README.md b/builder/README.md index a061f8afaf2d..c6190ef17a97 100644 --- a/builder/README.md +++ b/builder/README.md @@ -113,6 +113,9 @@ And then it can be used as: var mage = new Hero.Builder(Profession.MAGE, "Riobard").withHairColor(HairColor.BLACK).withWeapon(Weapon.DAGGER).build(); ``` +## Class diagram +![alt text](./etc/builder.urm.png "Builder class diagram") + ## Applicability Use the Builder pattern when diff --git a/builder/etc/builder.urm.png b/builder/etc/builder.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..d77808d36097165cace8b972de6a97d260f70cc5 GIT binary patch literal 94868 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
D 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 E9~Pz?ng9R* literal 0 HcmV?d00001 diff --git a/business-delegate/README.md b/business-delegate/README.md index e6e2491222e0..5debebbbad9f 100644 --- a/business-delegate/README.md +++ b/business-delegate/README.md @@ -15,6 +15,7 @@ presentation and business tiers. By using the pattern we gain loose coupling between the tiers and encapsulate knowledge about how to locate, connect to, and interact with the business objects that make up the application. +## Class diagram ![alt text](./etc/business-delegate.png "Business Delegate") ## Applicability diff --git a/bytecode/README.md b/bytecode/README.md index d2fc45e1e2d1..13d8013d6d24 100644 --- a/bytecode/README.md +++ b/bytecode/README.md @@ -12,6 +12,9 @@ tags: ## Intent Allows to encode behaviour as instructions for virtual machine. +## Class diagram +![alt text](./etc/bytecode.urm.png "Bytecode class diagram") + ## Applicability Use the Bytecode pattern when you have a lot of behavior you need to define and your game’s implementation language isn’t a good fit because: diff --git a/bytecode/etc/bytecode.urm.png b/bytecode/etc/bytecode.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..82036a78a9b1f87bc89556c63fa401ab3a9d99a6 GIT binary patch literal 68283 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 g$fF{EFHsd8txc~lF|(V0#YK~V9=?6q% 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 L^>bP0l+XkKhV(}E literal 0 HcmV?d00001 diff --git a/circuit-breaker/README.md b/circuit-breaker/README.md index 6a1c631c7cf7..8e840ce1efb3 100644 --- a/circuit-breaker/README.md +++ b/circuit-breaker/README.md @@ -165,6 +165,8 @@ How does the above pattern prevent failures? Let's understand via this finite st - If the number of failures cross a certain threshold, we move to the **open** state, which acts just like an open circuit and prevents remote service calls from being made, thus saving resources. (Here, we return the response called ```stale response from API```) - Once we exceed the retry timeout period, we move to the **half-open** state and make another call to the remote service again to check if the service is working so that we can serve fresh content. A *failure* sets it back to **open** state and another attempt is made after retry timeout period, while a *success* sets it to **closed** state so that everything starts working normally again. +## Class diagram +![alt text](./etc/circuit-breaker.urm.png "Circuit Breaker class diagram") ## Applicability Use the Circuit Breaker pattern when diff --git a/circuit-breaker/etc/circuit-breaker.urm.png b/circuit-breaker/etc/circuit-breaker.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..9278ce216665a5088e3f9b90ad310087e0dd9108 GIT binary patch literal 44822 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 literal 0 HcmV?d00001 diff --git a/collection-pipeline/README.md b/collection-pipeline/README.md index 9d2f2693b910..3f223dd07c65 100644 --- a/collection-pipeline/README.md +++ b/collection-pipeline/README.md @@ -14,6 +14,7 @@ tags: Collection Pipeline introduces Function Composition and Collection Pipeline, two functional-style patterns that you can combine to iterate collections in your code. In functional programming, it's common to sequence complex operations through a series of smaller modular functions or operations. The series is called a composition of functions, or a function composition. When a collection of data flows through a function composition, it becomes a collection pipeline. Function Composition and Collection Pipeline are two design patterns frequently used in functional-style programming. +## Class diagram ![alt text](./etc/collection-pipeline.png "Collection Pipeline") ## Applicability diff --git a/combinator/README.md b/combinator/README.md index e2245032121e..98d353050dbf 100644 --- a/combinator/README.md +++ b/combinator/README.md @@ -18,6 +18,8 @@ The functional pattern representing a style of organizing libraries centered aro Putting it simply, there is some type T, some functions for constructing "primitive" values of type T, and some "combinators" which can combine values of type T in various ways to build up more complex values of type T. +## Class diagram +![alt text](./etc/combinator.urm.png "Combinator class diagram") ## Applicability Use the combinator pattern when: diff --git a/combinator/etc/combinator.urm.png b/combinator/etc/combinator.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..80fdd36340bbacbbfd19ed0a4aa70c259b53c397 GIT binary patch literal 22657 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 Used to handle all problems that can be encountered when doing distributed transactions. +## Class diagram +![alt text](./etc/commander.urm.png "Commander class diagram") + ## Applicability This pattern can be used when we need to make commits into 2 (or more) databases to complete transaction, which cannot be done atomically and can thereby create problems. diff --git a/commander/etc/commander.urm.png b/commander/etc/commander.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..6b5ebba75bd64a971924f4a3f8a2a89b7df905d7 GIT binary patch literal 322274 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

vrI-9HR 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