diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 46ba288..c3e2423 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -22,7 +22,7 @@ List relations = new ArrayList<>(); // Relation transferRelation = new Relation(company, customer, MultiplicityValue.OneToOne); Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToMany); - DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PULL); + DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PUSH); DataTransferDesign design; try { @@ -36,7 +36,7 @@ design.addDependencyInversion(di); - System.out.println(ASTGenerator.generate(Observer.create())); + System.out.println(ASTGenerator.generate(Prototype.create())); // System.out.println(ASTGenerator.generate(design)); } catch (IllegalRelationException e) { e.printStackTrace(); diff --git a/src/main/java/designPatternExtensions/AbstractFactory.java b/src/main/java/designPatternExtensions/AbstractFactory.java new file mode 100644 index 0000000..1ed3ef5 --- /dev/null +++ b/src/main/java/designPatternExtensions/AbstractFactory.java @@ -0,0 +1,33 @@ +package designPatternExtensions; +import models.objectOrientedTransfer.*; +import java.util.ArrayList; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/abstract-factory + +public class AbstractFactory { + + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode elfCastle = new ObjectNode("ElfCastle"); + ObjectNode app = new ObjectNode("App"); + ObjectNode data = new ObjectNode("String"); + + Relation transferRelation = new Relation(elfCastle, app, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, data, "description", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + ObjectNode elfKingdomFactory = new ObjectNode("ElfKingdomFactory"); + MediatorInsertion mi = new MediatorInsertion(app, elfCastle, elfKingdomFactory); + design.addMediatorInsertion(mi); + + DependencyInversion di = new DependencyInversion( + elfKingdomFactory, new InterfaceNode(elfKingdomFactory, "KingdomFactory"), app + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Bridge.java b/src/main/java/designPatternExtensions/Bridge.java index 4222324..16ec812 100644 --- a/src/main/java/designPatternExtensions/Bridge.java +++ b/src/main/java/designPatternExtensions/Bridge.java @@ -3,28 +3,24 @@ import models.objectOrientedTransfer.*; import java.util.ArrayList; -import java.util.List; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/bridge public class Bridge { public static DataTransferDesign create() throws IllegalRelationException { - ObjectNode main = new ObjectNode("Main"); ObjectNode sword = new ObjectNode("Sword"); ObjectNode soulEatingEnchantment = new ObjectNode("SoulEatingEnchantment"); ObjectNode data = new ObjectNode("String"); - List srcEdges = new ArrayList<>(); - List dstEdges = new ArrayList<>(); - srcEdges.add(new ReferenceEdge(main, soulEatingEnchantment, "soulEatingEnchantment", "String")); - dstEdges.add(new ReferenceEdge(main, sword, "sword", "String")); - - List relations = new ArrayList<>(); - Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); - DataTransferContext context = new DataTransferContext(relations, transferRelation, data, "data", PushPullValue.PULL); + Relation transferRelation = new Relation(sword, soulEatingEnchantment, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, data, "data", PushPullValue.PUSH); DataTransferDesign design = new DataTransferDesign(context); - DependencyInversion di1 = new DependencyInversion(sword, new InterfaceNode(sword, "Weapon"), main); + DependencyInversion di1 = new DependencyInversion(sword, new InterfaceNode(sword, "Weapon")); design.addDependencyInversion(di1); DependencyInversion di2 = new DependencyInversion(soulEatingEnchantment, new InterfaceNode(soulEatingEnchantment, "Enchantment"), sword); diff --git a/src/main/java/designPatternExtensions/Builder.java b/src/main/java/designPatternExtensions/Builder.java new file mode 100644 index 0000000..21ba392 --- /dev/null +++ b/src/main/java/designPatternExtensions/Builder.java @@ -0,0 +1,24 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/builder +//メソッドチェーンがない + +public class Builder { + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode client = new ObjectNode("Client"); + ObjectNode builder = new ObjectNode("Builder"); + ObjectNode data = new ObjectNode("HairColor"); + + Relation transferRelation = new Relation(client, builder, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, data, "hairColor", PushPullValue.PUSH + ); + + return new DataTransferDesign(context); + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Command.java b/src/main/java/designPatternExtensions/Command.java new file mode 100644 index 0000000..420fed3 --- /dev/null +++ b/src/main/java/designPatternExtensions/Command.java @@ -0,0 +1,40 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; +import java.util.ArrayList; +import java.util.List; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/command + +public class Command { + + public static DataTransferDesign create() throws IllegalRelationException { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode main = new ObjectNode("Main"); + ObjectNode wizard = new ObjectNode("Wizard"); + ObjectNode spell = new ObjectNode("ChangeSizeSpell"); + ObjectNode data = new ObjectNode("Goblin"); + + srcEdges.add(new ReferenceEdge(main, wizard, "wizard")); + dstEdges.add(new ReferenceEdge(main, spell, "spell", "Integer")); + + List relations = new ArrayList<>(); + relations.add(new Relation(main, dstEdges, MultiplicityValue.OneToOne)); + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); + + DataTransferContext context = new DataTransferContext( + relations, transferRelation, data, "goblin", PushPullValue.PUSH + ); + + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion( + spell, new InterfaceNode(spell, "Runnable"), wizard + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Decorator.java b/src/main/java/designPatternExtensions/Decorator.java new file mode 100644 index 0000000..0bf3920 --- /dev/null +++ b/src/main/java/designPatternExtensions/Decorator.java @@ -0,0 +1,34 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +//https://github.com/iluwatar/java-design-patterns/tree/master/decorator +// + +public class Decorator { + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode simpleTroll = new ObjectNode("SimpleTroll"); + ObjectNode client = new ObjectNode("Client"); + ObjectNode data = new ObjectNode("Int"); + + Relation transferRelation = new Relation(simpleTroll, client, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new java.util.ArrayList<>(), transferRelation, data, "attackPower", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + ObjectNode clubbedTroll = new ObjectNode("ClubbedTroll"); + MediatorInsertion mi = new MediatorInsertion(client, simpleTroll, clubbedTroll); + design.addMediatorInsertion(mi); + + InterfaceNode troll = new InterfaceNode(clubbedTroll, "Troll"); + DependencyInversion di1 = new DependencyInversion(clubbedTroll, troll, client); + design.addDependencyInversion(di1); + + DependencyInversion di2 = new DependencyInversion(simpleTroll, troll); + design.addDependencyInversion(di2); + + return design; + } +} diff --git a/src/main/java/designPatternExtensions/DesignPatternMemo b/src/main/java/designPatternExtensions/DesignPatternMemo new file mode 100644 index 0000000..ee3fae6 --- /dev/null +++ b/src/main/java/designPatternExtensions/DesignPatternMemo @@ -0,0 +1,25 @@ +AbstractFactory　〇？ +Builder　？ +FactoryMethod +Prototype ？ +Singleton　？ + +Adapter　〇 完璧に再現できている +Bridge　〇？ +Composite +Decorator　〇？ +Facade +Flyweight +Proxy　〇？ + +ChainOfResponsibility +Command　？ +Interpreter +Iterator　？ +Mediator +Memento　△ 複数のデータ転送をまとめて扱えるようにしないとできない +Observer　× OneToManyが必要 +State　？ +Strategy　〇 同じ役割の実装クラスを複数用意できないが無視する +TemplateMethod ？ +Visitor　× 制御の委譲をできるようにする必要がある & OneToManyが必要 \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Iterator.java b/src/main/java/designPatternExtensions/Iterator.java new file mode 100644 index 0000000..916c864 --- /dev/null +++ b/src/main/java/designPatternExtensions/Iterator.java @@ -0,0 +1,36 @@ +package designPatternExtensions; +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; +//メモ +//中身の構造を隠したまま、順番にデータを取り出す +//アイテムのタイプをifで回さなくても +//https://github.com/iluwatar/java-design-patterns/tree/master/iterator + + +public class Iterator { + + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode treasureChest = new ObjectNode("TreasureChest"); + ObjectNode client = new ObjectNode("Client"); + ObjectNode item = new ObjectNode("Item"); + + Relation transferRelation = new Relation(treasureChest, client, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, item, "item", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + ObjectNode iterator = new ObjectNode("TreasureChestItemIterator"); + MediatorInsertion mi = new MediatorInsertion(client, treasureChest, iterator); + design.addMediatorInsertion(mi); + + DependencyInversion di = new DependencyInversion( + iterator, new InterfaceNode(iterator, "Iterator"), client + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Memento.java b/src/main/java/designPatternExtensions/Memento.java new file mode 100644 index 0000000..6700507 --- /dev/null +++ b/src/main/java/designPatternExtensions/Memento.java @@ -0,0 +1,33 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; + +//https://github.com/iluwatar/java-design-patterns/tree/master/memento +//複数のデータ転送をまとめて扱えるようにしないとできない　→　一方向でもできればいったんOK + +public class Memento { + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode star = new ObjectNode("Star"); + ObjectNode states = new ObjectNode("States"); + ObjectNode starMementoInternal = new ObjectNode("StarMementoInternal"); + + Relation transferRelation = new Relation(star, states, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, starMementoInternal, "memento", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + MediatorInsertion client = new MediatorInsertion(star, states, new ObjectNode("Client")); + design.addMediatorInsertion(client); + + DependencyInversion di = new DependencyInversion( + starMementoInternal, new InterfaceNode(starMementoInternal, "StarMemento"), states + ); + design.addDependencyInversion(di); + + return design; + } +} diff --git a/src/main/java/designPatternExtensions/Observer.java b/src/main/java/designPatternExtensions/Observer.java index 31595c2..6d8ceed 100644 --- a/src/main/java/designPatternExtensions/Observer.java +++ b/src/main/java/designPatternExtensions/Observer.java @@ -1,8 +1,9 @@ package designPatternExtensions; import models.objectOrientedTransfer.*; import java.util.ArrayList; +import java.util.List; -//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/observer //依存性の逆転構造は再現できているが、OneToManyが使えないから再現できない？ //　SubjectがObserverを記憶し（ManyToOne?PULL?）→DesignCraftが最初に登録してるものとする //　Clientから更新されたときに、Observerに通知する（OneToMany?PUSH？）→これが正解 @@ -29,4 +30,27 @@ return design; } -} \ No newline at end of file +} + +//public class Observer { +// public static DataTransferDesign create() throws IllegalRelationException { +// ObjectNode weather = new ObjectNode("Weather"); +// ObjectNode orcs = new ObjectNode("Orcs"); +// ObjectNode hobbits = new ObjectNode("Hobbits"); +// ObjectNode data = new ObjectNode("WeatherType"); +// +// Relation transferRelation = new Relation(weather, orcs, MultiplicityValue.OneToOne); +// DataTransferContext context = new DataTransferContext( +// new ArrayList<>(), transferRelation, data, "currentWeather", PushPullValue.PUSH +// ); +// +// DataTransferDesign design = new DataTransferDesign(context); +// +// DependencyInversion di1 = new DependencyInversion(orcs, new InterfaceNode(orcs, "WeatherObserver"), weather); +// DependencyInversion di2 = new DependencyInversion(hobbits, new InterfaceNode(hobbits, "WeatherObserver"), weather); +// design.addDependencyInversion(di1); +// design.addDependencyInversion(di2); +// +// return design; +// } +//} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Prototype.java b/src/main/java/designPatternExtensions/Prototype.java new file mode 100644 index 0000000..e3ac7c9 --- /dev/null +++ b/src/main/java/designPatternExtensions/Prototype.java @@ -0,0 +1,30 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/prototype + +public class Prototype { + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode heroFactoryImpl = new ObjectNode("HeroFactoryImpl"); + ObjectNode client = new ObjectNode("Client"); + ObjectNode beast = new ObjectNode("Beast"); + + Relation transferRelation = new Relation(heroFactoryImpl, client, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, beast, "beast", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion( + heroFactoryImpl, new InterfaceNode(heroFactoryImpl, "HeroFactory"), client + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Proxy.java b/src/main/java/designPatternExtensions/Proxy.java new file mode 100644 index 0000000..8dc3243 --- /dev/null +++ b/src/main/java/designPatternExtensions/Proxy.java @@ -0,0 +1,34 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +//https://github.com/iluwatar/java-design-patterns/tree/master/proxy +//WizardTowerProxyで行っている人数制御がない + +public class Proxy { + + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode ivoryTower = new ObjectNode("IvoryTower"); + ObjectNode client = new ObjectNode("Client"); + ObjectNode data = new ObjectNode("Wizard"); + + Relation transferRelation = new Relation(client, ivoryTower, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new java.util.ArrayList<>(), transferRelation, data, "wizard", PushPullValue.PUSH + ); + + DataTransferDesign design = new DataTransferDesign(context); + + ObjectNode proxy = new ObjectNode("WizardTowerProxy"); + MediatorInsertion mi = new MediatorInsertion(client, ivoryTower, proxy); + design.addMediatorInsertion(mi); + + InterfaceNode wizardTower = new InterfaceNode(proxy, "WizardTower"); + DependencyInversion di = new DependencyInversion(proxy, wizardTower, client); + design.addDependencyInversion(di); + DependencyInversion di2 = new DependencyInversion(ivoryTower, wizardTower); + design.addDependencyInversion(di2); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Singleton.java b/src/main/java/designPatternExtensions/Singleton.java new file mode 100644 index 0000000..83b43a9 --- /dev/null +++ b/src/main/java/designPatternExtensions/Singleton.java @@ -0,0 +1,23 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/singleton + +public class Singleton { + public static DataTransferDesign create() throws IllegalRelationException { + ObjectNode client = new ObjectNode("Client"); + ObjectNode enumIvoryTower = new ObjectNode("EnumIvoryTower"); + ObjectNode data = new ObjectNode("data"); + + Relation transferRelation = new Relation(enumIvoryTower, client, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, data, "data", PushPullValue.PULL + ); + + return new DataTransferDesign(context); + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/State.java b/src/main/java/designPatternExtensions/State.java new file mode 100644 index 0000000..b1290a6 --- /dev/null +++ b/src/main/java/designPatternExtensions/State.java @@ -0,0 +1,37 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; +import java.util.List; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/state + +public class State { + + public static DataTransferDesign create() throws IllegalRelationException { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode main = new ObjectNode("Main"); + ObjectNode mammoth = new ObjectNode("Mammoth"); + ObjectNode state = new ObjectNode("PeacefulState"); + ObjectNode data = new ObjectNode("data"); + srcEdges.add(new ReferenceEdge(main, mammoth, "mammoth")); + dstEdges.add(new ReferenceEdge(main, state, "state", "Integer")); + + List relations = new ArrayList<>(); + relations.add(new Relation(main, dstEdges, MultiplicityValue.OneToOne)); + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); + + DataTransferContext context = new DataTransferContext( + relations, transferRelation, data, "data", PushPullValue.PUSH); + + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion(state, new InterfaceNode(state, "State"), mammoth); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Strategy.java b/src/main/java/designPatternExtensions/Strategy.java new file mode 100644 index 0000000..b58a238 --- /dev/null +++ b/src/main/java/designPatternExtensions/Strategy.java @@ -0,0 +1,36 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; +import java.util.List; + +//https://github.com/iluwatar/java-design-patterns/tree/master/strategy +//同じ役割の実装クラスを複数用意できない（メソッドが空になる？） + +public class Strategy { + + public static DataTransferDesign create() throws IllegalRelationException { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode main = new ObjectNode("Main"); + ObjectNode dragonSlayer = new ObjectNode("DragonSlayer"); + ObjectNode meleeStrategy = new ObjectNode("MeleeStrategy"); + ObjectNode data = new ObjectNode("BattleExecute"); + srcEdges.add(new ReferenceEdge(main, dragonSlayer, "dragonSlayer")); + dstEdges.add(new ReferenceEdge(main, meleeStrategy, "meleeStrategy", "Integer")); + List relations = new ArrayList<>(); + relations.add(new Relation(main, dstEdges, MultiplicityValue.OneToOne)); + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext(relations, transferRelation, data, "battleExecute", PushPullValue.PUSH); + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion( + meleeStrategy, new InterfaceNode(meleeStrategy, "DragonSlayingStrategy"), dragonSlayer + ); + design.addDependencyInversion(di); + + return design; + } + +} diff --git a/src/main/java/designPatternExtensions/TemplateMethod.java b/src/main/java/designPatternExtensions/TemplateMethod.java new file mode 100644 index 0000000..941d974 --- /dev/null +++ b/src/main/java/designPatternExtensions/TemplateMethod.java @@ -0,0 +1,41 @@ +package designPatternExtensions; + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; +import java.util.List; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/template-method + +public class TemplateMethod { + + public static DataTransferDesign create() throws IllegalRelationException { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode main = new ObjectNode("Main"); + ObjectNode halflingThief = new ObjectNode("HalflingThief"); + ObjectNode subtleMethod = new ObjectNode("SubtleMethod"); + ObjectNode data = new ObjectNode("data"); + + srcEdges.add(new ReferenceEdge(main, halflingThief, "halflingThief")); + dstEdges.add(new ReferenceEdge(main, subtleMethod, "method", "Integer")); + + List relations = new ArrayList<>(); + relations.add(new Relation(main, dstEdges, MultiplicityValue.OneToOne)); + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); + + DataTransferContext context = new DataTransferContext( + relations, transferRelation, data, "data", PushPullValue.PUSH + ); + + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion( + subtleMethod, new InterfaceNode(subtleMethod, "StealingMethod"), halflingThief + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/designPatternExtensions/Visitor.java b/src/main/java/designPatternExtensions/Visitor.java new file mode 100644 index 0000000..58a2e97 --- /dev/null +++ b/src/main/java/designPatternExtensions/Visitor.java @@ -0,0 +1,46 @@ +package designPatternExtensions; + +//メモ +//https://github.com/iluwatar/java-design-patterns/tree/master/visitor +//Commander->Sergent(Children) 1:多の転送ができないため不可能 +//制御の委譲をできるようにする必要がある（自分の作業） + +import models.objectOrientedTransfer.*; + +import java.util.ArrayList; +import java.util.List; + +public class Visitor { + + public static DataTransferDesign create() throws IllegalRelationException { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode commander = new ObjectNode("Commander"); + ObjectNode sergent = new ObjectNode("Sergent"); + ObjectNode soldier = new ObjectNode("Soldier"); + ObjectNode client = new ObjectNode("Client"); + ObjectNode main = new ObjectNode("Main"); + ObjectNode visitor = new ObjectNode("SoldierVisitor"); + + ReferenceEdge srcEdge = new ReferenceEdge(commander, sergent, "children", "Integer"); + srcEdges.add(srcEdge); + srcEdge = new ReferenceEdge(sergent, soldier, "children", "Integer"); + srcEdges.add(srcEdge); + ReferenceEdge dstEdge = new ReferenceEdge(main, client, "client"); + dstEdges.add(dstEdge); + + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToOne); + DataTransferContext context = new DataTransferContext( + new ArrayList<>(), transferRelation, visitor, "visitor", PushPullValue.PULL + ); + + DataTransferDesign design = new DataTransferDesign(context); + + DependencyInversion di = new DependencyInversion( + visitor, new InterfaceNode(visitor, "UnitVisitor"), commander + ); + design.addDependencyInversion(di); + + return design; + } +} \ No newline at end of file diff --git a/src/main/java/generators/ASTGenerator.java b/src/main/java/generators/ASTGenerator.java index 2eabbb0..b6024fd 100644 --- a/src/main/java/generators/ASTGenerator.java +++ b/src/main/java/generators/ASTGenerator.java @@ -382,7 +382,11 @@ TypeDeclaration dstClass = createClass(codebase, dstName); for (MethodDeclaration method: dstClass.getMethods()) { if (!method.isConstructor()) { - interfaceDeclaration.addMethod(method); + boolean alreadyExists = interfaceDeclaration.getMethods().stream() + .anyMatch(m -> m.getName().equals(method.getName())); + if (!alreadyExists) { + interfaceDeclaration.addMethod(method); + } } } diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java index 78a624d..f23b9fa 100644 --- a/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java +++ b/src/main/java/models/objectOrientedTransfer/DataTransferDesign.java @@ -129,7 +129,7 @@ newSrcResource = relation.getDstResource(); newDstResource = relation.getSrcResource(); } - if (dstResource.size() < newDstResource.size()) { + if (dstResource.size() < newDstResource.size() || srcResource.size() < newSrcResource.size()) { List oneDestination = new ArrayList<>(); List manyDestinations = new ArrayList<>(); for (int i = 0; i < newDstResource.size(); i++) { diff --git a/src/main/java/models/objectOrientedTransfer/Relation.java b/src/main/java/models/objectOrientedTransfer/Relation.java index a2388ed..daf3589 100644 --- a/src/main/java/models/objectOrientedTransfer/Relation.java +++ b/src/main/java/models/objectOrientedTransfer/Relation.java @@ -26,7 +26,24 @@ this.dstResourceNode = dstResourceNode; this.multiplicity = multiplicity; } - + + public Relation(ObjectNode srcResourceNode, List dstResource, MultiplicityValue multiplicity) { + isFlat = false; + this.srcResource = new ArrayList<>(); + this.dstResource = dstResource; + this.srcResourceNode = srcResourceNode; + this.multiplicity = multiplicity; + } + + public Relation(List srcResource, ObjectNode dstResourceNode, MultiplicityValue multiplicity) { + isFlat = false; + this.srcResource = srcResource; + this.dstResource = new ArrayList<>(); + this.dstResourceNode = dstResourceNode; + this.multiplicity = multiplicity; + } + + public boolean isFlat() { return isFlat; }