abstract duck factory realization

Author: eaidova

Factory/.gitignore

@@ -0,0 +1,73 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+
+

Factory/Factory.pro

@@ -0,0 +1,11 @@
+TEMPLATE = app
+CONFIG += console c++11
+CONFIG -= app_bundle
+CONFIG -= qt
+
+SOURCES += main.cpp \
+    pizza.cpp
+
+HEADERS += \
+    pizza.h
+

Factory/main.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    cout << "Hello World!" << endl;
+    return 0;
+}
+

Factory/pizza.cpp

@@ -0,0 +1,7 @@
+#include "pizza.h"
+
+Pizza::Pizza()
+{
+
+}
+

Factory/pizza.h

@@ -0,0 +1,11 @@
+#ifndef PIZZA_H
+#define PIZZA_H
+
+
+class Pizza
+{
+public:
+    Pizza();
+};
+
+#endif // PIZZA_H

Strategy/Strategy.pro

@@ -11,8 +11,12 @@ SOURCES += main.cpp \
     realduck.cpp \
     rubberduck.cpp \
     woodenduck.cpp \
+    decorativeduck.cpp \
+    abstractduckfactory.cpp \
     ducksrategy.cpp \
-    decorativeduck.cpp
+    decorativeduckfactory.cpp \
+    duckfactory.cpp \
+    flock.cpp
 
 DISTFILES += \
     Strategy.pro.user \
@@ -27,5 +31,9 @@ HEADERS += \
     realduck.h \
     rubberduck.h \
     woodenduck.h \
-    decorativeduck.h
+    decorativeduck.h \
+    abstractduckfactory.h \
+    decorativeduckfactory.h \
+    duckfactory.h \
+    flock.h
 

Strategy/abstractduckfactory.cpp

@@ -0,0 +1,7 @@
+#include "abstractduckfactory.h"
+
+AbstractDuckFactory::AbstractDuckFactory()
+{
+
+}
+

Strategy/abstractduckfactory.h

@@ -0,0 +1,15 @@
+#ifndef ABSTRACTDUCKFACTORY_H
+#define ABSTRACTDUCKFACTORY_H
+#include "duck.h"
+
+class AbstractDuckFactory
+{
+public:
+    AbstractDuckFactory();
+    virtual Duck* createRealDuck()=0;
+    virtual Duck* createWoodenDuck()=0;
+    virtual Duck* createRubberDuck()=0;
+
+};
+
+#endif // ABSTRACTDUCKFACTORY_H

Strategy/decorativeduckfactory.cpp

@@ -0,0 +1,27 @@
+#include "decorativeduckfactory.h"
+#include "decorativeduck.h"
+#include "realduck.h"
+#include "realduckstrategy.h"
+#include "woodenduck.h"
+#include "woodenstrategy.h"
+#include "rubberduck.h"
+#include "rubberstrategy.h"
+
+DecorativeDuckFactory::DecorativeDuckFactory()
+{
+
+}
+
+Duck* DecorativeDuckFactory::createRealDuck()
+{
+    return new DecorativeDuck(new RealDuck(new RealDuckStrategy()));
+}
+
+Duck* DecorativeDuckFactory::createWoodenDuck()
+{
+    return new DecorativeDuck(new WoodenDuck(new WoodenStrategy()));
+}
+Duck* DecorativeDuckFactory::createRubberDuck()
+{
+    return new DecorativeDuck(new RubberDuck(new RubberStrategy()));
+}

Strategy/decorativeduckfactory.h

@@ -0,0 +1,15 @@
+#ifndef DECORATIVEDUCKFACTORY_H
+#define DECORATIVEDUCKFACTORY_H
+#include "abstractduckfactory.h"
+#include "duck.h"
+
+class DecorativeDuckFactory: public AbstractDuckFactory
+{
+public:
+    DecorativeDuckFactory();
+    virtual Duck* createRealDuck();
+    virtual Duck* createWoodenDuck();
+    virtual Duck* createRubberDuck();
+};
+
+#endif // DECORATIVEDUCKFACTORY_H

Strategy/duckfactory.cpp

