Add missing include to conffiles.h.

[stg.git] / include / stg / tariff_conf.h

diff --git a/include/stg/tariff_conf.h b/include/stg/tariff_conf.h
index 376ed378e527fc1ed74c0a3d79ba290677661ebb..0a4f988b904a5c166f64d98c224975ede8696013 100644 (file)
--- a/include/stg/tariff_conf.h
+++ b/include/stg/tariff_conf.h
@@ -18,34 +18,22 @@
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */
 
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */
 

- /*
- $Revision: 1.9 $
- $Date: 2010/10/05 20:41:11 $
- $Author: faust $
- */
-
-#ifndef TARIFF_CONF_H
-#define TARIFF_CONF_H
+#pragma once

 
 #include "tariff.h"
 
 #include "tariff.h"

-#include "resetable.h"

 #include "const.h"
 #include "const.h"

+#include "splice.h"

 
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>

+#include <optional>

 
 

-//-----------------------------------------------------------------------------
-enum
+namespace STG

 {
 {

-    TRAFF_UP = 0,
-    TRAFF_DOWN,
-    TRAFF_UP_DOWN,
-    TRAFF_MAX
-};

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-struct DIRPRICE_DATA
+struct DirPriceData

 {
 {

-    DIRPRICE_DATA()
+    DirPriceData() noexcept

         : hDay(0),
           mDay(0),
           hNight(0),
         : hDay(0),
           mDay(0),
           hNight(0),


@@ -57,7 +45,13 @@ struct DIRPRICE_DATA
           threshold(0),
           singlePrice(0),
           noDiscount(0)
           threshold(0),
           singlePrice(0),
           noDiscount(0)

-        {}
+    {}
+
+    DirPriceData(const DirPriceData&) = default;
+    DirPriceData& operator=(const DirPriceData&) = default;
+    DirPriceData(DirPriceData&&) = default;
+    DirPriceData& operator=(DirPriceData&&) = default;
+

     int    hDay;
     int    mDay;
     int    hNight;
     int    hDay;
     int    mDay;
     int    hNight;


@@ -71,185 +65,241 @@ struct DIRPRICE_DATA
     int    noDiscount; // Do not use threshold
 };
 //-----------------------------------------------------------------------------
     int    noDiscount; // Do not use threshold
 };
 //-----------------------------------------------------------------------------

-struct DIRPRICE_DATA_RES
+struct DirPriceDataOpt

 {
 {

-    DIRPRICE_DATA_RES()
-        : hDay(),
-          mDay(),
-          hNight(),
-          mNight(),
-          priceDayA(),
-          priceNightA(),
-          priceDayB(),
-          priceNightB(),
-          threshold(),
-          singlePrice(),
-          noDiscount()
-        {}
-
-    DIRPRICE_DATA_RES & operator= (const DIRPRICE_DATA & rvalue)
-        {
-        hDay        = rvalue.hDay;
-        mDay        = rvalue.mDay;
-        hNight      = rvalue.hNight;
-        mNight      = rvalue.mNight;
-        priceDayA   = rvalue.priceDayA;
-        priceNightA = rvalue.priceNightA;
-        priceDayB   = rvalue.priceDayB;
-        priceNightB = rvalue.priceNightB;
-        threshold   = rvalue.threshold;
-        singlePrice = rvalue.singlePrice;
-        noDiscount  = rvalue.noDiscount;
+    DirPriceDataOpt() = default;
+
+    DirPriceDataOpt(const DirPriceData& data) noexcept
+        : hDay(data.hDay),
+          mDay(data.mDay),
+          hNight(data.hNight),
+          mNight(data.mNight),
+          priceDayA(data.priceDayA),
+          priceNightA(data.priceNightA),
+          priceDayB(data.priceDayB),
+          priceNightB(data.priceNightB),
+          threshold(data.threshold),
+          singlePrice(data.singlePrice),
+          noDiscount(data.noDiscount)
+    {}
+
+    DirPriceDataOpt(const DirPriceDataOpt&) = default;
+    DirPriceDataOpt& operator=(const DirPriceDataOpt&) = default;
+    DirPriceDataOpt(DirPriceDataOpt&&) = default;
+    DirPriceDataOpt& operator=(DirPriceDataOpt&&) = default;
+
+    DirPriceDataOpt & operator=(const DirPriceData& rhs) noexcept
+    {
+        hDay        = rhs.hDay;
+        mDay        = rhs.mDay;
+        hNight      = rhs.hNight;
+        mNight      = rhs.mNight;
+        priceDayA   = rhs.priceDayA;
+        priceNightA = rhs.priceNightA;
+        priceDayB   = rhs.priceDayB;
+        priceNightB = rhs.priceNightB;
+        threshold   = rhs.threshold;
+        singlePrice = rhs.singlePrice;
+        noDiscount  = rhs.noDiscount;

         return *this;
         return *this;

-        }
-
-    DIRPRICE_DATA GetData()
-        {
-        DIRPRICE_DATA dd;
-        dd.hDay        = hDay;
-        dd.hNight      = hNight;
-        dd.mDay        = mDay;
-        dd.mNight      = mNight;
-        dd.noDiscount  = noDiscount;
-        dd.priceDayA   = priceDayA;
-        dd.priceDayB   = priceDayB;
-
-        dd.priceNightA = priceNightA;
-        dd.priceNightB = priceNightB;
-        dd.singlePrice = singlePrice;
-        dd.threshold   = threshold;
-        return dd;
-        }
-
-    RESETABLE<int>    hDay;
-    RESETABLE<int>    mDay;
-    RESETABLE<int>    hNight;
-    RESETABLE<int>    mNight;
-    RESETABLE<double> priceDayA;
-    RESETABLE<double> priceNightA;
-    RESETABLE<double> priceDayB;
-    RESETABLE<double> priceNightB;
-    RESETABLE<int>    threshold;
-    RESETABLE<int>    singlePrice;
-    RESETABLE<int>    noDiscount;
+    }
+
+    void splice(const DirPriceDataOpt & rhs) noexcept
+    {
+        STG::splice(hDay, rhs.hDay);
+        STG::splice(mDay, rhs.mDay);
+        STG::splice(hNight, rhs.hNight);
+        STG::splice(mNight, rhs.mNight);
+        STG::splice(priceDayA, rhs.priceDayA);
+        STG::splice(priceNightA, rhs.priceNightA);
+        STG::splice(priceDayB, rhs.priceDayB);
+        STG::splice(priceNightB, rhs.priceNightB);
+        STG::splice(threshold, rhs.threshold);
+        STG::splice(singlePrice, rhs.singlePrice);
+        STG::splice(noDiscount, rhs.noDiscount);
+    }
+
+    DirPriceData get(const DirPriceData& defaultValue) const noexcept
+    {
+        DirPriceData res;
+        res.hDay = hDay.value_or(defaultValue.hDay);
+        res.mDay = mDay.value_or(defaultValue.mDay);
+        res.hNight = hNight.value_or(defaultValue.hNight);
+        res.mNight = mNight.value_or(defaultValue.mNight);
+        res.priceDayA = priceDayA.value_or(defaultValue.priceDayA);
+        res.priceNightA = priceNightA.value_or(defaultValue.priceNightA);
+        res.priceDayB = priceDayB.value_or(defaultValue.priceDayB);
+        res.priceNightB = priceNightB.value_or(defaultValue.priceNightB);
+        res.threshold = threshold.value_or(defaultValue.threshold);
+        res.singlePrice = singlePrice.value_or(defaultValue.singlePrice);
+        res.noDiscount = noDiscount.value_or(defaultValue.noDiscount);
+        return res;
+    }
+
+    std::optional<int>    hDay;
+    std::optional<int>    mDay;
+    std::optional<int>    hNight;
+    std::optional<int>    mNight;
+    std::optional<double> priceDayA;
+    std::optional<double> priceNightA;
+    std::optional<double> priceDayB;
+    std::optional<double> priceNightB;
+    std::optional<int>    threshold;
+    std::optional<int>    singlePrice;
+    std::optional<int>    noDiscount;

 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------

-struct TARIFF_CONF
+struct TariffConf

 {
 {

-    double         fee;
-    double         free;
-    int            traffType;
-    double         passiveCost;
-    std::string    name;
-    TARIFF::PERIOD period;
-
-    TARIFF_CONF()
+    double             fee;
+    double             free;
+    Tariff::TraffType  traffType;
+    double             passiveCost;
+    std::string        name;
+    Tariff::Period     period;
+    Tariff::ChangePolicy changePolicy;
+    time_t changePolicyTimeout;
+
+    TariffConf() noexcept

         : fee(0),
           free(0),
         : fee(0),
           free(0),

-          traffType(TRAFF_UP_DOWN),
+          traffType(Tariff::TRAFF_UP_DOWN),

           passiveCost(0),
           passiveCost(0),

-          name(),
-          period(TARIFF::MONTH)
-        {}
+          period(Tariff::MONTH),
+          changePolicy(Tariff::ALLOW),
+          changePolicyTimeout(0)
+    {}

 
 

-    TARIFF_CONF(const std::string & n)
+    explicit TariffConf(const std::string & n) noexcept

         : fee(0),
           free(0),
         : fee(0),
           free(0),

-          traffType(TRAFF_UP_DOWN),
+          traffType(Tariff::TRAFF_UP_DOWN),

           passiveCost(0),
           name(n),
           passiveCost(0),
           name(n),

-          period(TARIFF::MONTH)
-        {}
+          period(Tariff::MONTH),
+          changePolicy(Tariff::ALLOW),
+          changePolicyTimeout(0)
+    {}
+
+    TariffConf(const TariffConf&) = default;
+    TariffConf& operator=(const TariffConf&) = default;
+    TariffConf(TariffConf&&) = default;
+    TariffConf& operator=(TariffConf&&) = default;

 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------

-struct TARIFF_CONF_RES
+struct TariffConfOpt

 {
 {

-    TARIFF_CONF_RES()
-        : fee(),
-          free(),
-          traffType(),
-          passiveCost(),
-          name(),
-          period()
-        {}
-
-    TARIFF_CONF_RES & operator=(const TARIFF_CONF & tc)
-        {
+    TariffConfOpt() = default;
+    TariffConfOpt(const TariffConf& data) noexcept
+        : fee(data.fee),
+          free(data.free),
+          traffType(data.traffType),
+          passiveCost(data.passiveCost),
+          name(data.name),
+          period(data.period),
+          changePolicy(data.changePolicy),
+          changePolicyTimeout(data.changePolicyTimeout)
+    {}
+    TariffConfOpt& operator=(const TariffConf & tc) noexcept
+    {

         fee         = tc.fee;
         free        = tc.free;
         traffType   = tc.traffType;
         passiveCost = tc.passiveCost;
         name        = tc.name;
         period      = tc.period;
         fee         = tc.fee;
         free        = tc.free;
         traffType   = tc.traffType;
         passiveCost = tc.passiveCost;
         name        = tc.name;
         period      = tc.period;

+        changePolicy = tc.changePolicy;
+        changePolicyTimeout = tc.changePolicyTimeout;

         return *this;
         return *this;

-        }
-
-    TARIFF_CONF GetData()
-        {
-        TARIFF_CONF tc;
-        tc.fee         = fee;
-        tc.free        = free;
-        tc.name        = name;
-        tc.passiveCost = passiveCost;
-        tc.traffType   = traffType;
-        tc.period      = period;
-        return tc;
-        }
-
-    RESETABLE<double>         fee;
-    RESETABLE<double>         free;
-    RESETABLE<int>            traffType;
-    RESETABLE<double>         passiveCost;
-    RESETABLE<std::string>    name;
-    RESETABLE<TARIFF::PERIOD> period;
+    }
+
+    TariffConfOpt(const TariffConfOpt&) = default;
+    TariffConfOpt& operator=(const TariffConfOpt&) = default;
+    TariffConfOpt(TariffConfOpt&&) = default;
+    TariffConfOpt& operator=(TariffConfOpt&&) = default;
+
+    TariffConf get(const TariffConf& defaultValue) const noexcept
+    {
+        TariffConf res;
+        res.fee = fee.value_or(defaultValue.fee);
+        res.free = free.value_or(defaultValue.free);
+        res.traffType = traffType.value_or(defaultValue.traffType);
+        res.passiveCost = passiveCost.value_or(defaultValue.passiveCost);
+        res.name = name.value_or(defaultValue.name);
+        res.period = period.value_or(defaultValue.period);
+        res.changePolicy = changePolicy.value_or(defaultValue.changePolicy);
+        res.changePolicyTimeout = changePolicyTimeout.value_or(defaultValue.changePolicyTimeout);
+        return res;
+    }
+
+    std::optional<double>             fee;
+    std::optional<double>             free;
+    std::optional<Tariff::TraffType>  traffType;
+    std::optional<double>             passiveCost;
+    std::optional<std::string>        name;
+    std::optional<Tariff::Period>     period;
+    std::optional<Tariff::ChangePolicy> changePolicy;
+    std::optional<time_t>             changePolicyTimeout;

 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------

-struct TARIFF_DATA
+struct TariffData

 {
 {

-    TARIFF_CONF                tariffConf;
-    std::vector<DIRPRICE_DATA> dirPrice;
+    TariffConf                tariffConf;
+    std::vector<DirPriceData> dirPrice;

 
 

-    TARIFF_DATA()
-        : tariffConf(),
-          dirPrice(DIR_NUM)
-        {}
+    TariffData() noexcept
+        : dirPrice(DIR_NUM)
+    {}

 
 

-    TARIFF_DATA(const std::string & name)
+    explicit TariffData(const std::string& name) noexcept

         : tariffConf(name),
           dirPrice(DIR_NUM)
         : tariffConf(name),
           dirPrice(DIR_NUM)

-        {}
+    {}

 
 

-    TARIFF_DATA(const TARIFF_DATA & td)
-        : tariffConf(td.tariffConf),
-          dirPrice(td.dirPrice)
-        {}
-
-    TARIFF_DATA & operator=(const TARIFF_DATA & td)
-        {
-        tariffConf = td.tariffConf;
-        dirPrice = td.dirPrice;
-        return *this;
-        }
+    TariffData(const TariffData&) = default;
+    TariffData& operator=(const TariffData&) = default;
+    TariffData(TariffData&&) = default;
+    TariffData& operator=(TariffData&&) = default;

 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------

-struct TARIFF_DATA_RES
+struct TariffDataOpt

 {
 {

-    TARIFF_CONF_RES                tariffConf;
-    std::vector<DIRPRICE_DATA_RES> dirPrice;
+    TariffConfOpt                tariffConf;
+    std::vector<DirPriceDataOpt> dirPrice;

 
 

-    TARIFF_DATA_RES()
-        : tariffConf(),
+    TariffDataOpt()
+        : dirPrice(DIR_NUM)
+    {}
+
+    TariffDataOpt(const TariffData& data) noexcept
+        : tariffConf(data.tariffConf),

           dirPrice(DIR_NUM)
           dirPrice(DIR_NUM)

-        {}
-
-    TARIFF_DATA GetData()
-        {
-        TARIFF_DATA td;
-        td.tariffConf = tariffConf.GetData();
-        for (size_t i = 0; i < DIR_NUM; i++)
-            td.dirPrice[i] = dirPrice[i].GetData();
-        return td;
-        }
+    {
+        for (size_t i = 0; i < DIR_NUM; ++i)
+            dirPrice[i] = data.dirPrice[i];
+    }
+
+    TariffDataOpt& operator=(const TariffData& td) noexcept
+    {
+        tariffConf = td.tariffConf;
+        for (size_t i = 0; i < DIR_NUM; ++i)
+            dirPrice[i] = td.dirPrice[i];
+        return *this;
+    }
+
+    TariffDataOpt(const TariffDataOpt&) = default;
+    TariffDataOpt& operator=(const TariffDataOpt&) = default;
+    TariffDataOpt(TariffDataOpt&&) = default;
+    TariffDataOpt& operator=(TariffDataOpt&&) = default;
+
+    TariffData get(const TariffData& defaultValue) const noexcept
+    {
+        TariffData res;
+        res.tariffConf = tariffConf.get(defaultValue.tariffConf);
+        for (size_t i = 0; i < DIR_NUM; ++i)
+            res.dirPrice[i] = dirPrice[i].get(defaultValue.dirPrice[i]);
+        return res;
+    }

 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------

-#endif
+}