~lzh/A133.git

/*
 * Copyright (c) 2011-2016, Intel Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation and/or
 * other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 * may be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#pragma once
 
#include "BaseIntegerParameterType.h"
#include "ParameterAdaptation.h"
#include "ParameterAccessContext.h"
 
#include <convert.hpp>
 
#include <type_traits>
#include <sstream>
#include <string>
#include <limits>
#include <iomanip>
 
namespace detail
{
template <bool isSigned, size_t size>
struct IntegerTraits
{
    static_assert(size == 8 or size == 16 or size == 32,
                  "IntegerParameterType size must be 8, 16 or 32.");
 
private:
    // Assumes that size is either 8, 16 or 32, which is ensured by the static_assert above.
    using Signed = typename std::conditional<
        size == 8, int8_t, typename std::conditional<size == 16, int16_t, int32_t>::type>::type;
    using Unsigned = typename std::make_unsigned<Signed>::type;
 
public:
    using CType = typename std::conditional<isSigned, Signed, Unsigned>::type;
};
} // namespace detail
 
template <bool isSigned, size_t bitSize>
class CIntegerParameterType : public CBaseIntegerParameterType
{
private:
    using Base = CBaseIntegerParameterType;
    using CType = typename detail::IntegerTraits<isSigned, bitSize>::CType;
 
    template <class UserType>
    bool doToBlackboard(UserType userValue, uint32_t &uiValue,
                        CParameterAccessContext &parameterAccessContext) const
    {
        {
            if (userValue < static_cast<UserType>(_min) ||
                userValue > static_cast<UserType>(_max)) {
 
                parameterAccessContext.setError("Value out of range");
                return false;
            }
            // Do assign
            uiValue = userValue;
 
            return true;
        }
    }
 
public:
    CIntegerParameterType(const std::string &name) : Base(name){};
 
    // From IXmlSink
    bool fromXml(const CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) override
    {
        setSize(bitSize / 8);
 
        xmlElement.getAttribute("Min", _min);
        xmlElement.getAttribute("Max", _max);
 
        if (_min > _max) {
            serializingContext.setError("The range of allowed value is empty (" +
                                        std::to_string(_min) + " > " + std::to_string(_max) + ").");
            return false;
        }
 
        // Base
        return Base::fromXml(xmlElement, serializingContext);
    }
 
    // From IXmlSource
    void toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const override
    {
        xmlElement.setAttribute("Signed", isSigned);
 
        xmlElement.setAttribute("Min", _min);
        xmlElement.setAttribute("Max", _max);
 
        xmlElement.setAttribute("Size", bitSize);
 
        Base::toXml(xmlElement, serializingContext);
    }
 
    bool fromBlackboard(std::string &strValue, const uint32_t &value,
                        CParameterAccessContext &parameterAccessContext) const override
    {
        // Format
        std::ostringstream stream;
 
        // Take care of format
        if (parameterAccessContext.valueSpaceIsRaw() &&
            parameterAccessContext.outputRawFormatIsHex()) {
 
            // Hexa display with unecessary bits cleared out
            stream << "0x" << std::hex << std::uppercase
                   << std::setw(static_cast<int>(getSize() * 2)) << std::setfill('0') << value;
        } else {
 
            if (isSigned) {
 
                int32_t iValue = value;
 
                // Sign extend
                signExtend(iValue);
 
                stream << iValue;
            } else {
 
                stream << value;
            }
        }
 
        strValue = stream.str();
 
        return true;
    }
 
    // Value access
    // Integer
    bool toBlackboard(uint32_t uiUserValue, uint32_t &uiValue,
                      CParameterAccessContext &parameterAccessContext) const override
    {
        return doToBlackboard(uiUserValue, uiValue, parameterAccessContext);
    }
 
    // Signed Integer
    bool toBlackboard(int32_t iUserValue, uint32_t &uiValue,
                      CParameterAccessContext &parameterAccessContext) const override
    {
        return doToBlackboard(iUserValue, uiValue, parameterAccessContext);
    }
 
    // Double
    bool toBlackboard(double dUserValue, uint32_t &uiValue,
                      CParameterAccessContext &parameterAccessContext) const override
    {
        // Check if there's an adaptation object available
        const CParameterAdaptation *pParameterAdaption = getParameterAdaptation();
 
        if (!pParameterAdaption) {
 
            // Reject request and let upper class handle the error
            return Base::toBlackboard(dUserValue, uiValue, parameterAccessContext);
        }
 
        // Do the conversion
        int64_t iConvertedValue = pParameterAdaption->fromUserValue(dUserValue);
 
        if (iConvertedValue < _min || iConvertedValue > _max) {
 
            parameterAccessContext.setError("Value out of range");
 
            return false;
        }
 
        // Do assign
        uiValue = (uint32_t)iConvertedValue;
 
        return true;
    }
 
    template <class T>
    bool toBlackboard(const std::string &strValue, uint32_t &uiValue,
                      CParameterAccessContext &parameterAccessContext) const
    {
        T intermediate;
        if (not convertTo(strValue, intermediate)) {
            std::string strError;
            strError = "Impossible to convert value " + strValue + " for " + getKind();
 
            parameterAccessContext.setError(strError);
            return false;
        }
 
        CType value = static_cast<CType>(intermediate);
        if (!checkValueAgainstRange(strValue, intermediate, parameterAccessContext,
                                    utility::isHexadecimal(strValue))) {
            return false;
        }
        uiValue = (uint32_t)value;
 
        return true;
    }
 
    // String
    bool toBlackboard(const std::string &strValue, uint32_t &uiValue,
                      CParameterAccessContext &parameterAccessContext) const override
    {
        if (isSigned and utility::isHexadecimal(strValue)) {
            using Intermediate = typename std::make_unsigned<CType>::type;
 
            return toBlackboard<Intermediate>(strValue, uiValue, parameterAccessContext);
        } else {
            return toBlackboard<CType>(strValue, uiValue, parameterAccessContext);
        }
    }
 
    bool fromBlackboard(double &dUserValue, uint32_t uiValue,
                        CParameterAccessContext &parameterAccessContext) const override
    {
        // Check if there's an adaptation object available
        const CParameterAdaptation *pParameterAdaption = getParameterAdaptation();
 
        if (!pParameterAdaption) {
 
            // Reject request and let upper class handle the error
            return Base::fromBlackboard(dUserValue, uiValue, parameterAccessContext);
        }
 
        int64_t iValueToConvert;
 
        // Deal with signed data
        if (isSigned) {
 
            int32_t iValue = uiValue;
 
            signExtend(iValue);
 
            iValueToConvert = iValue;
        } else {
 
            iValueToConvert = uiValue;
        }
 
        // Do the conversion
        dUserValue = pParameterAdaption->toUserValue(iValueToConvert);
 
        return true;
    }
 
    // Default value handling (simulation only)
    uint32_t getDefaultValue() const override { return _min; }
 
    // Element properties
    void showProperties(std::string &strResult) const override
    {
        Base::showProperties(strResult);
 
        std::ostringstream stream;
        stream << "Signed: " << (isSigned ? "yes" : "no") << "\n"
               << "Min: " << _min << "\n"
               << "Max: " << _max << "\n";
 
        strResult += stream.str();
 
        // Check if there's an adaptation object available
        const CParameterAdaptation *pParameterAdaption = getParameterAdaptation();
 
        if (pParameterAdaption) {
 
            // Display adaptation properties
            strResult += "Adaptation:\n";
 
            pParameterAdaption->showProperties(strResult);
        }
    }
 
    // Integer conversion
    int toPlainInteger(int iSizeOptimizedData) const override
    {
        if (isSigned) {
 
            signExtend(iSizeOptimizedData);
        }
 
        return Base::toPlainInteger(iSizeOptimizedData);
    }
 
    // Range checking
    bool checkValueAgainstRange(const std::string &strValue, CType value,
                                CParameterAccessContext &parameterAccessContext,
                                bool bHexaValue) const
    {
        if (value < _min || value > _max) {
 
            std::ostringstream stream;
 
            stream << "Value " << strValue << " standing out of admitted range [";
 
            if (bHexaValue) {
 
                stream << "0x" << std::hex << std::uppercase
                       << std::setw(static_cast<int>(getSize() * 2)) << std::setfill('0');
                // Format Min
                stream << _min;
                // Format Max
                stream << _max;
 
            } else {
 
                stream << _min << ", " << _max;
            }
 
            stream << "] for " << getKind();
 
            parameterAccessContext.setError(stream.str());
 
            return false;
        }
        return true;
    }
 
private:
    // Range
    CType _min{std::numeric_limits<CType>::min()};
    CType _max{std::numeric_limits<CType>::max()};
};