/**
* \brief Parse the xml definition of this widget setting the state of the
* object accordingly
*/
bool MythUIType::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
//FIXME add movement etc.
if (element.tagName() == "position")
SetPosition(parsePoint(element));
else if (element.tagName() == "area")
{
SetArea(parseRect(element));
}
else if (element.tagName() == "minsize")
{
// Use parsePoint so percentages can be used
if (element.hasAttribute("initiator"))
m_Initiator = parseBool(element.attribute("initiator"));
if (element.hasAttribute("vanish"))
m_Vanish = parseBool(element.attribute("vanish"));
SetMinSize(parsePoint(element));
}
else if (element.tagName() == "alpha")
{
m_Alpha = getFirstText(element).toInt();
m_AlphaChangeMode = 0;
}
else if (element.tagName() == "alphapulse")
{
m_AlphaChangeMode = 2;
m_AlphaMin = element.attribute("min", "0").toInt();
m_Alpha = m_AlphaMax = element.attribute("max", "255").toInt();
if (m_AlphaMax > 255)
m_Alpha = m_AlphaMax = 255;
if (m_AlphaMin < 0)
m_AlphaMin = 0;
m_AlphaChange = element.attribute("change", "5").toInt();
}
else if (element.tagName() == "focusorder")
{
int order = getFirstText(element).toInt();
SetFocusOrder(order);
}
else if (element.tagName() == "loadondemand")
{
SetDeferLoad(parseBool(element));
}
else if (element.tagName() == "helptext")
{
m_helptext = getFirstText(element);
}
else
return false;
return true;
}
void Option::parse(int argc, char* argv[])
{
if (argc == 1)
return;
for (int i = 1; i < argc; i++) {
char* arg = argv[i];
i++;
if (strcmp(arg, "-v") == 0 || strcmp(arg, "--version") == 0) {
printf("%s\n", VersionStr);
printf("Written by Nakayama Shintaro\n");
printf("Maintained by Pascal Malaise\n");
exit(0);
} else if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
printf("Usage %s { [ <option> ] }\n", argv[0]);
printf("<option> ::=\n");
printf(" -s <positive> | --speed <positive>\n");
#ifdef SHAPE
printf(" -r <boolean> | --round-card <boolean>\n");
#endif
printf(" -a <boolean> | --animation <boolean>\n");
printf(" -m <boolean> | --ms-seed <boolean>\n");
printf(" -p <boolean> | --auto-play <boolean>\n");
exit(0);
} else if (strcmp(arg, "-s") == 0 || strcmp(arg, "--speed") == 0) {
arg = argv[i];
if (i == argc) goto ERRORI;
_speedup = atoi(arg);
if (0 > _speedup) goto ERRORI;
continue;
ERRORI:
fprintf(stderr, "Positive integer must follow -s\n");
exit (1);
} else if (strcmp(arg, "-q") == 0 || strcmp(arg, "--query-window") == 0) {
_queryWindow = parseBool(i, argc, argv);
#ifdef SHAPE
} else if (strcmp(arg, "-r") == 0 || strcmp(arg, "--round-card") == 0) {
_roundCard = parseBool(i, argc, argv);
#endif
} else if (strcmp(arg, "-a") == 0 || strcmp(arg, "--animation") == 0) {
_animation = parseBool(i, argc, argv);
} else if (strcmp(arg, "-m") == 0 || strcmp(arg, "--ms-seed") == 0) {
_msSeed = parseBool(i, argc, argv);
} else if (strcmp(arg, "-p") == 0 || strcmp(arg, "--auto-play") == 0) {
_autoPlay = parseBool(i, argc, argv);
} else {
fprintf(stderr, "Unknown option: %s\n", arg);
exit (1);
}
}
}
void
EmsMessage::parseRCWWOpmodeMessage()
{
parseBool(0, 1, EmsValue::EigenesProgrammAktiv, EmsValue::WW);
parseBool(1, 1, EmsValue::EigenesProgrammAktiv, EmsValue::Zirkulation);
parseEnum(2, EmsValue::Betriebsart, EmsValue::WW);
parseEnum(3, EmsValue::Betriebsart, EmsValue::Zirkulation);
parseBool(4, 1, EmsValue::Desinfektion, EmsValue::WW);
parseEnum(5, EmsValue::DesinfektionTag, EmsValue::WW);
parseInteger(6, 1, EmsValue::DesinfektionStunde, EmsValue::WW);
parseNumeric(8, 1, 1, EmsValue::MaxTemp, EmsValue::WW);
parseBool(9 ,1, EmsValue::EinmalLadungsLED, EmsValue::WW);
}
eResult ArchiverImpl::AutoAttach(unsigned int ulFlags)
{
HRESULT hr = hrSuccess;
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "ArchiverImpl::AutoAttach() function entry");
ArchiveStateCollectorPtr ptrArchiveStateCollector;
ArchiveStateUpdaterPtr ptrArchiveStateUpdater;
if (ulFlags != ArchiveManage::Writable && ulFlags != ArchiveManage::ReadOnly && ulFlags != 0) {
hr = MAPI_E_INVALID_PARAMETER;
goto exit;
}
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "ArchiverImpl::AutoAttach() about to create collector");
hr = ArchiveStateCollector::Create(m_ptrSession, m_lpLogger, &ptrArchiveStateCollector);
if (hr != hrSuccess)
goto exit;
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "ArchiverImpl::AutoAttach() about to get state updater");
hr = ptrArchiveStateCollector->GetArchiveStateUpdater(&ptrArchiveStateUpdater);
if (hr != hrSuccess)
goto exit;
if (ulFlags == 0) {
if (parseBool(m_lpsConfig->GetSetting("auto_attach_writable")))
ulFlags = ArchiveManage::Writable;
else
ulFlags = ArchiveManage::ReadOnly;
}
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "ArchiverImpl::AutoAttach() about to call update all");
hr = ptrArchiveStateUpdater->UpdateAll(ulFlags);
exit:
return MAPIErrorToArchiveError(hr);
}
// FREE OPERATORS
JsonEntity* JsonParser::fromString( const std::string& rawJson )
{
for( int i=0; i < rawJson.length(); i++ )
{
if( rawJson[i] == '[' )
{
i = parseArray( rawJson, i );
}
else if( rawJson[i] == 't' || rawJson[i] == 'f' )
{
i = parseBool( rawJson, i );
}
else if( rawJson[i] == '{' )
{
i = parseObject( rawJson, i );
}
else if( rawJson[i] == '-' || ( rawJson[i] >= '0' && rawJson[i] <= '9' ) )
{
i = parseNumber( rawJson, i );
}
else if( rawJson[i] == '"' )
{
i = parseString( rawJson, i );
}
}
}
bool getAttrib(const TiXmlElement* XMLNode, const gkString& attrib, bool& value)
{
if (!XMLNode || !XMLNode->Attribute(attrib)) return false;
value = parseBool(XMLNode->Attribute(attrib.c_str()));
return true;
}
static void add(Setting_t type, Update_t update, const char* key, const char* val)
{
Setting* const s = malloc(sizeof(Setting));
s->type = type;
s->update = update;
switch(type) {
case INT: {
s->value[0].integer = atoi(val);
s->value[1].integer = s->value[0].integer;
} break;
case BOOL: {
s->value[0].boolean = parseBool(val);
s->value[1].boolean = s->value[0].boolean;
} break;
case STR: {
strncpy(s->value[0].string, val, sizeof(s->value[0].string) - 1);
s->value[0].string[sizeof(s->value[0].string) - 1] = '\0';
strcpy(s->value[1].string, s->value[0].string);
} break;
}
a_strhash_add(settings, key, s);
}
bool ConfigReader::getBool(const std::string theSection,
const std::string theName, const bool theDefault) const
{
bool anResult = theDefault;
// Check if theSection really exists
std::map<const std::string, typeNameValue*>::const_iterator iter;
iter = mSections.find(theSection);
if (iter != mSections.end())
{
// Try to obtain the name, value pair
typeNameValue* anMap = iter->second;
if (NULL != anMap)
{
typeNameValueIter iterNameValue;
iterNameValue = anMap->find(theName);
if (iterNameValue != anMap->end())
{
anResult = parseBool(iterNameValue->second, theDefault);
}
}
}
// Return the result found or theDefault assigned above
return anResult;
}
bool Properties::getBool(const std::string& key, bool defaultValue,
bool terse) const
{
bool result;
const_iterator iter = find(key);
if (iter == end()) {
if (terse) {
Log::log(logID, Log::LOG_MAX_DEBUG,
"No value specified for key %s, using default value.",
key.c_str());
}
result = defaultValue;
} else {
try {
result = parseBool(key, iter->second);
} catch (...) {
if (terse) {
Log::log(logID, Log::LOG_MAX_DEBUG,
"Invalid value specified for key %s, using default value.",
key.c_str());
}
result = defaultValue;
}
}
return result;
}
bool ConfigReader::getBool(const std::string theSection,
const std::string theName, const bool theDefault) const
{
bool anResult = theDefault;
// Comprueba si la sección existe
std::map<const std::string, typeNameValue*>::const_iterator iter;
iter = this->sections.find(theSection);
if (iter != this->sections.end())
{
// Intenta obtener el par <clave, valor>
typeNameValue* anMap = iter->second;
if (NULL != anMap)
{
typeNameValueIter iterNameValue;
iterNameValue = anMap->find(theName);
if (iterNameValue != anMap->end())
{
anResult = parseBool(iterNameValue->second, theDefault);
}
}
}
// Devuelve el resultado encontrado o el valor de theDefault
return anResult;
}
static void set(const char* key, const char* val, bool respect)
{
Setting* const s = a_strhash_get(settings, key);
if(s == NULL) {
a_error("Setting '%s' does not exist", key);
return;
} else if(respect
&& (s->update == SET_FROZEN || (s->update == SET_ONCE && frozen))) {
a_error("Setting '%s' is frozen", key);
return;
}
switch(s->type) {
case INT: {
s->value[1].integer = s->value[0].integer;
s->value[0].integer = atoi(val);
} break;
case BOOL: {
s->value[1].boolean = s->value[0].boolean;
s->value[0].boolean = parseBool(val);
} break;
case STR: {
strcpy(s->value[1].string, s->value[0].string);
strncpy(s->value[0].string, val, sizeof(s->value[0].string) - 1);
} break;
}
if(s->update == SET_ONCE) {
s->update = SET_FROZEN;
}
}
void
EmsMessage::parseRCHKOpmodeMessage(EmsValue::SubType subtype)
{
parseEnum(0, EmsValue::HeizArt, subtype);
parseNumeric(1, 1, 2, EmsValue::NachtTemp, subtype);
parseNumeric(2, 1, 2, EmsValue::TagTemp, subtype);
parseNumeric(3, 1, 2, EmsValue::UrlaubTemp, subtype);
parseNumeric(4, 1, 2, EmsValue::RaumEinfluss, subtype);
parseNumeric(6, 1, 2, EmsValue::RaumOffset, subtype);
parseEnum(7, EmsValue::Betriebsart, subtype);
parseNumeric(16, 1, 1, EmsValue::MinTemp, subtype);
parseNumeric(35, 1, 1, EmsValue::MaxTemp, subtype);
parseBool(19, 1, EmsValue::SchaltzeitOptimierung, subtype);
parseNumeric(22, 1, 1, EmsValue::SchwelleSommerWinter, subtype);
parseNumeric(23, 1, 1, EmsValue::FrostSchutzTemp, subtype);
parseEnum(25, EmsValue::RegelungsArt, subtype);
parseEnum(28, EmsValue::Frostschutz, subtype);
parseEnum(32, EmsValue::HeizSystem, subtype);
parseEnum(33, EmsValue::FuehrungsGroesse, subtype);
parseNumeric(36, 1, 1, EmsValue::AuslegungsTemp, subtype);
parseNumeric(37, 1, 2, EmsValue::RaumUebersteuerTemp, subtype);
parseNumeric(38, 1, 1, EmsValue::AbsenkungsAbbruchTemp, subtype);
parseNumeric(39, 1, 1, EmsValue::AbsenkungsSchwellenTemp, subtype);
parseNumeric(40, 1, 1, EmsValue::UrlaubAbsenkungsSchwellenTemp, subtype);
parseEnum(41, EmsValue::UrlaubAbsenkungsArt, subtype);
}
void
EmsMessage::parseRCSystemParameterMessage()
{
parseNumeric(5, 1, 1, EmsValue::MinTemp, EmsValue::Aussen);
parseEnum(6, EmsValue::GebaeudeArt, EmsValue::None);
parseBool(21, 1, EmsValue::ATDaempfung, EmsValue::None);
}
void
EmsMessage::parseWMTemp1Message()
{
parseNumeric(0, 2, 10, EmsValue::IstTemp, EmsValue::HK1);
/* Byte 2 = 0 -> Pumpe aus, 100 = 0x64 -> Pumpe an */
parseBool(2, 2, EmsValue::PumpeAktiv, EmsValue::HK1);
}
bool getValue(const TiXmlElement* XMLNode, bool& value)
{
if (!XMLNode || !XMLNode->GetText())
return false;
value = parseBool(XMLNode->GetText());
return true;
}
bool
CJString::
toBoolean() const
{
COptBool b = parseBool(text_);
return b.getValue(false);
}
void
EmsMessage::parseUBAParameterWWMessage()
{
parseBool(1, 0, EmsValue::KesselSchalter, EmsValue::WW);
parseNumeric(2, 1, 1, EmsValue::SetTemp, EmsValue::WW);
parseNumeric(8, 1, 1, EmsValue::DesinfektionsTemp, EmsValue::WW);
parseEnum(7,EmsValue::Schaltpunkte, EmsValue::Zirkulation);
}
bool ConfigManager::getBool(const String &key, const String &domName) const {
String value(get(key, domName));
bool val;
if (parseBool(value, val))
return val;
error("ConfigManager::getBool(%s,%s): '%s' is not a valid bool",
key.c_str(), domName.c_str(), value.c_str());
}
/*
* Throws
* std::invalid_argument if a value for key is not found.
* std::domain_error if value does not have a boolean value of
* "true", "yes", "on", "false", "no", "off", all case insensitive.
*/
bool Properties::getBool(const std::string& key) const
{
const_iterator iter = find(key);
if (iter == end()) {
throw std::invalid_argument(key + " not found");
}
return parseBool(key, iter->second);
}
bool AbstractConfiguration::getBool(const std::string& key) const
{
Mutex::ScopedLock lock(_mutex);
std::string value;
if (getRaw(key, value))
return parseBool(internalExpand(value));
else
throw NotFoundException(key);
}
void
EmsMessage::parseMMTempMessage()
{
parseNumeric(0, 1, 1, EmsValue::SollTemp, EmsValue::HK2);
parseNumeric(1, 2, 10, EmsValue::IstTemp, EmsValue::HK2);
parseNumeric(3, 1, 1, EmsValue::Mischersteuerung, EmsValue::None);
/* Byte 3 = 0 -> Pumpe aus, 100 = 0x64 -> Pumpe an */
parseBool(3, 2, EmsValue::PumpeAktiv, EmsValue::HK2);
}
bool AbstractConfiguration::getBool(const std::string& key, bool defaultValue) const
{
Mutex::ScopedLock lock(_mutex);
std::string value;
if (getRaw(key, value))
return parseBool(internalExpand(value));
else
return defaultValue;
}
bool Configuration::getBool(const String &key) const {
ASSERT(!key.empty());
if(key.empty())
throw IllegalArgumentException("Property key is not valid");
String value;
if (getUnparsedString(key, value))
return parseBool(value);
throw NoSuchPropertyException("Property not found: " + key);
}
bool Configuration::getBool(const String &key, const bool defaultValue) const {
ASSERT(!key.empty());
if(key.empty())
throw IllegalArgumentException("Property key is not valid");
String value;
if (getUnparsedString(key, value))
return parseBool(value);
return defaultValue;
}
void
EmsMessage::parseUBAMonitorFastMessage()
{
parseNumeric(0, 1, 1, EmsValue::SollTemp, EmsValue::Kessel);
parseNumeric(1, 2, 10, EmsValue::IstTemp, EmsValue::Kessel);
parseNumeric(11, 2, 10, EmsValue::IstTemp, EmsValue::WW);
parseNumeric(13, 2, 10, EmsValue::IstTemp, EmsValue::Ruecklauf);
parseNumeric(3, 1, 1, EmsValue::SollModulation, EmsValue::Brenner);
parseNumeric(4, 1, 1, EmsValue::IstModulation, EmsValue::Brenner);
parseNumeric(15, 2, 10, EmsValue::Flammenstrom, EmsValue::None);
parseNumeric(17, 1, 10, EmsValue::Systemdruck, EmsValue::None);
if (canAccess(18, 2)) {
std::ostringstream ss;
ss << m_data[18] << m_data[19];
m_valueHandler(EmsValue(EmsValue::ServiceCode, EmsValue::None, ss.str()));
}
if (canAccess(20, 2)) {
std::ostringstream ss;
ss << std::dec << (m_data[20] << 8 | m_data[21]);
m_valueHandler(EmsValue(EmsValue::FehlerCode, EmsValue::None, ss.str()));
}
parseBool(7, 0, EmsValue::FlammeAktiv, EmsValue::None);
parseBool(7, 2, EmsValue::BrennerAktiv, EmsValue::None);
parseBool(7, 3, EmsValue::ZuendungAktiv, EmsValue::None);
parseBool(7, 5, EmsValue::PumpeAktiv, EmsValue::Kessel);
parseBool(7, 6, EmsValue::DreiWegeVentilAufWW, EmsValue::None);
parseBool(7, 7, EmsValue::ZirkulationAktiv, EmsValue::None);
}
void
EmsMessage::parseUBAParametersMessage()
{
parseBool(0, 1, EmsValue::KesselSchalter, EmsValue::Kessel);
parseNumeric(1, 1, 1, EmsValue::SetTemp, EmsValue::Kessel);
parseNumeric(2, 1, 1, EmsValue::MaxModulation, EmsValue::Brenner);
parseNumeric(3, 1, 1, EmsValue::MinModulation, EmsValue::Brenner);
parseNumeric(4, 1, 1, EmsValue::AusschaltHysterese, EmsValue::Kessel);
parseNumeric(5, 1, 1, EmsValue::EinschaltHysterese, EmsValue::Kessel);
parseInteger(6, 1, EmsValue::AntipendelZeit, EmsValue::None);
parseInteger(8, 1, EmsValue::NachlaufZeit, EmsValue::KesselPumpe);
parseNumeric(9, 1, 1, EmsValue::MaxModulation, EmsValue::KesselPumpe);
parseNumeric(10, 1, 1, EmsValue::MinModulation, EmsValue::KesselPumpe);
}
bool MythUIStateType::ParseElement(
const QString &filename, QDomElement &element, bool showWarnings)
{
QMap<QString, QString> dependsMap;
if (element.tagName() == "showempty")
m_ShowEmpty = parseBool(element);
else if (element.tagName() == "state")
{
QString name = element.attribute("name", "");
QString type = element.attribute("type", "");
QString statename;
if (!type.isEmpty())
statename = type;
else
statename = name;
element.setAttribute("name", statename);
MythUIGroup *uitype = dynamic_cast<MythUIGroup *>
(ParseUIType(filename, element, "group", this, NULL, showWarnings, dependsMap));
if (!type.isEmpty())
{
StateType stype = None;
if (type == "off")
stype = Off;
else if (type == "half")
stype = Half;
else if (type == "full")
stype = Full;
if (uitype && !m_ObjectsByState.contains((int)stype))
AddObject(stype, uitype);
}
else if (!name.isEmpty())
{
if (uitype && !m_ObjectsByName.contains(name))
AddObject(name, uitype);
}
}
else
{
return MythUIType::ParseElement(filename, element, showWarnings);
}
return true;
}
void
EmsMessage::parseUBAMonitorWWMessage()
{
parseNumeric(0, 1, 1, EmsValue::SollTemp, EmsValue::WW);
parseNumeric(1, 2, 10, EmsValue::IstTemp, EmsValue::WW);
parseInteger(10, 3, EmsValue::WarmwasserbereitungsZeit, EmsValue::None);
parseInteger(13, 3, EmsValue::WarmwasserBereitungen, EmsValue::None);
parseBool(5, 0, EmsValue::Tagbetrieb, EmsValue::WW);
parseBool(5, 1, EmsValue::EinmalLadungAktiv, EmsValue::WW);
parseBool(5, 2, EmsValue::DesinfektionAktiv, EmsValue::WW);
parseBool(5, 3, EmsValue::WarmwasserBereitung, EmsValue::None);
parseBool(5, 4, EmsValue::NachladungAktiv, EmsValue::WW);
parseBool(5, 5, EmsValue::WarmwasserTempOK, EmsValue::None);
parseBool(7, 0, EmsValue::Tagbetrieb, EmsValue::Zirkulation);
parseBool(7, 2, EmsValue::ZirkulationAktiv, EmsValue::None);
parseEnum(8, EmsValue::WWSystemType, EmsValue::None);
}
bool testParseBool(void) {
if(!parseBool("true")) {
printf("'true' is not true\n");
return false;
}
if(!parseBool("True")) {
printf("'True' is not true\n");
return false;
}
if(!parseBool("TRUE")) {
printf("'TRUE' is not true\n");
return false;
}
if(parseBool("false")) {
printf("'false' is not false\n");
return false;
}
if(parseBool("blort")) {
printf("'blort' is not false\n");
return false;
}
if(parseBool("")) {
printf("'' is not false\n");
return false;
}
if(parseBool(NULL)) {
printf("NULL is not false\n");
return false;
}
if(parseBool(0)) {
printf("0 is not false\n");
return false;
}
return true;
}
bool MythUIStateType::ParseElement(QDomElement &element)
{
if (element.tagName() == "showempty")
m_ShowEmpty = parseBool(element);
else if (element.tagName() == "state")
{
QString name = element.attribute("name", "").lower();
QString type = element.attribute("type", "").lower();
MythUIType *uitype = ParseChildren(element, this);
if (!type.isEmpty())
{
StateType stype = None;
if (type == "off")
stype = Off;
else if (type == "half")
stype = Half;
else if (type == "full")
stype = Full;
if (uitype && m_ObjectsByState.contains((int)stype))
{
delete m_ObjectsByState[(int)stype];
m_ObjectsByState.erase((int)stype);
}
AddObject(stype, uitype);
}
else if (!name.isEmpty())
{
if (uitype && m_ObjectsByName.contains(name))
{
delete m_ObjectsByName[name];
m_ObjectsByName.erase(name);
}
AddObject(name, uitype);
}
}
else
return MythUIType::ParseElement(element);
return true;
}
