void ZFMethod::objectInfoT(ZF_IN_OUT zfstring &ret) const
{
if(this->methodIsStatic())
{
ret += zfText("static ");
}
else if(this->methodIsVirtual())
{
ret += zfText("virtual ");
}
ret += this->methodReturnTypeName();
ret += zfText(" ");
ret += this->ownerClass()->className();
ret += zfText("::");
ret += this->methodName();
if(!zfscmpTheSame(this->methodId(), zfText("")))
{
ret += zfText(":");
ret += this->methodId();
}
if(this->methodParamCount() > 0)
{
ret += zfText("(");
for(zfindex i = 0; i < this->methodParamCount(); ++i)
{
if(i != 0)
{
ret += zfText(", ");
}
ret += this->methodParamTypeNameAtIndex(i);
}
ret += zfText(")");
}
else
{
ret += zfText("(void)");
}
if(this->methodIsConst())
{
ret += zfText(" const");
}
}
zfbool ZFEnum::serializableOnSerializeCategoryFromData(ZF_IN const ZFSerializableData &ownerData,
ZF_OUT_OPT zfstring *outErrorHintToAppend /* = zfnull */,
ZF_OUT_OPT const ZFSerializableData **outErrorPos /* = zfnull */)
{
if(!zfsuperI(ZFSerializable)::serializableOnSerializeCategoryFromData(ownerData, outErrorHintToAppend, outErrorPos)) {return zffalse;}
{ // enum
const ZFSerializableData *categoryData = ZFSerializableUtil::checkElementByCategory(ownerData, ZFSerializableKeyword_ZFEnum_enum);
if(categoryData != zfnull)
{
ZFEnumValue enumValue = ZFEnumValueInvalid;
const zfchar *propertyValue = categoryData->propertyValue();
if(propertyValue != zfnull)
{
if(!zfscmpTheSame(propertyValue, ZFEnumValueNameInvalid))
{
enumValue = this->enumValueForName(propertyValue);
if(enumValue == ZFEnumValueInvalid)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, outErrorPos, *categoryData,
zfText("invalid value %s for enum %s"), propertyValue, this->classData()->className());
return zffalse;
}
}
}
this->enumValueSet(enumValue);
categoryData->resolveMark();
if(categoryData->referenceInfoExist())
{
this->serializableRefInfoSetForCategory(ZFSerializableKeyword_ZFEnum_enum, categoryData->referenceInfoCopy());
}
}
else
{
this->enumValueSet(ZFEnumValueInvalid);
}
}
return zftrue;
}
ZF_NAMESPACE_GLOBAL_BEGIN
zfbool zfLangLoad(ZF_IN const ZFSerializableData &serializableData,
ZF_OUT_OPT zfstring *errorHint /* = zfnull */)
{
for(zfindex i = 0; i < serializableData.elementCount(); ++i)
{
const ZFSerializableData &item = serializableData.elementAtIndex(i);
if(zfscmpTheSame(item.itemClass(), zfText("l")))
{
const zfchar *k = item.attributeForName(zfText("k"));
const zfchar *v = item.attributeForName(zfText("v"));
if(k != zfnull && v != zfnull)
{
zfLangSet(k, v);
}
}
}
zfLangNotifyChanged();
return zftrue;
}
ZFPROPERTY_TYPE_DECLARE_SERIALIZE_FROM_DEFINE(ZFCallback, ZFCallback)
{
{ // custom serialize logic
const zfchar *customType = ZFSerializableUtil::checkAttribute(serializableData, ZFSerializableKeyword_ZFCallback_callbackType);
if(customType != zfnull)
{
const ZFSerializableData *customData = ZFSerializableUtil::checkElementByCategory(serializableData, ZFSerializableKeyword_ZFCallback_callbackData);
if(customData == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, outErrorPos, serializableData,
zfText("missing %s"), ZFSerializableKeyword_ZFCallback_callbackData);
return zffalse;
}
ZFCallbackSerializeCustomSerializeCallback serializeCallback = ZFCallbackSerializeCustomTypeGet(customType);
if(serializeCallback == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, outErrorPos, serializableData,
zfText("no such callback custom serialize type: %s"), customType);
return zffalse;
}
if(!serializeCallback(result, *customData, outErrorHintToAppend, outErrorPos))
{
return zffalse;
}
result.callbackSerializeCustomTypeSet(customType);
result.callbackSerializeCustomDataSet(customData);
serializableData.resolveMark();
return zftrue;
}
}
if(zfscmpTheSame(serializableData.itemClass(), ZFSerializableKeyword_null))
{
result = ZFCallbackNull();
serializableData.resolveMark();
return zftrue;
}
if(ZFSerializableUtil::requireSerializableClass(ZFPropertyTypeId_ZFCallback, serializableData, outErrorHintToAppend, outErrorPos) == zfnull)
{
return zffalse;
}
const ZFSerializableData *methodData = ZFSerializableUtil::requireElementByCategory(serializableData, ZFSerializableKeyword_ZFCallback_method, outErrorHintToAppend, outErrorPos);
if(methodData == zfnull)
{
return zffalse;
}
const ZFMethod *method = zfnull;
if(!ZFMethodFromSerializableData(method, *methodData, outErrorHintToAppend, outErrorPos))
{
return zffalse;
}
if(method->ownerClass() == zfnull)
{
result = ZFCallbackForMethod(method);
}
else if(method->methodIsStatic())
{
result = ZFCallbackForMethod(method);
}
else
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, outErrorPos, serializableData,
zfText("member method callback is not supported"));
return zffalse;
}
serializableData.resolveMark();
return zftrue;
}
zfbool ZFXmlToSerializableData(ZF_OUT ZFSerializableData &serializableData,
ZF_IN const ZFXmlItem *xmlElement,
ZF_OUT_OPT zfstring *outErrorHintToAppend /* = zfnull */,
ZF_OUT_OPT const ZFXmlItem **outErrorPos /* = zfnull */)
{
if(xmlElement == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("null xml element"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
if(xmlElement->xmlType() != ZFXmlType::e_XmlElement)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("param not type of xml element"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
if(xmlElement->xmlName() == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing xml node name"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
serializableData.itemClassSet(xmlElement->xmlName());
const ZFXmlItem *attribute = xmlElement->xmlAttributeFirst();
while(attribute != zfnull)
{
if(attribute->xmlName() == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing xml attribute name"));
if(outErrorPos != zfnull)
{
*outErrorPos = attribute;
}
return zffalse;
}
if(zfscmpTheSame(attribute->xmlName(), ZFSerializableKeyword_refType))
{
serializableData.referenceRefTypeSet(attribute->xmlValue());
}
else if(zfscmpTheSame(attribute->xmlName(), ZFSerializableKeyword_refData))
{
serializableData.referenceRefDataSet(attribute->xmlValue());
}
else
{
serializableData.attributeSet(attribute->xmlName(), attribute->xmlValue());
}
attribute = attribute->xmlAttributeNext();
}
const ZFXmlItem *element = xmlElement->xmlChildElementFirst();
while(element != zfnull)
{
ZFSerializableData childData;
if(!ZFXmlToSerializableData(childData, element, outErrorHintToAppend, outErrorPos))
{
return zffalse;
}
serializableData.elementAdd(childData);
element = element->xmlSiblingElementNext();
}
if(outErrorPos != zfnull)
{
*outErrorPos = zfnull;
}
return serializableData.referenceCheckLoad(outErrorHintToAppend, zfnull);
}
static zfbool _ZFP_ZFXmlParseToSerializableData(ZF_OUT ZFSerializableData &serializableData,
ZF_IN const ZFXmlItem &xmlElement,
ZF_OUT_OPT zfstring *outErrorHintToAppend = zfnull,
ZF_OUT_OPT ZFXmlItem *outErrorPos = zfnull)
{
if(xmlElement.xmlIsNull())
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("null xml element"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
if(xmlElement.xmlType() != ZFXmlType::e_XmlElement)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("param not type of xml element"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
if(xmlElement.xmlName() == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing xml node name"));
if(outErrorPos != zfnull)
{
*outErrorPos = xmlElement;
}
return zffalse;
}
serializableData.itemClassSet(xmlElement.xmlName());
ZFXmlItem attribute = xmlElement.xmlAttributeFirst();
while(!attribute.xmlIsNull())
{
if(attribute.xmlName() == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing xml attribute name"));
if(outErrorPos != zfnull)
{
*outErrorPos = attribute;
}
return zffalse;
}
if(zfscmpTheSame(attribute.xmlName(), ZFSerializableKeyword_refType))
{
serializableData.referenceRefTypeSet(attribute.xmlValue());
}
else if(zfscmpTheSame(attribute.xmlName(), ZFSerializableKeyword_refData))
{
serializableData.referenceRefDataSet(attribute.xmlValue());
}
else
{
serializableData.attributeSet(attribute.xmlName(), attribute.xmlValue());
}
attribute = attribute.xmlAttributeNext();
}
ZFXmlItem element = xmlElement.xmlChildElementFirst();
while(!element.xmlIsNull())
{
ZFSerializableData childData;
if(!_ZFP_ZFXmlParseToSerializableData(childData, element, outErrorHintToAppend, outErrorPos))
{
return zffalse;
}
serializableData.elementAdd(childData);
element = element.xmlSiblingElementNext();
}
return zftrue;
}
zfbool ZFJsonToSerializableData(ZF_OUT ZFSerializableData &serializableData,
ZF_IN const ZFJsonItem *jsonObject,
ZF_OUT_OPT zfstring *outErrorHintToAppend /* = zfnull */,
ZF_OUT_OPT const ZFJsonItem **outErrorPos /* = zfnull */)
{
if(jsonObject == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("null json object"));
if(outErrorPos != zfnull)
{
*outErrorPos = jsonObject;
}
return zffalse;
}
const ZFJsonItem *elementJsonArray = zfnull;
for(zfiterator jsonItemIt = jsonObject->jsonItemIterator(); jsonObject->jsonItemIteratorIsValid(jsonItemIt); jsonObject->jsonItemIteratorNext(jsonItemIt))
{
const zfchar *key = jsonObject->jsonItemIteratorGetKey(jsonItemIt);
const ZFJsonItem *jsonItem = jsonObject->jsonItemIteratorGet(jsonItemIt);
zfassert(jsonItem != zfnull);
if(*key == _ZFP_ZFJsonSerializeKey_classPrefix)
{
serializableData.itemClassSet(key + 1);
if(jsonItem->jsonType() != ZFJsonType::e_JsonArray)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend,
zfText("json item %s not type of %s"),
jsonItem->objectInfo().cString(),
ZFJsonType::EnumNameForValue(ZFJsonType::e_JsonArray));
if(outErrorPos != zfnull)
{
*outErrorPos = jsonItem;
}
return zffalse;
}
elementJsonArray = jsonItem;
}
else
{
if(jsonItem->jsonType() != ZFJsonType::e_JsonValue)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend,
zfText("json item %s not type of %s"),
jsonItem->objectInfo().cString(),
ZFJsonType::EnumNameForValue(ZFJsonType::e_JsonValue));
if(outErrorPos != zfnull)
{
*outErrorPos = jsonItem;
}
return zffalse;
}
const zfchar *value = jsonItem->jsonValue();
if(zfscmpTheSame(key, ZFSerializableKeyword_refType))
{
serializableData.referenceRefTypeSet(value);
}
else if(zfscmpTheSame(key, ZFSerializableKeyword_refData))
{
serializableData.referenceRefDataSet(value);
}
else
{
serializableData.attributeSet(zfstring(key).cString(), value);
}
}
}
if(serializableData.itemClass() == zfnull)
{
ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing class node (which looks like \"@ClassName\")"));
if(outErrorPos != zfnull)
{
*outErrorPos = jsonObject;
}
return zffalse;
}
if(elementJsonArray != zfnull)
{
for(zfindex i = 0; i < elementJsonArray->jsonObjectCount(); ++i)
{
ZFSerializableData childData;
if(!ZFJsonToSerializableData(childData, elementJsonArray->jsonObjectAtIndex(i), outErrorHintToAppend, outErrorPos))
{
return zffalse;
}
serializableData.elementAdd(childData);
}
}
if(outErrorPos != zfnull)
{
*outErrorPos = zfnull;
}
return serializableData.referenceCheckLoad(outErrorHintToAppend, zfnull);
}
