private void addElementInArrayWithoutIdRef(Object _value)
{
if (isPrimitive(_value))
{
ElementsSerial elt_ = createPrimitive(_value, false, null);
getComponents().Add(elt_);
}
else
{
TemplateSerial elt_ = createComposite(_value, false, null, false);
getNews().Add(elt_);
getComponents().Add(elt_);
return;
/* if (!SerializeXmlObject.isCheckReferences())
* {
* getNews().Add(elt_);
* getComponents().Add(elt_);
* return;
* }
* MyList<TemplateSerial> records_ = ElementsSerial.findSerialisableInList(_value, getAllComposites());
* if (records_.isEmpty())
* {
* getNews().Add(elt_);
* getAllComposites().Add(elt_);
* getComponents().Add(elt_);
* }
* else {
* throw new RefException();
* }*/
}
}
public override XmlElement serialize(XmlDocument _doc)
{
XmlElement node_ = _doc.CreateElement(ElementsSerial.getType(getValueClass()));
if (getId() != null)
{
node_.SetAttribute(ID, getId().ToString());
}
if (getRef() != null)
{
node_.SetAttribute(REF, getRef().ToString());
}
if (getField() != null && !getField().isEmpty())
{
node_.SetAttribute(FIELD, getField());
}
if (getClassName() != null)
{
node_.SetAttribute(CLASS, getClassName());
}
if (isKeyOfMap())
{
node_.SetAttribute(KEY, EMPTY_STRING);
}
return(node_);
}
public override void setElementSerial(ElementsSerial _e, ElementsSerial _newE)
{
string str_ = _e.getClassName();
Type class_;
if (str_.Contains(SPECIAL_SEP))
{
string types_ = str_.Substring(str_.IndexOf(SPECIAL_SEP));
class_ = Constants.classForName(str_, types_);
}
else
{
class_ = Constants.classForName(str_);
}
FieldInfo field_ = SerializeXmlObject.getField(class_, _e.getField());
field_.SetValue(value, _newE.getValue());
/*for (Field f: cl_.getDeclaredFields()) {
* if (!f.getName().equals(_e.getField()))
* {
* continue;
* }
* if (!SerializeXmlObject.isUpdateFinalFields())
* {
* if (Modifier.isFinal(f.getModifiers()))
* {
* continue;
* }
* }
* f.setAccessible(cl_.getAnnotation(RwXml.class)!=null);
* f.set(value, _newE.getValue());
* break;
* }*/
}
private static ElementsSerial createPrimitive(
Object _value, bool _isKey, Type _cl, String _field)
{
ElementsSerial elt_ = createPrimitive(_value, _isKey, _field);
elt_.setClassName(Constants.getTypeFullString(_cl));
return(elt_);
}
public override bool Equals(Object _arg0)
{
if (_arg0 == null)
{
return(false);
}
if (!(_arg0 is ElementsSerial))
{
return(false);
}
ElementsSerial e_ = (ElementsSerial)_arg0;
return(getValue() == e_.getValue());
}
private void addElementWithoutIdRef(Object _value,
bool _isKey, Type _cl, String _fieldName, bool _isComparator)
{
if (isPrimitive(_value))
{
ElementsSerial elt_ = createPrimitive(_value, _isKey, _cl, _fieldName);
getComponents().Add(elt_);
}
else
{
TemplateSerial elt_ = createComposite(_value, _isKey, _cl, _fieldName, _isComparator);
if (elt_ == null)
{
return;
}
if (_isComparator)
{
getAllImplicitComparators().Add(elt_);
}
getNews().Add(elt_);
getComponents().Add(elt_);
return;
/*
* if (!SerializeXmlObject.isCheckReferences())
* {
* getNews().Add(elt_);
* getComponents().Add(elt_);
* return;
* }
* MyList<TemplateSerial> records_ = ElementsSerial.findSerialisableInList(_value, getAllComposites());
* if (records_.isEmpty())
* {
* getNews().Add(elt_);
* getAllComposites().Add(elt_);
* getComponents().Add(elt_);
* }
* else {
* throw new RefException();
* }*/
}
}
public override void setElementSerial(ElementsSerial _e, ElementsSerial _newE)
{
int l_ = array.Length;
for (int i = 0; i < l_; i++)
{
if (!indexesRef.contains(i))
{
continue;
}
if (!indexesRef.getVal(i).Equals(((TemplateSerial)_e).getRef()))
{
continue;
}
Object o_ = _newE.getValue();
// if (o_ != null) {
// if (!classElements.isInstance(o_)) {
// throw new IllegalArgumentException();
// }
// }
array.SetValue(o_, i);
}
}
public static Object fromXmlStringObject(String _xmlString)
{
XmlElement root_ = XmlParser.documentElement(XmlParser.parseSax(_xmlString));
try {
ElementsSerial elt_ = createPrimitive(root_);
if (elt_ != null)
{
return(elt_.getValue());
}
} catch (Exception) {
}
MyList <XmlNode> currentNodesToBeRead_ = new MyList <XmlNode>();
currentNodesToBeRead_.Add(root_);
MyList <TemplateSerial> currentSerializableElements_ = new MyList <TemplateSerial>();
ObjectSerial rootElement_;
rootElement_ = ObjectSerial.newSerial(root_, false);
currentSerializableElements_.Add(rootElement_);
MyList <XmlNode> newNodesToBeRead_ = new MyList <XmlNode>();
MyList <TemplateSerial> newSerializableElements_ = new MyList <TemplateSerial>();
MyList <ObjectSerial> notEmptyMaps_ = new MyList <ObjectSerial>();
bool modif_ = true;
while (modif_)
{
modif_ = false;
newSerializableElements_ = new MyList <TemplateSerial>();
newNodesToBeRead_ = new MyList <XmlNode>();
int len_;
len_ = currentNodesToBeRead_.size();
for (int i = List.FIRST_INDEX; i < len_; i++)
{
XmlNode currentNode_ = currentNodesToBeRead_.get(i);
TemplateSerial composite_ = currentSerializableElements_.get(i);
bool isTreeMap_ = false;
bool containsTree_ = false;
foreach (XmlNode nCh_ in XmlParser.childrenNodes(currentNode_))
{
if (!(nCh_ is XmlElement))
{
continue;
}
containsTree_ = nCh_.Attributes.GetNamedItem(TemplateSerial.COMPARATOR) != null;
if (containsTree_)
{
break;
}
}
if (containsTree_)
{
isTreeMap_ = true;
}
MyList <ElementsSerial> elt_ = new MyList <ElementsSerial>();
foreach (XmlNode n in XmlParser.childrenNodes(currentNode_))
{
if (!(n is XmlElement))
{
continue;
}
try
{
ArraySerial serialArray_ = ArraySerial.newListSerial(n);
elt_.Add(serialArray_);
newSerializableElements_.Add(serialArray_);
newNodesToBeRead_.Add(n);
continue;
}
catch (NoAttributeForSerializable e_)
{
throw e_;
}
catch (ClassFoundException)
{
}
try
{
ElementsSerial primitive_ = createPrimitive(n);
if (primitive_ == null)
{
throw new NullReferenceException();
}
elt_.Add(primitive_);
continue;
}
catch (NoAttributeForSerializable e_)
{
throw e_;
}
catch (InexistingValueForEnum e_)
{
throw e_;
}
catch (FormatException e_)
{
throw e_;
}
/*catch (InvocationTargetException e_)
* {
* throw e_;
* }
* catch (InstantiationException e_)
* {
* throw e_;
* }
* catch (SecurityException e_)
* {
* throw e_;
* }
* catch (ClassNotFoundException e_)
* {
* throw e_;
* }*/
catch (NullReferenceException)
{
}
ComparatorSerial cmp_ = getCmpSerial(n, isTreeMap_, composite_);
if (cmp_ != null)
{
elt_.Add(cmp_);
newSerializableElements_.Add(cmp_);
newNodesToBeRead_.Add(n);
continue;
}
ObjectSerial serial_ = ObjectSerial.newSerial(n, true);
elt_.Add(serial_);
newSerializableElements_.Add(serial_);
newNodesToBeRead_.Add(n);
}
composite_.appendElementSerialWithoutRef(elt_);
if (composite_ is ObjectSerial)
{
if (!((ObjectSerial)composite_).mapIsEmpty())
{
notEmptyMaps_.Add((ObjectSerial)composite_);
}
}
}
if (!newSerializableElements_.isEmpty())
{
currentNodesToBeRead_ = new MyList <XmlNode>(newNodesToBeRead_);
currentSerializableElements_ = new MyList <TemplateSerial>(newSerializableElements_);
modif_ = true;
}
}
List <ObjectSerial> filledMaps_ = new MyList <ObjectSerial>();
List <ObjectSerial> fillableMaps_ = new MyList <ObjectSerial>();
/*foreach (ObjectSerial m in notEmptyMaps_) {
* if (m.keysAllDifferent()) {
* fillableMaps_.Add(m);
* }
* }
* while (true) {
* for (MayBeMap m : fillableMaps_) {
* m.setComponents();
* filledMaps_.add(m);
* }
* fillableMaps_.clear();
* for (MayBeMap m : notEmptyMaps_) {
* if (!m.keysAllDifferent()) {
* continue;
* }
* if (filledMaps_.containsObj(m)) {
* continue;
* }
* fillableMaps_.add(m);
* }
* if (fillableMaps_.isEmpty()) {
* break;
* }
* }
* for (MayBeMap m : notEmptyMaps_) {
* if (!filledMaps_.containsObj(m)) {
* m.setComponents();
* }
* }*/
return(rootElement_.getValue());
}
public abstract void setElementSerial(ElementsSerial _e, ElementsSerial _newE);
public override void setElementSerial(ElementsSerial _e, ElementsSerial _newE)
{
/* if(value instanceof List) {
* int len_ = ((List <?>)value).size();
* for (int i = Constants.getFirstIndex(); i < len_; i++)
* {
* if (!indexesRef.containsKey(i))
* {
* continue;
* }
* if (!indexesRef.get(i).equals(((TemplateSerial)_e).getRef()))
* {
* continue;
* }
* SET_METHOD.invoke(value, i, _newE.getValue());
* }
* }
* if(value instanceof Map) {
* int len_ = keys.size();
* for (int i = Constants.getFirstIndex(); i < len_; i++)
* {
* if (!keysIndexesRef.containsKey(i))
* {
* continue;
* }
* if (!keysIndexesRef.get(i).equals(((TemplateSerial)_e).getRef()))
* {
* continue;
* }
* keys.set(i, _newE.getValue());
* }
* for (int i = Constants.getFirstIndex(); i < len_; i++)
* {
* if (!valuesIndexesRef.containsKey(i))
* {
* continue;
* }
* if (!valuesIndexesRef.get(i).equals(((TemplateSerial)_e).getRef()))
* {
* continue;
* }
* values.set(i, _newE.getValue());
* }
* }
* Class<?> class_ = Constants.classForName(_e.getClassName());
* if (!class_.isInstance(value)) {
* return;
* }
* if (_e.getField() == null) {
* return;
* }
* Field field_;
* try {
* field_ = class_.getDeclaredField(_e.getField());
* } catch (NoSuchFieldException exception) {
* return;
* }
* if (!SerializeXmlObject.isUpdateFinalFields()) {
* if (Modifier.isFinal(field_.getModifiers()))
* {
* return;
* }
* }
* if (Modifier.isStatic(field_.getModifiers())) {
* return;
* }
* field_.setAccessible(class_.getAnnotation(RwXml.class)!=null);
* field_.set(value, _newE.getValue());*/
}
