refactored factories for payoff by eliminating unncesarry interfaces …

…so as to use static crete method, asn added factroeis for all options except barrier whihc will require to ad dthe knock bhevaiour to the payoff

CMakeLists.txt

@@ -38,12 +38,9 @@ add_library(payoff SHARED
         src/payoff/double_strikes/base_payoff_double_strikes.cpp
         src/payoff/double_strikes/payoff_double_digital.cpp
         # Factories
-        src/payoff/factory_payoff.cpp
         src/payoff/single_strike/factory_payoff_vanilla.cpp
         src/payoff/single_strike/factory_payoff_digital.cpp
         src/payoff/double_strikes/factory_payoff_double_digital.cpp
-        src/payoff/double_strikes/factory_payoff_double_strikes.cpp
-        src/payoff/single_strike/factory_payoff_single_strike.cpp
 )
 
 # Create dynamic library for option, linking against marketdata and payoff
@@ -66,11 +63,15 @@ add_library(option SHARED
         src/option/path_dependent/barrier/base_single_barrier_option.cpp
         src/option/path_dependent/barrier/up_single_barrier_option.cpp
         src/option/path_dependent/barrier/down_single_barrier_option.cpp
+        # Factories
         src/option/factory_option.cpp
-        src/option/single_path/factory_single_path_option.cpp
         src/option/single_path/factory_european_option.cpp
-        include/option/single_path/factory_digital_option.h
         src/option/single_path/factory_digital_option.cpp
+        src/option/single_path/factory_double_digital_option.cpp
+        src/option/path_dependent/factory_american_option.cpp
+        src/option/path_dependent/asian/factory_arithmetic_asian_option.cpp
+        src/option/path_dependent/asian/factory_geometric_asian_option.cpp
+        src/option/path_dependent/barrier/factory_up_single_barrier_option.cpp
 )
 
 # Link the option library against marketdata and payoff

include/option/factory_option.h

@@ -2,17 +2,34 @@
 #define FACTORY_OPTION_H
 
 #include <string>
+#include "payoff/base_payoff.h"
+#include "option/base_option.h"
+#include "option/parameter_object.h"
 
 namespace OptionPricer {
     class OptionFactory {
     public:
-        virtual ~OptionFactory() = 0;
+        virtual ~OptionFactory();
+
+        // Non-static create methods as we use virtual methods
+        [[nodiscard]] std::shared_ptr<Option> createCallOption(const ParameterObject& params);
+        [[nodiscard]] std::shared_ptr<Option> createPutOption(const ParameterObject& params);
 
     protected:
-        [[nodiscard]] virtual std::string invalidParams(const std::string& option_type) const;
-    };
+        // Template method pattern
+        std::shared_ptr<Option> createOption(const ParameterObject& params, const std::string& type);
 
-    inline OptionFactory::~OptionFactory() = default;
+        // Can be overiden to add extra parameters
+        virtual std::string invalidParams(const std::string& option_type) const;
+
+        // To be overidden in concrete factories
+        virtual std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params,
+                                                             const std::string& type) = 0;
+        virtual std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                             std::unique_ptr<Payoff> payoff,
+                                                             const std::shared_ptr<IMarketData>& marketData) = 0;
+        virtual std::string getType(const std::string& type) const = 0;
+    };
 }
 
 #endif //FACTORY_OPTION_H

include/option/parameter_object.h

@@ -16,6 +16,7 @@ namespace OptionPricer {
 
         void setParameter(const std::string& name, Parameter value);
 
+        // Maybe using a context to return only a type specified in Parameter
         template <typename T>
         T getParameter(const std::string& name) const {
             if (!hasParameter(name)) {

include/option/path_dependent/american_option.h

@@ -12,6 +12,7 @@ namespace OptionPricer {
     private:
         AmericanOption(const std::string& ticker, std::unique_ptr<Payoff> payoff, const double& T,
             std::shared_ptr<IMarketData> marketData);
+        friend class AmericanOptionFactory;
     };
 }
 

include/option/path_dependent/asian/arithmetic_asian_option.h

@@ -12,6 +12,7 @@ namespace OptionPricer {
     private:
         ArithmeticAsianOption(const std::string& ticker, std::unique_ptr<Payoff> payoff, const double& T,
             std::shared_ptr<IMarketData> marketData);
+        friend class ArithmeticAsianOptionFactory;
     };
 }
 

include/option/path_dependent/asian/factory_arithmetic_asian_option.h

@@ -0,0 +1,18 @@
+#ifndef FACTORY_ARITHMETIC_ASIAN_OPTION_H
+#define FACTORY_ARITHMETIC_ASIAN_OPTION_H
+
+#include "option/factory_option.h"
+
+namespace OptionPricer {
+    class ArithmeticAsianOptionFactory final: public OptionFactory {
+        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const std::string& type) override;
+
+        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                               std::unique_ptr<Payoff> payoff,
+                                                               const std::shared_ptr<IMarketData>& marketData) override;
+
+        std::string getType(const std::string& type) const override;
+    };
+}
+
+#endif //FACTORY_ARITHMETIC_ASIAN_OPTION_H

