/*

* Copyright (c) 2014-2015, 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, Value, 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.

*/

#include "FloatingPointParameterType.h"

#include <sstream>

#include <iomanip>

#include "ParameterAccessContext.h"

#include "ConfigurationAccessContext.h"

#include <limits>

#include <climits>

#include "convert.hpp"

#include "Utility.h"

#include "BinaryCopy.hpp"

using std::string;

CFloatingPointParameterType::CFloatingPointParameterType(const string &strName) : base(strName)

{

}

string CFloatingPointParameterType::getKind() const

{

return "FloatingPointParameter";

}

// Element properties

void CFloatingPointParameterType::showProperties(string &strResult) const

{

base::showProperties(strResult);

strResult += "Min:" + std::to_string(_fMin) + "\n" + "Max:" + std::to_string(_fMax) + "\n";

}

void CFloatingPointParameterType::handleValueSpaceAttribute(

CXmlElement &xmlConfigurableElementSettingsElement,

CConfigurationAccessContext &configurationAccessContext) const

{

if (!configurationAccessContext.serializeOut()) {

string strValueSpace;

if (xmlConfigurableElementSettingsElement.getAttribute("ValueSpace", strValueSpace)) {

configurationAccessContext.setValueSpaceRaw(strValueSpace == "Raw");

} else {

configurationAccessContext.setValueSpaceRaw(false);

}

} else {

// Set the value space only if it is raw (i.e. not the default one)

if (configurationAccessContext.valueSpaceIsRaw()) {

xmlConfigurableElementSettingsElement.setAttribute("ValueSpace", "Raw");

}

}

}

bool CFloatingPointParameterType::fromXml(const CXmlElement &xmlElement,

CXmlSerializingContext &serializingContext)

{

// Size. The XSD fixes it to 32

size_t sizeInBits = 32;

xmlElement.getAttribute("Size", sizeInBits);

// Size support check: only floats are supported

// (e.g. doubles are not supported)

if (sizeInBits != sizeof(float) * CHAR_BIT) {

serializingContext.setError("Unsupported size (" + std::to_string(sizeInBits) + ") for " +

getKind() + " " + xmlElement.getPath() +

". For now, only 32 is supported.");

return false;

}

setSize(sizeInBits / CHAR_BIT);

xmlElement.getAttribute("Min", _fMin);

xmlElement.getAttribute("Max", _fMax);

if (_fMin > _fMax) {

serializingContext.setError("Min (" + std::to_string(_fMin) +

") can't be greater than Max (" + std::to_string(_fMax) + ")");

return false;

}

return base::fromXml(xmlElement, serializingContext);

}

bool CFloatingPointParameterType::toBlackboard(

const string &strValue, uint32_t &uiValue,

CParameterAccessContext &parameterAccessContext) const

{

// Check Value integrity

if (utility::isHexadecimal(strValue) && !parameterAccessContext.valueSpaceIsRaw()) {

parameterAccessContext.setError("Hexadecimal values are not supported for " + getKind() +

" when selected value space is real: " + strValue);

return false;

}

if (parameterAccessContext.valueSpaceIsRaw()) {

// Raw value: interpret the user input as the memory content of the

// parameter

if (!convertTo(strValue, uiValue)) {

parameterAccessContext.setError("Value '" + strValue + "' is invalid");

return false;

}

auto fData = utility::binaryCopy<float>(uiValue);

// Check against NaN or infinity

if (!std::isfinite(fData)) {

parameterAccessContext.setError("Value " + strValue + " is not a finite number");

return false;

}

if (!checkValueAgainstRange(fData)) {

setOutOfRangeError(strValue, parameterAccessContext);

return false;

}

return true;

} else {

float fValue = 0.0f;

// Interpret the user input as float

if (!convertTo(strValue, fValue)) {

parameterAccessContext.setError("Value " + strValue + " is invalid");

return false;

}

if (!checkValueAgainstRange(fValue)) {

setOutOfRangeError(strValue, parameterAccessContext);

return false;

}

// Move to the "raw memory" value space

uiValue = utility::binaryCopy<decltype(uiValue)>(fValue);

return true;

}

}

void CFloatingPointParameterType::setOutOfRangeError(

const string &strValue, CParameterAccessContext &parameterAccessContext) const

{

// error message buffer

std::ostringstream ostrStream;

ostrStream << "Value " << strValue << " standing out of admitted ";

if (!parameterAccessContext.valueSpaceIsRaw()) {

ostrStream << "real range [" << _fMin << ", " << _fMax << "]";

} else {

auto uiMin = utility::binaryCopy<uint32_t>(_fMin);

auto uiMax = utility::binaryCopy<uint32_t>(_fMax);

if (utility::isHexadecimal(strValue)) {

ostrStream << std::showbase << std::hex << std::setw(static_cast<int>(getSize() * 2))

<< std::setfill('0');

}

ostrStream << "raw range [" << uiMin << ", " << uiMax << "]";

}

ostrStream << " for " << getKind();

parameterAccessContext.setError(ostrStream.str());

}

bool CFloatingPointParameterType::fromBlackboard(

string &strValue, const uint32_t &uiValue,

CParameterAccessContext &parameterAccessContext) const

{

std::ostringstream ostrStream;

if (parameterAccessContext.valueSpaceIsRaw()) {

if (parameterAccessContext.outputRawFormatIsHex()) {

ostrStream << std::showbase << std::hex << std::setw(static_cast<int>(getSize() * 2))

<< std::setfill('0');

}

ostrStream << uiValue;

} else {

// Move from "raw memory" value space to real space

auto fValue = utility::binaryCopy<float>(uiValue);

ostrStream << fValue;

}

strValue = ostrStream.str();

return true;

}

// Value access

bool CFloatingPointParameterType::toBlackboard(

double dUserValue, uint32_t &uiValue, CParameterAccessContext &parameterAccessContext) const

{

if (!checkValueAgainstRange(dUserValue)) {

parameterAccessContext.setError("Value out of range");

return false;

}

// Cast is fine because dValue has been checked against the value range

float fValue = static_cast<float>(dUserValue);

uiValue = utility::binaryCopy<decltype(uiValue)>(fValue);

return true;

}

bool CFloatingPointParameterType::fromBlackboard(double &dUserValue, uint32_t uiValue,

CParameterAccessContext & /*ctx*/) const

{

// Move from "raw memory" value space to real space

auto fValue = utility::binaryCopy<float>(uiValue);

dUserValue = fValue;

return true;

}

bool CFloatingPointParameterType::checkValueAgainstRange(double dValue) const

{

// Check that dValue can safely be cast to a float

// (otherwise, behaviour is undefined)

if ((dValue < -std::numeric_limits<float>::max()) ||

(dValue > std::numeric_limits<float>::max())) {

return false;

}

return checkValueAgainstRange(static_cast<float>(dValue));

}

bool CFloatingPointParameterType::checkValueAgainstRange(float fValue) const

{

return fValue <= _fMax && fValue >= _fMin;

}

void CFloatingPointParameterType::toXml(CXmlElement &xmlElement,

CXmlSerializingContext &serializingContext) const

{

xmlElement.setAttribute("Size", getSize() * CHAR_BIT);

xmlElement.setAttribute("Min", _fMin);

xmlElement.setAttribute("Max", _fMax);

base::toXml(xmlElement, serializingContext);

}