1 /*
2  *  Copyright (C) 2013-2018 Team Kodi
3  *  This file is part of Kodi - https://kodi.tv
4  *
5  *  SPDX-License-Identifier: GPL-2.0-or-later
6  *  See LICENSES/README.md for more information.
7  */
8 
9 #pragma once
10 
11 #include "SettingConditions.h"
12 #include "utils/BooleanLogic.h"
13 #include "utils/logtypes.h"
14 
15 #include <list>
16 #include <set>
17 #include <string>
18 
19 enum class SettingDependencyType {
20   Unknown = 0,
21   Enable,
22   Update,
23   Visible
24 };
25 
26 enum class SettingDependencyOperator {
27   Unknown = 0,
28   Equals,
29   LessThan,
30   GreaterThan,
31   Contains
32 };
33 
34 enum class SettingDependencyTarget {
35   Unknown = 0,
36   Setting,
37   Property
38 };
39 
40 class CSettingDependencyCondition : public CSettingConditionItem
41 {
42 public:
43   explicit CSettingDependencyCondition(CSettingsManager *settingsManager = nullptr);
44   CSettingDependencyCondition(const std::string &setting, const std::string &value,
45                               SettingDependencyOperator op, bool negated = false,
46                               CSettingsManager *settingsManager = nullptr);
47   CSettingDependencyCondition(const std::string &strProperty, const std::string &value,
48                               const std::string &setting = "", bool negated = false,
49                               CSettingsManager *settingsManager = nullptr);
50   ~CSettingDependencyCondition() override = default;
51 
52   bool Deserialize(const TiXmlNode *node) override;
53   bool Check() const override;
54 
GetName()55   const std::string& GetName() const { return m_name; }
GetSetting()56   const std::string& GetSetting() const { return m_setting; }
GetTarget()57   SettingDependencyTarget GetTarget() const { return m_target; }
GetOperator()58   SettingDependencyOperator GetOperator() const { return m_operator; }
59 
60 private:
61   CSettingDependencyCondition(CSettingsManager* settingsManager,
62                               const std::string& strProperty,
63                               const std::string& setting,
64                               const std::string& value,
65                               SettingDependencyTarget target = SettingDependencyTarget::Unknown,
66                               SettingDependencyOperator op = SettingDependencyOperator::Equals,
67                               bool negated = false);
68 
69   bool setTarget(const std::string &target);
70   bool setOperator(const std::string &op);
71 
72   SettingDependencyTarget m_target = SettingDependencyTarget::Unknown;
73   SettingDependencyOperator m_operator = SettingDependencyOperator::Equals;
74 
75   static Logger s_logger;
76 };
77 
78 using CSettingDependencyConditionPtr = std::shared_ptr<CSettingDependencyCondition>;
79 
80 class CSettingDependencyConditionCombination;
81 using CSettingDependencyConditionCombinationPtr = std::shared_ptr<CSettingDependencyConditionCombination>;
82 
83 class CSettingDependencyConditionCombination : public CSettingConditionCombination
84 {
85 public:
86   explicit CSettingDependencyConditionCombination(CSettingsManager *settingsManager = nullptr)
CSettingConditionCombination(settingsManager)87     : CSettingConditionCombination(settingsManager)
88   { }
89   CSettingDependencyConditionCombination(BooleanLogicOperation op, CSettingsManager *settingsManager = nullptr)
CSettingConditionCombination(settingsManager)90     : CSettingConditionCombination(settingsManager)
91   {
92     SetOperation(op);
93   }
94   ~CSettingDependencyConditionCombination() override = default;
95 
96   bool Deserialize(const TiXmlNode *node) override;
97 
GetSettings()98   const std::set<std::string>& GetSettings() const { return m_settings; }
99 
100   CSettingDependencyConditionCombination* Add(const CSettingDependencyConditionPtr& condition);
101   CSettingDependencyConditionCombination* Add(
102       const CSettingDependencyConditionCombinationPtr& operation);
103 
104 private:
newOperation()105   CBooleanLogicOperation* newOperation() override { return new CSettingDependencyConditionCombination(m_settingsManager); }
newValue()106   CBooleanLogicValue* newValue() override { return new CSettingDependencyCondition(m_settingsManager); }
107 
108   std::set<std::string> m_settings;
109 };
110 
111 class CSettingDependency : public CSettingCondition
112 {
113 public:
114   explicit CSettingDependency(CSettingsManager *settingsManager = nullptr);
115   CSettingDependency(SettingDependencyType type, CSettingsManager *settingsManager = nullptr);
116   ~CSettingDependency() override = default;
117 
118   bool Deserialize(const TiXmlNode *node) override;
119 
GetType()120   SettingDependencyType GetType() const { return m_type; }
121   std::set<std::string> GetSettings() const;
122 
123   CSettingDependencyConditionCombinationPtr And();
124   CSettingDependencyConditionCombinationPtr Or();
125 
126 private:
127   bool setType(const std::string &type);
128 
129   SettingDependencyType m_type = SettingDependencyType::Unknown;
130 
131   static Logger s_logger;
132 };
133 
134 using SettingDependencies = std::list<CSettingDependency>;
135 using SettingDependencyMap = std::map<std::string, SettingDependencies>;
136