include/option/path_dependent/asian/factory_geometric_asian_option.h

@@ -0,0 +1,18 @@
+#ifndef FACTORY_GEOMETRIC_ASIAN_OPTION_H
+#define FACTORY_GEOMETRIC_ASIAN_OPTION_H
+
+#include "option/factory_option.h"
+
+namespace OptionPricer {
+    class GeometricAsianOptionFactory final: public OptionFactory {
+        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const std::string& type) override;
+
+        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                     std::unique_ptr<Payoff> payoff,
+                                                     const std::shared_ptr<IMarketData>& marketData) override;
+
+        std::string getType(const std::string& type) const override;
+    };
+}
+
+#endif //FACTORY_GEOMETRIC_ASIAN_OPTION_H

include/option/path_dependent/asian/geometric_asian_option.h

@@ -12,6 +12,8 @@ namespace OptionPricer {
     private:
         GeometricAsianOption(const std::string& ticker, std::unique_ptr<Payoff> payoff, const double& T,
             std::shared_ptr<IMarketData> marketData);
+
+        friend class GeometricAsianOptionFactory;
     };
 }
 

include/option/path_dependent/barrier/base_barrier_option.h

@@ -17,9 +17,7 @@ namespace OptionPricer {
 
         virtual bool isOut(double S) const = 0;
 
-        bool isActive(double S) const {
-            return knockBehavior_->isActive(isOut(S));
-        }
+        bool isActive(double S) const;
 
         std::unique_ptr<KnockBehavior> knockBehavior_;
     };

include/option/path_dependent/barrier/factory_up_single_barrier_option.h

@@ -0,0 +1,20 @@
+#ifndef FACTORY_UP_SINGLE_BARRIER_OPTION_H
+#define FACTORY_UP_SINGLE_BARRIER_OPTION_H
+
+/*
+#include "option/factory_option.h"
+
+namespace OptionPricer {
+    class UpSingleBarrierOptionFactory final: public OptionFactory {
+        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const std::string& type) override;
+
+        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                     std::unique_ptr<Payoff> payoff,
+                                                     const std::shared_ptr<IMarketData>& marketData) override;
+
+        std::string getType(const std::string& type) const override;
+    };
+}
+*/
+
+#endif //FACTORY_UP_SINGLE_BARRIER_OPTION_H

include/option/path_dependent/barrier/up_single_barrier_option.h

@@ -15,6 +15,8 @@ namespace OptionPricer {
                               const double& barrier);
 
         bool isOut(double S) const override;
+
+        friend class UpSingleBarrierOptionFactory;
     };
 }
 

include/option/path_dependent/factory_american_option.h

@@ -0,0 +1,18 @@
+#ifndef FACTORY_AMERICAN_OPTION_H
+#define FACTORY_AMERICAN_OPTION_H
+
+#include "option/factory_option.h"
+
+namespace OptionPricer {
+    class AmericanOptionFactory final: public OptionFactory {
+        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const std::string& type) override;
+
+        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                               std::unique_ptr<Payoff> payoff,
+                                                               const std::shared_ptr<IMarketData>& marketData) override;
+
+        std::string getType(const std::string& type) const override;
+    };
+}
+
+#endif //FACTORY_AMERICAN_OPTION_H

include/option/single_path/double_digital_option.h

@@ -12,6 +12,8 @@ namespace OptionPricer {
     private:
         DoubleDigitalOption(const std::string& ticker, std::unique_ptr<Payoff> payoff, const double& T,
             std::shared_ptr<IMarketData> marketData);
+
+        friend class DoubleDigitalOptionFactory;
     };
 }
 

include/option/single_path/factory_digital_option.h

@@ -1,11 +1,17 @@
 #ifndef FACTORY_DIGITAL_OPTION_H
 #define FACTORY_DIGITAL_OPTION_H
 
-#include "option/single_path/factory_single_path_option.h"
+#include "option/factory_option.h"
 
 namespace OptionPricer {
-    class DigitalOptionFactory final: public SinglePathOptionFactory {
-        std::shared_ptr<SinglePathOption> createOption(const ParameterObject& params, const std::string& type) override;
+    class DigitalOptionFactory final: public OptionFactory {
+        std::unique_ptr<Payoff> createSpecificPayoff(const ParameterObject& params, const std::string& type) override;
+
+        std::shared_ptr<Option> createSpecificOption(const ParameterObject& params,
+                                                               std::unique_ptr<Payoff> payoff,
+                                                               const std::shared_ptr<IMarketData>& marketData) override;
+
+        std::string getType(const std::string& type) const override;
     };
 }