* See the License for the specific language governing permissions and
* limitations under the License.
*/
- /**
+/**
* This file have been implemented in compliance with W3C WARP SPEC.
* but there are some patent issue between W3C WARP SPEC and APPLE.
* so if you want to use this file, refer to the README file in root directory
}
void UpdateTextWithDirectionMark(Direction direction,
- DPL::String* text)
+ DPL::String* text)
{
Assert(text);
switch (direction) {
break;
default:
Assert(false);
+ break;
}
}
} // namespace Unicode
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &InnerElementsParser::Other);
}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const Text& text)
{
InnerElementsParser(ElementParserPtr parent) :
m_parentParser(parent),
m_textDirection(Unicode::EMPTY)
- {
- }
+ {}
ElementParserPtr Other()
{
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &NameParser::Other);
}
}
NameParser(Unicode::Direction direction,
- ConfigParserData& data) :
+ ConfigParserData& data) :
m_data(data),
m_textDirection(direction)
- {
- }
+ {}
ElementParserPtr Other()
{
};
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &AccessParser::Other);
}
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
void AcceptWac(const XmlAttribute& attribute)
{
break;
default:
LogError("Error in Access tag - unknown standard.");
+ break;
}
}
return;
}
+ if(m_strIRIOrigin == L"*") //wildcard match means yes for subdomains
+ {
+ m_bSubDomainAccess = true;
+ }
+
ConfigParserData::AccessInfo accessInfo(m_strIRIOrigin,
m_bSubDomainAccess);
- std::pair <ConfigParserData::AccessInfoSet::iterator, bool> ret =
- m_data.accessInfoSet.insert(accessInfo);
+ //std::pair <ConfigParserData::AccessInfoSet::iterator, bool> ret =
+ m_data.accessInfoSet.insert(accessInfo);
}
virtual void Verify()
break;
default:
LogError("Error in Access tag - unknown standard.");
+ break;
}
}
m_standardType(STANDARD_TYPE_NONE),
m_network(false),
m_data(data)
- {
- }
+ {}
ElementParserPtr Other()
{
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &DescriptionParser::Other);
}
}
DescriptionParser(Unicode::Direction direction,
- ConfigParserData& data) :
+ ConfigParserData& data) :
m_data(data),
m_lang(),
m_description(),
m_textDirection(direction)
- {
- }
+ {}
private:
ConfigParserData& m_data;
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &AuthorParser::Other);
}
AuthorParser(Unicode::Direction direction,
- ConfigParserData& data) :
+ ConfigParserData& data) :
m_data(data),
m_textDirection(direction)
- {
- }
+ {}
virtual void Accept(const Element& /*element*/)
{
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return DPL::MakeDelegate(this, &LicenseParser::Other);
}
LicenseParser(Unicode::Direction direction,
- ConfigParserData& data) :
+ ConfigParserData& data) :
m_data(data),
m_ignore(true),
m_textDirection(direction)
- {
- }
+ {}
virtual void Accept(const Element& element)
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
IconParser(ConfigParserData& data) : ElementParser(),
m_data(data)
- {
- }
+ {}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const XmlAttribute& attribute)
{
strtol(DPL::ToUTF8String(value).c_str(), &reterr, 10);
if (errno != 0 ||
std::string(reterr) == DPL::ToUTF8String(value) ||
- valueInt <= 0) {
+ valueInt <= 0)
+ {
return DPL::OptionalInt::Null;
} else {
return valueInt;
}
/**
- * @brief delocalizePath removes locales folder from relative path if neccessary
+ * @brief delocalizePath removes locales folder from relative path if
+ * neccessary
* @param source source string
*
* @throw BadSrcError if string is bad value of src attribute
DPL::String result = source;
- if(source.substr(0,index) == localeFolder)
- {
- size_t pos = result.find_first_of('/',index);
- if(pos != std::string::npos && pos + 1 < source.size())
- {
- result = result.substr(pos + 1,source.size());
- }
- else
- {
+ if (source.substr(0, index) == localeFolder) {
+ size_t pos = result.find_first_of('/', index);
+ if (pos != std::string::npos && pos + 1 < source.size()) {
+ result = result.substr(pos + 1, source.size());
+ } else {
Throw(BadSrcError);
}
}
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
ContentParser(ConfigParserData& data) :
ElementParser(),
m_data(data)
- {
- }
+ {}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Accept(const XmlAttribute& attribute)
{
ConfigParserData& m_data;
};
-class FeatureParser : public ElementParser
-{
- public:
- struct ParamParser : public ElementParser
- {
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
- {
- return &IgnoringParser::Create;
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- m_name = attribute.value;
- NormalizeString(m_name);
- } else if (attribute.name == L"value") {
- m_value = attribute.value;
- NormalizeString(m_value);
- }
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- ThrowMsg(Exception::ParseError, "param element must be empty");
- }
-
- virtual void Verify()
- {
- if (m_name.IsNull() || *m_name == L"") {
- return;
- }
- if (m_value.IsNull() || *m_value == L"") {
- return;
- }
-
- ConfigParserData::Param param(*m_name);
- param.value = *m_value;
-
- if (m_data.paramsList.find(param) == m_data.paramsList.end()) {
- m_data.paramsList.insert(param);
- }
- }
-
- ParamParser(ConfigParserData::Feature& data) :
- ElementParser(),
- m_data(data)
- {
- }
-
- private:
- DPL::OptionalString m_name;
- DPL::OptionalString m_value;
- ConfigParserData::Feature& m_data;
- };
-
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
- {
- if (name == L"param") {
- return DPL::MakeDelegate(this, &FeatureParser::OnParamElement);
- } else {
- return &IgnoringParser::Create;
- }
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- m_feature.name = attribute.value;
- } else if (attribute.name == L"required") {
- if (attribute.value == L"false") {
- m_feature.required = false;
- } else {
- m_feature.required = true;
- }
- }
- }
-
- virtual void Verify()
- {
- LibIri::Wrapper iri(DPL::ToUTF8String(m_feature.name).c_str());
-
- if (m_feature.name != L"") {
- if (iri.Validate()) {
- if (m_data.featuresList.find(m_feature) ==
- m_data.featuresList.end()) {
- m_data.featuresList.insert(m_feature);
- } else {
- LogDebug("Ignoring feature with name" <<
- DPL::ToUTF8String(m_feature.name));
- }
- } else {
- if (m_feature.required) {
- //Throw only if required
- ThrowMsg(Exception::ParseError, "invalid feature IRI");
- }
- }
- }
- }
-
- ElementParserPtr OnParamElement()
- {
- return ElementParserPtr(new ParamParser(m_feature));
- }
-
- FeatureParser(ConfigParserData& data) :
- ElementParser(),
- m_data(data),
- m_feature(L"")
- {
- }
-
- private:
- ConfigParserData& m_data;
- ConfigParserData::Feature m_feature;
-};
-
class PreferenceParser : public ElementParser
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const Text& /*text*/)
{
ConfigParserData::Preference preference(*m_name, m_required);
preference.value = m_value;
if (m_data.preferencesList.find(preference) ==
- m_data.preferencesList.end()) {
+ m_data.preferencesList.end())
+ {
m_data.preferencesList.insert(preference);
}
}
ElementParser(),
m_required(false),
m_data(data)
- {
- }
+ {}
private:
DPL::OptionalString m_name;
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &DenyAllParser::Create;
}
ThrowMsg(Exception::ParseError,
"rel attribute must have describedby value");
}
- } else if (attribute.name == L"type") {
- } else if (attribute.name == L"href") {
+ } else if (attribute.name == L"type") {} else if (attribute.name ==
+ L"href")
+ {
LogDebug("here is href");
m_href = attribute.value;
} else {
m_properNamespace(false),
m_data(data),
m_href(DPL::OptionalString::Null)
- {
- }
+ {}
private:
bool m_properNamespace;
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const XmlAttribute& attribute)
{
}
virtual void Verify()
- {
- }
+ {}
SettingParser(ConfigParserData& data) :
ElementParser(),
m_data(data),
m_setting(L"", L"")
- {
- }
+ {}
private:
ConfigParserData& m_data;
m_scheme = attribute.value;
} else if (attribute.name == L"mime") {
m_mime = attribute.value;
+ } else if (attribute.name == L"disposition") {
+ if (attribute.value == L"inline")
+ m_disposition =
+ ConfigParserData::ServiceInfo::Disposition::INLINE;
}
}
LogWarning("namespace for app service = " << element.ns);
if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
ThrowMsg(Exception::ParseError,
- "Wrong xml namespace for widget element");
+ "Wrong xml namespace for widget element");
}
}
NormalizeString(m_scheme);
NormalizeString(m_mime);
+ // exception
+ DPL::String ignoreUri(L"file");
+
+ if (!m_scheme.IsNull() && *m_scheme == ignoreUri)
+ {
+ LogInfo("exception : '" << *m_scheme << "' scheme will be ignored.");
+ m_scheme = DPL::OptionalString::Null;
+ }
+
// verify duplicate element
DPL::String wildString(L"*/*");
DPL::String nullString(L"");
ConfigParserData::ServiceInfo serviceInfo(
- m_src.IsNull() ? nullString:*m_src,
- m_operation.IsNull() ? nullString:*m_operation,
- m_scheme.IsNull() ? nullString:*m_scheme,
- m_mime.IsNull() ? nullString:*m_mime);
+ m_src.IsNull() ? nullString : *m_src,
+ m_operation.IsNull() ? nullString : *m_operation,
+ m_scheme.IsNull() ? nullString : *m_scheme,
+ m_mime.IsNull() ? nullString : *m_mime,
+ m_disposition);
FOREACH(iterator, m_data.appServiceList) {
if (iterator->m_operation == serviceInfo.m_operation &&
// check scheme
(iterator->m_scheme == serviceInfo.m_scheme ||
- // check input scheme is "*/*" case
- (iterator->m_scheme == wildString &&
- serviceInfo.m_scheme != nullString) ||
- // check iterator scheme is "*/*" case
- (serviceInfo.m_scheme == wildString &&
- iterator->m_scheme != nullString)) &&
+ // check input scheme is "*/*" case
+ (iterator->m_scheme == wildString &&
+ serviceInfo.m_scheme != nullString) ||
+ // check iterator scheme is "*/*" case
+ (serviceInfo.m_scheme == wildString &&
+ iterator->m_scheme != nullString)) &&
(iterator->m_mime == serviceInfo.m_mime ||
- // check input mime is "*/*" case
- (iterator->m_mime == wildString &&
- serviceInfo.m_mime != nullString) ||
- // check iterator mime is "*/*" case
- (serviceInfo.m_mime == wildString &&
- iterator->m_mime != nullString)))
+ // check input mime is "*/*" case
+ (iterator->m_mime == wildString &&
+ serviceInfo.m_mime != nullString) ||
+ // check iterator mime is "*/*" case
+ (serviceInfo.m_mime == wildString &&
+ iterator->m_mime != nullString)))
{
ThrowMsg(Exception::ParseError,
- "service operation is duplicated " +
- DPL::ToUTF8String(*m_operation));
+ "service operation is duplicated " +
+ DPL::ToUTF8String(*m_operation));
}
}
m_data.appServiceList.push_back(serviceInfo);
m_operation(DPL::OptionalString::Null),
m_scheme(DPL::OptionalString::Null),
m_mime(DPL::OptionalString::Null),
+ m_disposition(ConfigParserData::ServiceInfo::Disposition::WINDOW),
m_data(data)
- {
- }
+ {}
private:
DPL::OptionalString m_src;
DPL::OptionalString m_operation;
DPL::OptionalString m_scheme;
DPL::OptionalString m_mime;
+ ConfigParserData::ServiceInfo::Disposition m_disposition;
ConfigParserData& m_data;
};
class AppControlParser : public ElementParser
{
public:
- struct SourceParser : public ElementParser
- {
- public:
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
- {
- return &IgnoringParser::Create;
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- if (attribute.value.size() > 0) {
- m_value = attribute.value;
- NormalizeString(m_value);
- }
- }
- }
-
- virtual void Verify()
- {
- if (m_value.IsNull() || *m_value== L"") {
- return;
- }
-
- m_data.m_src = *m_value;
- }
-
- SourceParser(ConfigParserData::AppControlInfo& data) :
- ElementParser(),
- m_properNamespace(false),
- m_data(data)
- {
- }
-
- private:
- bool m_properNamespace;
- DPL::OptionalString m_value;
- ConfigParserData::AppControlInfo& m_data;
- };
-
- struct OperationParser : public ElementParser
- {
- public:
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
- {
- return &IgnoringParser::Create;
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- if (attribute.value.size() > 0) {
- m_value = attribute.value;
- NormalizeString(m_value);
- }
- }
- }
-
- virtual void Verify()
- {
- if (m_value.IsNull() || *m_value== L"") {
- return;
- }
-
- m_data.m_operation = *m_value;
- }
-
- OperationParser(ConfigParserData::AppControlInfo& data) :
- ElementParser(),
- m_properNamespace(false),
- m_data(data)
- {
- }
-
- private:
- bool m_properNamespace;
- DPL::OptionalString m_value;
- ConfigParserData::AppControlInfo& m_data;
- };
-
- struct UriParser : public ElementParser
- {
- public:
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
- {
- return &IgnoringParser::Create;
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- if (attribute.value.size() > 0) {
- m_value = attribute.value;
- NormalizeString(m_value);
- }
- }
- }
-
- virtual void Verify()
- {
- if (m_value.IsNull() || *m_value == L"") {
- return;
- }
-
- DPL::String wildString(L"*/*");
- if ((m_data.m_uriList.find(wildString) ==
- m_data.m_uriList.end())
- && (m_data.m_uriList.find(*m_value) ==
- m_data.m_uriList.end())) {
-
- m_data.m_uriList.insert(*m_value);
- } else {
- LogDebug("Ignoring uri with name" <<
- DPL::ToUTF8String(*m_value));
- }
- }
-
- UriParser(ConfigParserData::AppControlInfo& data) :
- ElementParser(),
- m_properNamespace(false),
- m_data(data)
- {
- }
-
- private:
- bool m_properNamespace;
- DPL::OptionalString m_value;
- ConfigParserData::AppControlInfo& m_data;
- };
-
- struct MimeParser : public ElementParser
- {
- public:
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
- {
- return &IgnoringParser::Create;
- }
-
- virtual void Accept(const Text& /*text*/)
- {
- }
-
- virtual void Accept(const Element& /*element*/)
- {
- }
-
- virtual void Accept(const XmlAttribute& attribute)
- {
- if (attribute.name == L"name") {
- if (attribute.value.size() > 0) {
- m_value = attribute.value;
- NormalizeString(m_value);
- }
- }
- }
-
- virtual void Verify()
- {
- if (m_value.IsNull() || *m_value == L"") {
- return;
- }
-
- DPL::String wildString(L"*/*");
- if ((m_data.m_mimeList.find(wildString) ==
- m_data.m_mimeList.end())
- && (m_data.m_mimeList.find(*m_value) ==
- m_data.m_mimeList.end())) {
- m_data.m_mimeList.insert(*m_value);
- } else {
- LogDebug("Ignoring mime with name" <<
- DPL::ToUTF8String(*m_value));
- }
- }
-
- MimeParser(ConfigParserData::AppControlInfo& data) :
- ElementParser(),
- m_properNamespace(false),
- m_data(data)
- {
- }
-
- private:
- bool m_properNamespace;
- DPL::OptionalString m_value;
- ConfigParserData::AppControlInfo& m_data;
- };
-
- virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ struct SourceParser : public ElementParser
{
- if (name == L"src") {
- return DPL::MakeDelegate(this, &AppControlParser::OnSourceElement);
- } else if (name == L"operation") {
- return DPL::MakeDelegate(this, &AppControlParser::OnOperationElement);
- } else if (name == L"uri") {
- return DPL::MakeDelegate(this, &AppControlParser::OnUriElement);
- } else if (name == L"mime") {
- return DPL::MakeDelegate(this, &AppControlParser::OnMimeElement);
- } else {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
return &IgnoringParser::Create;
}
- }
- virtual void Accept(const XmlAttribute& attribute)
- {
- }
+ virtual void Accept(const Text& /*text*/)
+ {}
- virtual void Accept(const Element& element)
- {
- LogWarning("namespace for app service = " << element.ns);
- if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
- ThrowMsg(Exception::ParseError,
- "Wrong xml namespace for widget element");
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"name") {
+ if (attribute.value.size() > 0) {
+ m_value = attribute.value;
+ NormalizeString(m_value);
+ }
+ }
}
- }
- virtual void Accept(const Text& /*text*/)
- {
- ThrowMsg(Exception::ParseError, "param element must be empty");
- }
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
- virtual void Verify()
- {
- if (m_appControl.m_src == L""){
- LogWarning("service element must have src element");
- return;
+ m_data.m_src = *m_value;
}
- if (m_appControl.m_operation == L""){
- LogWarning("service element must have operation element");
- return;
+ SourceParser(ConfigParserData::AppControlInfo& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_value;
+ ConfigParserData::AppControlInfo& m_data;
+ };
+
+ struct OperationParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
}
- FOREACH(iterator, m_data.appControlList) {
- if (iterator->m_src == m_appControl.m_src &&
- iterator->m_operation == m_appControl.m_operation )
- {
- ThrowMsg(Exception::ParseError,
- "app control element is duplicated " +
- DPL::ToUTF8String(m_appControl.m_src) + ", " +
- DPL::ToUTF8String(m_appControl.m_operation));
+ virtual void Accept(const Text& /*text*/)
+ {}
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"name") {
+ if (attribute.value.size() > 0) {
+ m_value = attribute.value;
+ NormalizeString(m_value);
+ }
}
}
- m_data.appControlList.push_back(m_appControl);
- }
- ElementParserPtr OnSourceElement()
- {
- return ElementParserPtr(new SourceParser(m_appControl));
- }
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
- ElementParserPtr OnOperationElement()
- {
- return ElementParserPtr(new OperationParser(m_appControl));
- }
+ m_data.m_operation = *m_value;
+ }
- ElementParserPtr OnUriElement()
- {
+ OperationParser(ConfigParserData::AppControlInfo& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_value;
+ ConfigParserData::AppControlInfo& m_data;
+ };
+
+ struct UriParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ virtual void Accept(const Text& /*text*/)
+ {}
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"name") {
+ if (attribute.value.size() > 0) {
+ m_value = attribute.value;
+ NormalizeString(m_value);
+ }
+ }
+ }
+
+ virtual void Verify()
+ {
+ // exception
+ DPL::String ignoreUri(L"file");
+
+ if (!m_value.IsNull() && *m_value == ignoreUri)
+ {
+ LogInfo("exception : '" << *m_value << "' scheme will be ignored.");
+ m_value = DPL::OptionalString::Null;
+ }
+
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
+
+ DPL::String wildString(L"*/*");
+ if ((m_data.m_uriList.find(wildString) == m_data.m_uriList.end())
+ && (m_data.m_uriList.find(*m_value) == m_data.m_uriList.end()))
+ {
+ m_data.m_uriList.insert(*m_value);
+ } else {
+ LogDebug("Ignoring uri with name" <<
+ DPL::ToUTF8String(*m_value));
+ }
+ }
+
+ UriParser(ConfigParserData::AppControlInfo& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_value;
+ ConfigParserData::AppControlInfo& m_data;
+ };
+
+ struct MimeParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ virtual void Accept(const Text& /*text*/)
+ {}
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"name") {
+ if (attribute.value.size() > 0) {
+ m_value = attribute.value;
+ NormalizeString(m_value);
+ }
+ }
+ }
+
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
+
+ DPL::String wildString(L"*/*");
+ if ((m_data.m_mimeList.find(wildString) ==
+ m_data.m_mimeList.end())
+ && (m_data.m_mimeList.find(*m_value) ==
+ m_data.m_mimeList.end()))
+ {
+ m_data.m_mimeList.insert(*m_value);
+ } else {
+ LogDebug("Ignoring mime with name" <<
+ DPL::ToUTF8String(*m_value));
+ }
+ }
+
+ MimeParser(ConfigParserData::AppControlInfo& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_value;
+ ConfigParserData::AppControlInfo& m_data;
+ };
+
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& name)
+ {
+ if (name == L"src") {
+ return DPL::MakeDelegate(this, &AppControlParser::OnSourceElement);
+ } else if (name == L"operation") {
+ return DPL::MakeDelegate(this,
+ &AppControlParser::OnOperationElement);
+ } else if (name == L"uri") {
+ return DPL::MakeDelegate(this, &AppControlParser::OnUriElement);
+ } else if (name == L"mime") {
+ return DPL::MakeDelegate(this, &AppControlParser::OnMimeElement);
+ } else {
+ return &IgnoringParser::Create;
+ }
+ }
+
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Accept(const Element& element)
+ {
+ LogWarning("namespace for app service = " << element.ns);
+ if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
+ ThrowMsg(Exception::ParseError,
+ "Wrong xml namespace for widget element");
+ }
+ }
+
+ virtual void Accept(const Text& /*text*/)
+ {
+ ThrowMsg(Exception::ParseError, "param element must be empty");
+ }
+
+ virtual void Verify()
+ {
+ if (m_appControl.m_src == L"") {
+ LogWarning("service element must have src element");
+ return;
+ }
+
+ if (m_appControl.m_operation == L"") {
+ LogWarning("service element must have operation element");
+ return;
+ }
+
+ m_data.appControlList.push_back(m_appControl);
+ }
+
+ ElementParserPtr OnSourceElement()
+ {
+ return ElementParserPtr(new SourceParser(m_appControl));
+ }
+
+ ElementParserPtr OnOperationElement()
+ {
+ return ElementParserPtr(new OperationParser(m_appControl));
+ }
+
+ ElementParserPtr OnUriElement()
+ {
return ElementParserPtr(new UriParser(m_appControl));
}
{
return ElementParserPtr(new MimeParser(m_appControl));
}
-
+
AppControlParser(ConfigParserData& data) :
ElementParser(),
m_data(data),
m_appControl(L"")
- {
- }
+ {}
private:
ConfigParserData& m_data;
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
- virtual void Accept(const Text& text)
+ virtual void Accept(const Text& /*text*/)
{
if (m_properNamespace) {
LogDebug("text");
LogDebug("attribute");
if (attribute.name == L"id") {
m_id = attribute.value;
+ NormalizeAndTrimSpaceString(m_id);
+ } else if (attribute.name == L"package") {
+ m_package = attribute.value;
} else if (attribute.name == L"required_version") {
m_version = attribute.value;
NormalizeString(m_version);
virtual void Verify()
{
- if(!m_id) {
+ if (!m_id) {
ThrowMsg(Exception::ParseError,
"application element must have id attribute");
}
- if(!m_version) {
+ if (!!m_package) {
+ m_data.tizenPkgId = m_package;
+ }
+
+ if (!m_version) {
ThrowMsg(Exception::ParseError,
"application element must have required_version attribute");
}
//TODO check if id and version format is right
- m_data.tizenId = m_id;
+ m_data.tizenAppId = m_id;
m_data.tizenMinVersionRequired = m_version;
}
m_id(DPL::OptionalString::Null),
m_version(DPL::OptionalString::Null),
m_properNamespace(false)
- {
- }
+ {}
private:
ConfigParserData& m_data;
DPL::OptionalString m_id;
+ DPL::OptionalString m_package;
DPL::OptionalString m_version;
bool m_properNamespace;
};
}
}
- virtual void Accept(const Element& element)
- {
- }
+ virtual void Accept(const Element& /*element*/)
+ {}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
if (m_src.IsNull()) {
- LogWarning("src attribute of splash element is mandatory - ignoring");
+ LogWarning(
+ "src attribute of splash element is mandatory - ignoring");
return;
}
SplashParser(ConfigParserData& data) :
ElementParser(),
m_data(data)
- {
- }
+ {}
private:
DPL::OptionalString m_src;
}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
if (m_src.IsNull()) {
- LogWarning("src attribute of background element is mandatory - ignoring");
+ LogWarning(
+ "src attribute of background element is mandatory - ignoring");
return;
}
explicit BackgroundParser(ConfigParserData& data) :
m_data(data)
- {
- }
+ {}
private:
DPL::OptionalString m_src;
{
public:
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Accept(const Element& element)
{
m_privilege.name = attribute.value;
}
}
- m_feature.required = false;
}
virtual void Verify()
if (m_feature.name != L"") {
if (iri.Validate()) {
if (m_data.featuresList.find(m_feature) ==
- m_data.featuresList.end()) {
+ m_data.featuresList.end())
+ {
m_data.featuresList.insert(m_feature);
} else {
LogDebug("Ignoring feature with name" <<
- DPL::ToUTF8String(m_feature.name));
+ DPL::ToUTF8String(m_feature.name));
}
}
}
if (m_privilege.name != L"") {
if (iriPrivilege.Validate()) {
if (m_data.privilegeList.find(m_privilege) ==
- m_data.privilegeList.end()) {
+ m_data.privilegeList.end())
+ {
m_data.privilegeList.insert(m_privilege);
} else {
LogDebug("Ignoring privilege with name" <<
m_feature(L""),
m_privilege(L""),
m_properNamespace(false)
- {
- }
+ {}
private:
ConfigParserData& m_data;
}
virtual void Accept(const Element& /*element*/)
- {
- }
+ {}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
if (m_name.IsNull()) {
- LogWarning("name attribute of category element is mandatory - ignoring");
+ LogWarning(
+ "name attribute of category element is mandatory - ignoring");
return;
}
if (m_data.categoryList.find(*m_name) ==
- m_data.categoryList.end()) {
+ m_data.categoryList.end())
+ {
m_data.categoryList.insert(*m_name);
}
}
explicit CategoryParser(ConfigParserData& data) :
m_data(data)
- {
- }
+ {}
private:
DPL::OptionalString m_name;
ConfigParserData& m_data;
};
-class LiveboxParser : public ElementParser
+class AppWidgetParser : public ElementParser
{
- public:
+ public:
struct BoxLabelParser : public ElementParser
{
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
- virtual void Accept(const XmlAttribute& attribute)
- {
- }
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
virtual void Accept(const Text& text)
{
- if(m_properNamespace)
+ if (m_properNamespace) {
m_label = text.value;
+ }
}
virtual void Verify()
ElementParser(),
m_properNamespace(false),
m_data(data)
- {
- }
+ {}
- private:
+ private:
DPL::String m_label;
bool m_properNamespace;
ConfigParserData::LiveboxInfo& m_data;
struct BoxIconParser : public ElementParser
{
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
virtual void Accept(const XmlAttribute& attribute)
{
- if(m_properNamespace) {
+ if (m_properNamespace) {
if (attribute.name == L"src") {
m_icon = attribute.value;
}
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
ElementParser(),
m_properNamespace(false),
m_data(data)
- {
- }
+ {}
- private:
+ private:
DPL::String m_icon;
bool m_properNamespace;
ConfigParserData::LiveboxInfo& m_data;
struct BoxSizeParser : public ElementParser
{
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& /*name*/)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
virtual void Accept(const XmlAttribute& attribute)
{
- if(m_properNamespace) {
+ if (m_properNamespace) {
if (attribute.name == L"preview") {
m_preview = attribute.value;
}
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
virtual void Accept(const Text& text)
{
- if(m_properNamespace)
+ if (m_properNamespace) {
m_size = text.value;
+ }
}
virtual void Verify()
m_data.m_boxSize.push_back(boxSize);
}
- explicit BoxSizeParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
+ explicit BoxSizeParser(
+ ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
ElementParser(),
+ m_properNamespace(false),
m_data(data)
- {
- }
+ {}
- private:
+ private:
DPL::String m_size;
DPL::String m_preview;
bool m_properNamespace;
struct PdParser : public ElementParser
{
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ const DPL::String& /*name*/)
{
return &IgnoringParser::Create;
}
virtual void Accept(const XmlAttribute& attribute)
{
- if(m_properNamespace) {
+ if (m_properNamespace) {
if (attribute.name == L"src") {
m_src = attribute.value;
} else if (attribute.name == L"width") {
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
m_data.m_pdHeight = m_height;
}
- explicit PdParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
+ explicit PdParser(
+ ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
ElementParser(),
m_properNamespace(false),
m_data(data)
- {
- }
+ {}
- private:
+ private:
DPL::String m_src;
DPL::String m_width;
DPL::String m_height;
};
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ const DPL::String& name)
{
if (name == L"box-size") {
- return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnBoxSizeElement);
+ return DPL::MakeDelegate(
+ this,
+ &AppWidgetParser::BoxContentParser::
+ OnBoxSizeElement);
} else if (name == L"pd") {
- return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnPdElement);
- } else{
- ThrowMsg(Exception::ParseError, "No element parser for name: " << name);
+ return DPL::MakeDelegate(
+ this,
+ &AppWidgetParser::BoxContentParser::
+ OnPdElement);
+ } else {
+ ThrowMsg(Exception::ParseError,
+ "No element parser for name: " << name);
}
}
virtual void Accept(const XmlAttribute& attribute)
{
if (m_properNamespace) {
- if (attribute.name == L"src")
+ if (attribute.name == L"src") {
m_box.m_boxSrc = attribute.value;
+ }
+ if (attribute.name == L"mouse-event") {
+ m_box.m_boxMouseEvent = attribute.value;
+ }
+ if (attribute.name == L"touch-effect") {
+ m_box.m_boxTouchEffect = attribute.value;
+ }
}
}
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
ElementParser(),
m_properNamespace(false),
m_data(data)
- {
- }
+ {}
ElementParserPtr OnBoxSizeElement()
{
return ElementParserPtr(new PdParser(m_box));
}
- private:
+ private:
DPL::String m_src;
bool m_properNamespace;
ConfigParserData::LiveboxInfo& m_data;
};
virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ const DPL::String& name)
{
if (name == L"box-label") {
- return DPL::MakeDelegate(this, &LiveboxParser::OnBoxLabelElement);
+ return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxLabelElement);
} else if (name == L"box-icon") {
- return DPL::MakeDelegate(this, &LiveboxParser::OnBoxIconElement);
- } else if (name == L"box-content") {
- return DPL::MakeDelegate(this, &LiveboxParser::OnBoxContentElement);
+ return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxIconElement);
+ } else if (name == L"box-content") {
+ return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxContentElement);
} else {
return &IgnoringParser::Create;
}
m_autoLaunch = attribute.value;
} else if (attribute.name == L"update-period") {
m_updatePeriod = attribute.value;
+ } else if (attribute.name == L"type") {
+ m_type = attribute.value;
}
}
}
virtual void Accept(const Element& element)
{
if (element.ns ==
- ConfigurationNamespace::TizenWebAppNamespaceName)
+ ConfigurationNamespace::TizenWebAppNamespaceName)
{
m_properNamespace = true;
}
}
virtual void Accept(const Text& /*text*/)
- {
- }
+ {}
virtual void Verify()
{
m_livebox.m_primary = m_primary;
m_livebox.m_autoLaunch = m_autoLaunch;
m_livebox.m_updatePeriod = m_updatePeriod;
+ m_livebox.m_type = m_type;
m_data.m_livebox.push_back(m_livebox);
}
- explicit LiveboxParser(ConfigParserData& data) :
+ explicit AppWidgetParser(ConfigParserData& data) :
ElementParser(),
m_data(data),
m_properNamespace(false)
DPL::String m_primary;
DPL::String m_autoLaunch;
DPL::String m_updatePeriod;
+ DPL::String m_type;
bool m_properNamespace;
+};
+
+class CspParser : public ElementParser
+{
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ CspParser(ConfigParserData& data) :
+ ElementParser(),
+ m_data(data),
+ m_properNamespace(false)
+ {}
+
+ virtual void Accept(const Element& element)
+ {
+ if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) {
+ m_properNamespace = true;
+ }
+ }
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Accept(const Text& text)
+ {
+ if (m_properNamespace) {
+ m_policy = text.value;
+ }
+ }
+
+ virtual void Verify()
+ {
+ if (!m_policy.IsNull()) {
+ m_data.cspPolicy = *m_policy;
+ }
+ }
+
+ private:
+ ConfigParserData& m_data;
+ bool m_properNamespace;
+ DPL::OptionalString m_policy;
};
+class CspReportOnlyParser : public ElementParser
+{
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ CspReportOnlyParser(ConfigParserData& data) :
+ ElementParser(),
+ m_data(data),
+ m_properNamespace(false)
+ {}
+
+ virtual void Accept(const Element& element)
+ {
+ if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) {
+ m_properNamespace = true;
+ }
+ }
+
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Accept(const Text& text)
+ {
+ if (m_properNamespace) {
+ m_policy = text.value;
+ }
+ }
+
+ virtual void Verify()
+ {
+ if (!m_policy.IsNull()) {
+ m_data.cspPolicyReportOnly = *m_policy;
+ }
+ }
-ElementParser::ActionFunc WidgetParser::GetElementParser(const DPL::String& /*ns*/,
- const DPL::String& name)
+ private:
+ ConfigParserData& m_data;
+ bool m_properNamespace;
+ DPL::OptionalString m_policy;
+};
+
+class AccountParser : public ElementParser
+{
+ public:
+ struct AccountProviderParser : public ElementParser
+ {
+ public:
+
+ struct IconParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ virtual void Accept(const Text& text)
+ {
+ if (text.value == L"") {
+ return;
+ }
+ m_value = text.value;
+ }
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"section") {
+ if (attribute.value == L"account") {
+ m_type = ConfigParserData::IconSectionType::DefaultIcon;
+ } else if (attribute.value == L"account-small") {
+ m_type = ConfigParserData::IconSectionType::SmallIcon;
+ }
+ }
+ }
+
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
+
+ std::pair<ConfigParserData::IconSectionType, DPL::String> icon;
+ icon.first = m_type;
+ icon.second = *m_value;
+
+ m_data.m_iconSet.insert(icon);
+ }
+
+ IconParser(ConfigParserData::AccountProvider& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_type(ConfigParserData::DefaultIcon),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ ConfigParserData::IconSectionType m_type;
+ ConfigParserData::AccountProvider& m_data;
+ DPL::OptionalString m_value;
+ };
+
+ struct DisplayNameParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ virtual void Accept(const Text& text)
+ {
+ if (text.value == L"") {
+ return;
+ }
+ m_value = text.value;
+ }
+
+ virtual void Accept(const Element& element)
+ {
+ m_lang = element.lang;
+ m_value= L"";
+ }
+
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
+
+ std::pair<DPL::String, DPL::String> name;
+ name.first = *m_lang;
+ name.second = *m_value;
+
+ m_data.m_displayNameSet.insert(name);
+ }
+
+ DisplayNameParser(ConfigParserData::AccountProvider& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_lang;
+ DPL::OptionalString m_value;
+ ConfigParserData::AccountProvider& m_data;
+ };
+
+ struct CapabilityParser : public ElementParser
+ {
+ public:
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& /*name*/)
+ {
+ return &IgnoringParser::Create;
+ }
+
+ virtual void Accept(const Text& text)
+ {
+ if (text.value == L"") {
+ return;
+ }
+ m_value = text.value;
+ }
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Verify()
+ {
+ if (m_value.IsNull() || *m_value == L"") {
+ return;
+ }
+ m_data.m_capabilityList.push_back(*m_value);
+ }
+
+ CapabilityParser(ConfigParserData::AccountProvider& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ DPL::OptionalString m_value;
+ ConfigParserData::AccountProvider& m_data;
+ };
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& name)
+ {
+ if (name == L"icon") {
+ return DPL::MakeDelegate(this, &AccountProviderParser::OnIconElement);
+ } else if (name == L"display-name") {
+ return DPL::MakeDelegate(this,
+ &AccountProviderParser::OnDisplayNameElement);
+ } else if (name == L"capability") {
+ return DPL::MakeDelegate(this, &AccountProviderParser::OnCapabilityElement);
+ } else {
+ return &IgnoringParser::Create;
+ }
+ }
+
+ virtual void Accept(const Text& /*text*/)
+ {}
+
+ virtual void Accept(const Element& /*element*/)
+ {}
+
+ virtual void Accept(const XmlAttribute& attribute)
+ {
+ if (attribute.name == L"multiple-accounts-support") {
+ if (attribute.value == L"") {
+ return;
+ }
+
+ if (attribute.value == L"ture") {
+ m_multiSupport = true;
+ }
+ }
+ }
+
+ virtual void Verify()
+ {
+ m_data.m_multiAccountSupport = m_multiSupport;
+ }
+
+ ElementParserPtr OnIconElement()
+ {
+ return ElementParserPtr(new IconParser(m_data));
+ }
+
+ ElementParserPtr OnDisplayNameElement()
+ {
+ return ElementParserPtr(new DisplayNameParser(m_data));
+ }
+
+ ElementParserPtr OnCapabilityElement()
+ {
+ return ElementParserPtr(new CapabilityParser(m_data));
+ }
+
+ AccountProviderParser(ConfigParserData::AccountProvider& data) :
+ ElementParser(),
+ m_properNamespace(false),
+ m_multiSupport(false),
+ m_data(data)
+ {}
+
+ private:
+ bool m_properNamespace;
+ bool m_multiSupport;
+ ConfigParserData::AccountProvider& m_data;
+ };
+
+ virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
+ const DPL::String& name)
+ {
+ if (name == L"account-provider") {
+ return DPL::MakeDelegate(this, &AccountParser::OnProviderElement);
+ } else {
+ return &IgnoringParser::Create;
+ }
+ }
+
+ virtual void Accept(const Element& element)
+ {
+ if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) {
+ m_properNamespace = true;
+ }
+ }
+
+ virtual void Accept(const XmlAttribute& /*attribute*/)
+ {}
+
+ virtual void Accept(const Text& /*text*/)
+ {}
+
+ virtual void Verify()
+ {}
+
+ ElementParserPtr OnProviderElement()
+ {
+ return ElementParserPtr(new AccountProviderParser(m_account));
+ }
+
+ AccountParser(ConfigParserData& data) :
+ ElementParser(),
+ m_data(data),
+ m_account(data.accountProvider),
+ m_properNamespace(false),
+ m_multiSupport(false)
+ {}
+
+ private:
+ ConfigParserData& m_data;
+ ConfigParserData::AccountProvider& m_account;
+ bool m_properNamespace;
+ bool m_multiSupport;
+};
+
+ElementParser::ActionFunc WidgetParser::GetElementParser(
+ const DPL::String& /*ns*/,
+ const DPL::String&
+ name)
{
FuncMap::const_iterator it = m_map.find(name);
if (it != m_map.end()) {
m_map[L"icon"] = DPL::MakeDelegate(this, &WidgetParser::OnIconElement);
m_map[L"content"] =
DPL::MakeDelegate(this, &WidgetParser::OnContentElement);
- m_map[L"feature"] =
- DPL::MakeDelegate(this, &WidgetParser::OnFeatureElement);
m_map[L"preference"] =
DPL::MakeDelegate(this, &WidgetParser::OnPreferenceElement);
m_map[L"link"] = DPL::MakeDelegate(this, &WidgetParser::OnLinkElement);
m_map[L"setting"] =
DPL::MakeDelegate(this, &WidgetParser::OnSettingElement);
// TODO: appservice will be removed
- m_map[L"appservice"] = DPL::MakeDelegate(this, &WidgetParser::OnAppServiceElement);
- m_map[L"application"] = DPL::MakeDelegate(this, &WidgetParser::OnApplicationElement);
+ m_map[L"appservice"] = DPL::MakeDelegate(this,
+ &WidgetParser::OnAppServiceElement);
+ m_map[L"application"] = DPL::MakeDelegate(
+ this,
+ &WidgetParser::
+ OnApplicationElement);
m_map[L"splash"] = DPL::MakeDelegate(this, &WidgetParser::OnSplashElement);
- m_map[L"background"] = DPL::MakeDelegate(this, &WidgetParser::OnBackgroundElement);
- m_map[L"privilege"] = DPL::MakeDelegate(this, &WidgetParser::OnPrivilegeElement);
- m_map[L"app-control"] = DPL::MakeDelegate(this,
- &WidgetParser::OnAppControlElement);
+ m_map[L"background"] = DPL::MakeDelegate(this,
+ &WidgetParser::OnBackgroundElement);
+ m_map[L"privilege"] = DPL::MakeDelegate(this,
+ &WidgetParser::OnPrivilegeElement);
+ m_map[L"app-control"] = DPL::MakeDelegate(
+ this,
+ &WidgetParser::
+ OnAppControlElement);
m_map[L"category"] = DPL::MakeDelegate(this,
- &WidgetParser::OnCategoryElement);
- m_map[L"livebox"] = DPL::MakeDelegate(this, &WidgetParser::OnLiveboxElement);
-
+ &WidgetParser::OnCategoryElement);
+ m_map[L"app-widget"] = DPL::MakeDelegate(this, &WidgetParser::OnAppWidgetElement);
+#ifdef CSP_ENABLED
+ m_map[L"content-security-policy"] = DPL::MakeDelegate(
+ this,
+ &WidgetParser::
+ OnCspElement);
+ m_map[L"content-security-policy-report-only"] = DPL::MakeDelegate(
+ this,
+ &WidgetParser::
+ OnCspReportOnlyElement);
+#endif
+ m_map[L"account"] = DPL::MakeDelegate(this, &WidgetParser::OnAccountElement);
}
ElementParserPtr WidgetParser::OnNameElement()
return ElementParserPtr(new ContentParser(m_data));
}
-ElementParserPtr WidgetParser::OnFeatureElement()
-{
- return ElementParserPtr(new FeatureParser(m_data));
-}
-
ElementParserPtr WidgetParser::OnPreferenceElement()
{
return ElementParserPtr(new PreferenceParser(m_data));
return ElementParserPtr(new CategoryParser(m_data));
}
-ElementParserPtr WidgetParser::OnLiveboxElement()
+ElementParserPtr WidgetParser::OnAppWidgetElement()
{
- return ElementParserPtr(new LiveboxParser(m_data));
+ return ElementParserPtr(new AppWidgetParser(m_data));
+}
+
+ElementParserPtr WidgetParser::OnCspElement()
+{
+ return ElementParserPtr(new CspParser(m_data));
+}
+
+ElementParserPtr WidgetParser::OnCspReportOnlyElement()
+{
+ return ElementParserPtr(new CspReportOnlyParser(m_data));
+}
+
+ElementParserPtr WidgetParser::OnAccountElement()
+{
+ return ElementParserPtr(new AccountParser(m_data));
}
void WidgetParser::Accept(const Element& element)
m_defaultlocale = attribute.value;
NormalizeString(m_defaultlocale);
if (!LanguageSubtagRstTreeSingleton::Instance().ValidateLanguageTag(
- DPL::ToUTF8String(*m_defaultlocale))) {
+ DPL::ToUTF8String(*m_defaultlocale)))
+ {
LogWarning("Language tag: " <<
m_defaultlocale << " is not valid");
m_defaultlocale = DPL::OptionalString::Null;
- }
- else
+ } else {
LogDebug("Default Locale Found " << m_defaultlocale);
+ }
} else {
LogWarning("Ignoring subsequent default locale");
}
- //Any other value consider as a namespace definition
+ //Any other value consider as a namespace definition
} else if (attribute.name == L"xmlns" || attribute.prefix == L"xmlns") {
LogInfo("Namespace domain: " << attribute.name);
LogInfo("Namespace value: " << attribute.value);
m_nameSpaces[attribute.name] = attribute.value;
} else {
LogError("Unknown attirbute: namespace=" << attribute.ns <<
- ", name=" << attribute.name <<
- ", value=" << attribute.value);
+ ", name=" << attribute.name <<
+ ", value=" << attribute.value);
}
}
FOREACH(mode, m_windowModes) {
if (L"windowed" == *mode || L"floating" == *mode ||
L"fullscreen" == *mode || L"maximized" == *mode ||
- L"minimized" == *mode) {
+ L"minimized" == *mode)
+ {
m_data.windowModes.insert(*mode);
}
}
projects / framework / web / wrt-installer.git / blobdiff