@@ -0,0 +1,24 @@
+#include "duckfactory.h"
+#include "realduck.h"
+#include "realduckstrategy.h"
+#include "woodenduck.h"
+#include "woodenstrategy.h"
+#include "rubberduck.h"
+#include "rubberstrategy.h"
+DuckFactory::DuckFactory()
+{
+
+}
+Duck* DuckFactory::createRealDuck()
+{
+    return new RealDuck(new RealDuckStrategy());
+}
+
+Duck* DuckFactory::createWoodenDuck()
+{
+    return new WoodenDuck(new WoodenStrategy());
+}
+Duck* DuckFactory::createRubberDuck()
+{
+    return new RubberDuck(new RubberStrategy());
+}

Strategy/duckfactory.h

@@ -0,0 +1,14 @@
+#ifndef DUCKFACTORY_H
+#define DUCKFACTORY_H
+#include"abstractduckfactory.h"
+
+class DuckFactory : public AbstractDuckFactory
+{
+public:
+    DuckFactory();
+    virtual Duck* createRealDuck();
+    virtual Duck* createWoodenDuck();
+    virtual Duck* createRubberDuck();
+};
+
+#endif // DUCKFACTORY_H

Strategy/flock.cpp

@@ -0,0 +1,7 @@
+#include "flock.h"
+
+Flock::Flock()
+{
+
+}
+

Strategy/flock.h

@@ -0,0 +1,16 @@
+#ifndef FLOCK_H
+#define FLOCK_H
+#include <vector>
+#include "duck.h"
+#include "abstractduckfactory.h"
+
+class Flock
+{
+    std::vector<Duck*> ducks;
+public:
+    Flock();
+    virtual void addDucks(AbstractDuckFactory& factory)=0;
+    virtual void useDuckStrategy()=0;
+};
+
+#endif // FLOCK_H

Strategy/main.cpp

@@ -1,45 +1,56 @@
 #include <iostream>
 #include <vector>
 #include "duck.h"
-#include "realduck.h"
-#include "rubberduck.h"
-#include "woodenduck.h"
-#include "woodenstrategy.h"
-#include "realduckstrategy.h"
-#include "rubberstrategy.h"
 #include "decorativeduck.h"
-
+#include "abstractduckfactory.h"
+#include "duckfactory.h"
+#include "decorativeduckfactory.h"
 using namespace std;
 
 int main()
 {
-    vector<DecorativeDuck*> ducks;
+    vector<Duck*> decducks;
+    vector <Duck*> normducks;
+    AbstractDuckFactory* decDucksFactory = new DecorativeDuckFactory();
+    AbstractDuckFactory* normDucksFactory = new DuckFactory();
+
+
 	for (int i = 0; i < 10; i++)
 	{
         switch (i%3)
 		{
 		case 0:
-            ducks.push_back(new DecorativeDuck(new RealDuck(new RealDuckStrategy())));
+            decducks.push_back(decDucksFactory->createRealDuck());
+            normducks.push_back(normDucksFactory->createRealDuck());
 			break;
 		case 1:
-            ducks.push_back(new DecorativeDuck(new WoodenDuck(new WoodenStrategy())));
+            decducks.push_back(decDucksFactory->createWoodenDuck());
+            normducks.push_back(normDucksFactory->createWoodenDuck());
 			break;
 		case 2:
-            ducks.push_back(new DecorativeDuck(new RubberDuck(new RubberStrategy())));
+            decducks.push_back(decDucksFactory->createRubberDuck());
+            normducks.push_back(normDucksFactory->createRubberDuck());
 			break;
 		}
 	}
-    for (auto duck : ducks)
+    for (auto duck : normducks)
 	{
         duck->useStrategy();
 
+    }
+    for (auto duck : decducks)
+    {
+        duck->useStrategy();
+
     }
     int krya=0;
-    for (auto duck : ducks)
+    for (auto duck : decducks)
     {
-        krya += duck->getCount();
+        auto d = dynamic_cast<DecorativeDuck*>(duck);
+        if (d!=nullptr)
+        krya += d->getCount();
 
     }
-    std::cout << krya << std::endl;
+    std::cout << "\nnumber of quaks = "<< krya << std::endl;
 
 }