void FormFactorDecorator::updateParametersFrom(const ParameterList &list) {
// Try to update mesonRadius
std::shared_ptr<FitParameter> rad;
try {
rad = FindParameter(MesonRadius->name(), list);
} catch (std::exception &ex) {
}
if (rad)
MesonRadius->updateParameter(rad);
// Try to update daugher1's mass
std::shared_ptr<FitParameter> daug1Mass;
try{
daug1Mass = FindParameter(Daughter1Mass->name(), list);
} catch (std::exception &ex) {
}
if (daug1Mass)
daug1Mass->updateParameter(daug1Mass);
// Try to update daugher2's mass
std::shared_ptr<FitParameter> daug2Mass;
try{
daug2Mass = FindParameter(Daughter2Mass->name(), list);
} catch (std::exception &ex) {
}
if (daug2Mass)
daug2Mass->updateParameter(daug2Mass);
UndecoratedBreitWigner->updateParametersFrom(list);
return;
}
NS_IMETHODIMP
calIcalProperty::GetParameter(const nsACString ¶m, nsACString &value)
{
// More ridiculous parameter/X-PARAMETER handling.
icalparameter_kind paramkind =
icalparameter_string_to_kind(PromiseFlatCString(param).get());
if (paramkind == ICAL_NO_PARAMETER)
return NS_ERROR_INVALID_ARG;
const char *icalstr = nullptr;
if (paramkind == ICAL_X_PARAMETER) {
icalparameter *icalparam = FindParameter(mProperty, param, ICAL_X_PARAMETER);
if (icalparam)
icalstr = icalparameter_get_xvalue(icalparam);
} else if (paramkind == ICAL_IANA_PARAMETER) {
icalparameter *icalparam = FindParameter(mProperty, param, ICAL_IANA_PARAMETER);
if (icalparam)
icalstr = icalparameter_get_iana_value(icalparam);
} else {
icalstr = icalproperty_get_parameter_as_string(mProperty,
PromiseFlatCString(param).get());
}
if (!icalstr) {
value.Truncate();
value.SetIsVoid(true);
} else {
value.Assign(icalstr);
}
return NS_OK;
}
NS_IMETHODIMP
calIcalProperty::SetParameter(const nsACString ¶m, const nsACString &value)
{
icalparameter_kind paramkind =
icalparameter_string_to_kind(PromiseFlatCString(param).get());
if (paramkind == ICAL_NO_PARAMETER)
return NS_ERROR_INVALID_ARG;
// Because libical's support for manipulating parameters is weak, and
// X-PARAMETERS doubly so, we walk the list looking for an existing one of
// that name, and reset its value if found.
if (paramkind == ICAL_X_PARAMETER) {
icalparameter *icalparam = FindParameter(mProperty, param, ICAL_X_PARAMETER);
if (icalparam) {
icalparameter_set_xvalue(icalparam,
PromiseFlatCString(value).get());
return NS_OK;
}
// If not found, fall through to adding a new parameter below.
} else if (paramkind == ICAL_IANA_PARAMETER) {
icalparameter *icalparam = FindParameter(mProperty, param, ICAL_IANA_PARAMETER);
if (icalparam) {
icalparameter_set_iana_value(icalparam,
PromiseFlatCString(value).get());
return NS_OK;
}
// If not found, fall through to adding a new parameter below.
} else {
// We could try getting an existing parameter here and resetting its
// value, but this is easier and I don't care that much about parameter
// performance at this point.
RemoveParameter(param);
}
icalparameter *icalparam =
icalparameter_new_from_value_string(paramkind,
PromiseFlatCString(value).get());
if (!icalparam)
return NS_ERROR_OUT_OF_MEMORY;
// You might ask me "why does libical not do this for us?" and I would
// just nod knowingly but sadly at you in return.
//
// You might also, if you were not too distracted by the first question,
// ask why we have icalproperty_set_x_name but icalparameter_set_xname.
// More nodding would ensue.
if (paramkind == ICAL_X_PARAMETER)
icalparameter_set_xname(icalparam, PromiseFlatCString(param).get());
else if (paramkind == ICAL_IANA_PARAMETER)
icalparameter_set_iana_name(icalparam, PromiseFlatCString(param).get());
icalproperty_add_parameter(mProperty, icalparam);
// XXX check ical errno
return NS_OK;
}
// set a parameter (attribute=value) of the field
void MimeField::SetParameter(const char* pszAttr, const char* pszValue)
{
int nSize = pszValue ? (int)::strlen(pszValue) : 0;
string strValue;
strValue.reserve(nSize+3);
if (!pszValue || *pszValue != '"')
strValue = "\"";
if (pszValue != NULL)
strValue += pszValue;
if (nSize < 2 || pszValue[nSize-1] != '"')
strValue += "\"";
bool encodedParameter;
int nPos;
if (!FindParameter(pszAttr, nPos, nSize, encodedParameter)) // add new parameter
{
m_strValue.reserve(m_strValue.size() + ::strlen(pszAttr) + strValue.size() + 5);
//if (MimeEnvironment::AutoFolding())
// m_strValue += ";\r\n\t";
//else
// m_strValue += "; ";
m_strValue += "; ";
m_strValue += pszAttr;
m_strValue += '=';
m_strValue += strValue;
}
else // update existing parameter
m_strValue.replace(nPos, nSize, strValue);
}
// GetInt64ParameterValue
int64
DriverParameterContainer::GetInt64ParameterValue(const char* name,
int64 unknownValue, int64 noValue) const
{
DriverParameter parameter;
if (!FindParameter(name, ¶meter))
return unknownValue;
return parameter.Int64ValueAt(0, noValue);
}
// GetBoolParameterValue
bool
DriverParameterContainer::GetBoolParameterValue(const char* name,
bool unknownValue, bool noValue) const
{
DriverParameter parameter;
if (!FindParameter(name, ¶meter))
return unknownValue;
return parameter.BoolValueAt(0, noValue);
}
// GetParameterValue
const char*
DriverParameterContainer::GetParameterValue(const char* name,
const char* unknownValue, const char* noValue) const
{
DriverParameter parameter;
if (!FindParameter(name, ¶meter))
return unknownValue;
return parameter.ValueAt(0, noValue);
}
BOOL CParameterInfo::IsParameterExisting(int paramIndex)
{
if(FindParameter(paramIndex))
{
return TRUE;
}
return FALSE;
}
EObjectDataType CParameterInfo::GetParameterType(int paramIndex)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->GetType();
}
return ODT_UNKNOWN;
}
DWORD CParameterInfo::GetParameterArraySize(int p_lParamIndex)
{
CParameterBase* pParameter;
pParameter = FindParameter(p_lParamIndex);
if(pParameter)
{
return pParameter->GetArraySize();
}
return 0;
}
EXPORT_C void CTcParameterList::RemoveParameter(
const TDesC8& aName,
MTcTyped::TParameterType aType )
{
TInt pos = FindParameter( aName, aType );
if( pos != KErrNotFound )
{
MTcTyped* item = iParameters.At( pos );
iParameters.Delete( pos );
delete item;
}
}
BOOL CParameterInfo::SetParameterDataString(int paramIndex, CStdString strValue, BOOL showMsg)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->SetValue(strValue, showMsg);
}
return FALSE;
}
CStdString CParameterInfo::GetParameterTypeStr(int paramIndex)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->GetTypeStr();
}
return "";
}
BOOL CParameterInfo::IsParameterVisible(int paramIndex)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->IsVisible();
}
return FALSE;
}
CStdString CParameterInfo::GetParameterDataStr(int paramIndex, EObjectValueStringFormat format)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->GetValueStr(format);
}
return "";
}
BOOL CParameterInfo::GetParameterData(int paramIndex, void *data, DWORD length)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->GetData(data, length);
}
return FALSE;
}
BOOL CParameterInfo::SetParameterData(int paramIndex, void* data, size_t length)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->SetData(data, (DWORD)length);
}
return FALSE;
}
DWORD CParameterInfo::GetParameterLength(int paramIndex)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
return pParameter->GetLength();
}
return 0;
}
BOOL CParameterInfo::GetParameterDataString(int paramIndex, CStdString* pStrValue, EObjectValueStringFormat format)
{
CParameterBase* pParameter;
pParameter = FindParameter(paramIndex);
if(pParameter && pStrValue)
{
*pStrValue = pParameter->GetValueStr(format);
return TRUE;
}
return FALSE;
}
void CParameterInfo::AddParameter(int paramIndex, CStdString name, EObjectDataType type, DWORD dArraySize, BOOL visible, BOOL editable)
{
CParameter* pParameter = 0;
pParameter = FindParameter(paramIndex);
if(pParameter)
{
pParameter->Init(paramIndex, name, type, dArraySize, visible, editable);
}
else
{
pParameter = new CParameter();
pParameter->Init(paramIndex, name, type, dArraySize, visible, editable);
m_ParameterList.push_back(pParameter);
}
}
bool GetPrivateSettingsData()
{
// Find parameters line.
GetPostParameterLine();
if (_requestLine[0] == CH_NONE)
{ return false; }
// Process params.
char * paramVal;
uint8_t paramLen;
uint8_t vdPos = 0;
uint8_t ipBuff[IP_LEN];
bool findParam;
bool cnvResult;
for (uint8_t row = 0; row < DATA_ROW_COUNT; row++)
{
for (uint8_t col = 0; col < DOG_COUNT; col++)
{
DogSetting& dog = DogListSettings[col];
uint8_t val;
char numChar = ONE_TO_FOUR[col];
ValidationData& vd = ValidDataSettings[vdPos++];
switch (row)
{
// Status.
case 0:
{
// cbX=1.
findParam = FindParameter(_requestLine, PREFF_CB, numChar, paramVal, paramLen);
dog.Active = (findParam && paramVal[0] == CH_1) ? true : false;
vd.IsValid = 1;
vd.Value = paramVal;
vd.Length = paramLen;
}
break;
// IP.
case 1:
{
// ipX=0.0.0.0.
findParam = FindParameter(_requestLine, PREFF_IP, numChar, paramVal, paramLen);
cnvResult = atoip(paramVal, ipBuff);
vd.IsValid = findParam && cnvResult ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
if (cnvResult)
{ memcpy(dog.IP, ipBuff, IP_LEN); }
}
break;
// Test period.
case 2:
{
// tpX=30
findParam = FindParameter(_requestLine, PREFF_TP, numChar, paramVal, paramLen);
cnvResult = atoUint8(paramVal, val);
vd.IsValid = (findParam && cnvResult) && val > 0 ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
dog.TestPeriod = val;
}
break;
// Host lost after.
case 3:
{
// hlX=3.
findParam = FindParameter(_requestLine, PREFF_HL, numChar, paramVal, paramLen);
cnvResult = atoUint8(paramVal, val);
vd.IsValid = (findParam && cnvResult && val <= MAX_HOST_LOST_AFTER && val > 0) ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
dog.HostLostAfter = val;
}
break;
// Restart wait time.
case 4:
{
// rwX=10.
findParam = FindParameter(_requestLine, PREFF_RW, numChar, paramVal, paramLen);
cnvResult = atoUint8(paramVal, val);
vd.IsValid = (findParam && cnvResult && val > 0) ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
dog.RestartWaitTime = val;
}
break;
// Wait after restart.
case 5:
{
// waX=60.
findParam = FindParameter(_requestLine, PREFF_WA, numChar, paramVal, paramLen);
cnvResult = atoUint8(paramVal, val);
vd.IsValid = (findParam && cnvResult && val > 0) ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
dog.WaitAfterRestart = val;
}
break;
}
}
}
return true;
}
ShaderEffect::Parameter* ShaderEffect::FindParameter(const String& name)
{
return FindParameter(name.CStr());
}
bool GetPrivateUserAndIpData()
{
// Find parameters line.
GetPostParameterLine();
if (_requestLine[0] == CH_NONE)
{ return false; }
// Process params.
char * paramVal;
uint8_t paramLen;
uint8_t ipBuff[IP_LEN];
bool findParam;
bool cnvResult;
for (uint8_t col = 0; col < VALID_USER_AND_IP_LEN; col++)
{
ValidationData& vd = ValidUserAndIP[col];
switch (col)
{
// User name.
case 0:
{
// cbX=1.
findParam = FindParameter(_requestLine, PREFF_US, CH_1, paramVal, paramLen);
vd.IsValid = (findParam && paramLen >= 3 && paramLen <= 8) ? true : false;
vd.Value = paramVal;
vd.Length = paramLen;
if (vd.IsValid)
{ strNCopy(DeviceDataUserAndIP.User, paramVal, paramLen); }
}
break;
// Password.
case 1:
{
// cbX=1.
findParam = FindParameter(_requestLine, PREFF_PS, CH_1, paramVal, paramLen);
vd.IsValid = (findParam && paramLen >= 3 && paramLen <= 8) ? true : false;
vd.Value = paramVal;
vd.Length = paramLen;
if (vd.IsValid)
{ strNCopy(DeviceDataUserAndIP.Password, paramVal, paramLen); }
}
break;
// IP.
case 2:
{
findParam = FindParameter(_requestLine, PREFF_IP, CH_1, paramVal, paramLen);
cnvResult = atoip(paramVal, ipBuff);
vd.IsValid = findParam && cnvResult ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
if (cnvResult)
{ memcpy(DeviceDataUserAndIP.IP, ipBuff, IP_LEN); }
}
break;
// Subnet mask.
case 3:
{
findParam = FindParameter(_requestLine, PREFF_SN, CH_1, paramVal, paramLen);
cnvResult = atoip(paramVal, ipBuff);
vd.IsValid = findParam && cnvResult ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
if (cnvResult)
{ memcpy(DeviceDataUserAndIP.SubnetMask, ipBuff, IP_LEN); }
}
break;
// Subnet mask.
case 4:
{
findParam = FindParameter(_requestLine, PREFF_GW, CH_1, paramVal, paramLen);
cnvResult = atoip(paramVal, ipBuff);
vd.IsValid = findParam && cnvResult ? 1 : 0;
vd.Value = paramVal;
vd.Length = paramLen;
if (cnvResult)
{ memcpy(DeviceDataUserAndIP.Gateway, ipBuff, IP_LEN); }
}
break;
}
}
return true;
}
// get the value of a parameter
bool CMimeField::GetParameter(const char* pszAttr, string& strValue) const
{
int nPos, nSize;
if (!FindParameter(pszAttr, nPos, nSize))
{
strValue.clear();
if(pszAttr!=0)
{
// parameters might have been continued on another line with param*0, param*1, param*2
std::string tempval("");
std::string tempparam("");
int paramnum=0;
std::ostringstream numstr;
numstr << paramnum++;
tempparam=std::string(pszAttr)+"*"+numstr.str();
while(FindParameter(tempparam.c_str(),nPos,nSize)==true)
{
if(m_strValue[nPos]=='"')
{
nPos++;
nSize--;
if(nSize>0 && m_strValue[nPos+nSize-1]=='"')
{
nSize--;
}
}
if(nSize>0)
{
tempval+=m_strValue.substr(nPos,nSize);
}
numstr.str("");
numstr << paramnum++;
tempparam=std::string(pszAttr)+"*"+numstr.str();
}
strValue=tempval;
}
if(strValue!="")
{
return true;
}
else
{
return false;
}
}
if (m_strValue[nPos] == '"')
{
nPos++;
nSize--;
if (nSize > 0 && m_strValue[nPos+nSize-1] == '"')
nSize--;
}
strValue.assign(m_strValue.data()+nPos, nSize);
return true;
}
