1/*
2 * Copyright (c) 2015, Intel Corporation
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this
9 * list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation and/or
13 * other materials provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors
16 * may be used to endorse or promote products derived from this software without
17 * specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30#pragma once
31
32#include "Config.hpp"
33#include "ConfigFiles.hpp"
34#include "FailureWrapper.hpp"
35
36#include <ParameterMgrFullConnector.h>
37
38namespace parameterFramework
39{
40
41/** This forward declaration is an implementation detail, client should expect its presence.
42 * @note This forward definition should not be needed as the `friend class ElementHandle`
43 *       declaration in ParameterFramework is itself a forward declaration.
44 *       Unfortunately there seem to be a bug in visual studio 2015, it is required.
45 */
46class ElementHandle;
47
48/** Wrapper around the Parameter Framework to throw exceptions on errors and
49 *  have more user friendly methods.
50 *  @see parameterFramework::ElementHandle to access elements of the parameter tree.
51 */
52class ParameterFramework : private parameterFramework::ConfigFiles,
53                           private FailureWrapper<CParameterMgrFullConnector>
54{
55protected:
56    /** Alias to the Platform Connector PF.
57     * It should not be usefull as PF is a super set but is useful
58     * to disambiguate overloaded method for MS visual compiler.
59     */
60    using PPF = CParameterMgrPlatformConnector;
61    using PF = CParameterMgrFullConnector;
62    using EH = ::ElementHandle;
63
64public:
65    ParameterFramework(const Config &config = Config())
66        : ConfigFiles(config), FailureWrapper(getPath())
67    {
68        setForceNoRemoteInterface(true);
69    }
70
71    void start() { mayFailCall(&PF::start); }
72
73    /** @name Forwarded methods
74     * Forward those methods without modification as there are ergonomic and
75     * can not fail (no failure to throw).
76     * @{ */
77    using PF::applyConfigurations;
78    using PF::getFailureOnMissingSubsystem;
79    using PF::getFailureOnFailedSettingsLoad;
80    using PF::getForceNoRemoteInterface;
81    using PF::setForceNoRemoteInterface;
82    using PF::getSchemaUri;
83    using PF::setSchemaUri;
84    using PF::getValidateSchemasOnStart;
85    using PF::isValueSpaceRaw;
86    using PF::isOutputRawFormatHex;
87    using PF::isTuningModeOn;
88    using PF::isAutoSyncOn;
89    using PF::setLogger;
90    using PF::createCommandHandler;
91    /** @} */
92
93    /** Wrap PF::setValidateSchemasOnStart to throw an exception on failure. */
94    void setValidateSchemasOnStart(bool validate)
95    {
96        mayFailCall(&PPF::setValidateSchemasOnStart, validate);
97    }
98
99    /** Wrap PF::setFailureOnFailedSettingsLoad to throw an exception on failure. */
100    void setFailureOnFailedSettingsLoad(bool fail)
101    {
102        mayFailCall(&PPF::setFailureOnFailedSettingsLoad, fail);
103    }
104
105    /** Wrap PF::setFailureOnMissingSubsystem to throw an exception on failure. */
106    void setFailureOnMissingSubsystem(bool fail)
107    {
108        mayFailCall(&PPF::setFailureOnMissingSubsystem, fail);
109    }
110
111    /** Renaming for better readability (and coherency with PF::isValueSpaceRaw)
112     *  of PF::setValueSpace. */
113    void setRawValueSpace(bool enable) { setValueSpace(enable); }
114
115    /** Renaming for better readability (and coherency with PF::isValueSpaceRaw)
116     *  of PF::setValueSpace. */
117    void setHexOutputFormat(bool enable) { setOutputRawFormat(enable); }
118
119    /** Wrap PF::setTuningMode to throw an exception on failure. */
120    void setTuningMode(bool enable) { mayFailCall(&PF::setTuningMode, enable); }
121
122    /** Wrap PF::setAutoSync to throw an exception on failure. */
123    void setAutoSync(bool enable) { mayFailCall(&PF::setAutoSync, enable); }
124
125    /** Wrap PF::accessParameterValue in "set" mode (and rename it) to throw an
126     * exception on failure
127     */
128    void setParameter(const std::string &path, std::string &value)
129    {
130        mayFailCall(&PF::accessParameterValue, path, value, true);
131    }
132    /** Wrap PF::accessParameterValue in "get" mode (and rename it) to throw an
133     * exception on failure
134     */
135    void getParameter(const std::string &path, std::string &value)
136    {
137        mayFailCall(&PF::accessParameterValue, path, value, false);
138    }
139
140    /** Wrap PF::accessConfigurationValue in "set" mode (and rename it) to throw an
141     * exception on failure
142     */
143    void setConfigurationParameter(const std::string domain, const std::string &configuration,
144                                   const std::string &path, std::string &value)
145    {
146        mayFailCall(&PF::accessConfigurationValue, domain, configuration, path, value, true);
147    }
148
149    /** Wrap PF::accessConfigurationValue in "get" mode (and rename it) to throw an
150     * exception on failure
151     */
152    void getConfigurationParameter(const std::string &domain, const std::string &configuration,
153                                   const std::string &path, std::string &value)
154    {
155        mayFailCall(&PF::accessConfigurationValue, domain, configuration, path, value, false);
156    }
157
158private:
159    /** Create an unwrapped element handle.
160     *
161     * Is not public as this method is intended to be used by ElementHandle facade.
162     */
163    EH createElementHandle(const std::string &path)
164    {
165        // PF::createElementHandle takes it's handler in the free store
166        std::unique_ptr<EH> newedHandle{mayFailCall(&PF::createElementHandle, path)};
167        EH handle{*newedHandle};
168        return handle;
169    }
170    friend class ElementHandle;
171};
172
173} // parameterFramework
174