public IValue Get(XdtoProperty property)
{
if (property != null && _data.ContainsKey(property))
{
return(_data [property]);
}
return(ValueFactory.Create());
}
internal XdtoDataObject(XdtoObjectType type, XdtoDataObject owner, XdtoProperty property)
{
_type = type;
_owner = owner;
_owningProperty = property;
_sequence = new XdtoSequence(this, true);
FillPropertiesFromType();
}
public void Add(XmlFormEnum form, string namespaceUri, string localName, IXdtoValue dataElement)
{
if (_type?.Open ?? true)
{
var customProperty = new XdtoProperty(null, this, form, namespaceUri, localName);
Add(customProperty, dataElement);
}
throw new RuntimeException("Добавлять можно только в объекты открытого типа!");
}
public IValue GetList(XdtoProperty property)
{
var v = Get(property) as XdtoList;
if (v == null)
{
v = new XdtoList(this, property);
_data[property] = v;
}
return(v);
}
public IXdtoValue GetXdto(XdtoProperty property)
{
var value = Get(property);
if (value is IXdtoValue)
{
return(value as IXdtoValue);
}
if (property.Type is XdtoValueType)
{
return(new XdtoDataValue(property.Type as XdtoValueType, value?.AsString() ?? "", value));
}
return(_pv.SerializeXdto(value, null));
}
public void Add(XdtoProperty property, IXdtoValue dataElement)
{
XdtoList list;
if (_data.ContainsKey(property))
{
list = _data [property] as XdtoList;
if (list == null)
{
list = new XdtoList(this, property);
_data [property] = list;
}
}
else
{
list = new XdtoList(this, property);
_data [property] = list;
}
list.Add(ValueFactory.Create(dataElement));
}
internal XdtoList(XdtoDataObject owner, XdtoProperty owningProperty)
{
Owner = owner;
OwningProperty = owningProperty;
}
public void Insert(int index, XdtoProperty property, IValue dataElement)
{
elements.Insert(index, new XdtoSequenceValueElement(property, dataElement as IXdtoValue));
}
public void Add(XdtoProperty property, IValue dataElement)
{
elements.Add(new XdtoSequenceValueElement(property, dataElement as IXdtoValue));
}
public XdtoSequenceValueElement(XdtoProperty property, IXdtoValue value)
{
Value = value;
}
public bool IsSet(XdtoProperty property)
{
return(_data.ContainsKey(property));
}
public void Set(XdtoProperty property, IValue value)
{
RegisterProperty(property.LocalName);
_data [property] = value;
}
public void Unset(XdtoProperty property)
{
_data.Remove(property);
RemoveProperty(property.LocalName);
}
internal void BuildPackage()
{
if (_built)
{
return;
}
_built = true;
foreach (var include in _schema.Includes)
{
if (include is XmlSchemaImport)
{
var import = include as XmlSchemaImport;
var packagetoImport = _factory.Packages.Get(import.Namespace);
// TODO: what if null ?
packagetoImport?.BuildPackage();
}
}
foreach (var oType in _schema.SchemaTypes)
{
var dElement = (DictionaryEntry)oType;
var type = dElement.Value;
if (type is XmlSchemaSimpleType)
{
_types.Add(new XdtoValueType(type as XmlSchemaSimpleType, _factory));
}
else
if (type is XmlSchemaComplexType)
{
_types.Add(new XdtoObjectType(type as XmlSchemaComplexType, _factory));
}
}
var rootProperties = new List <XdtoProperty> ();
foreach (var oElement in _schema.Elements)
{
var elPair = (DictionaryEntry)oElement;
var element = elPair.Value as XmlSchemaElement;
// в XDTO под элемент создаётся свой тип с таким же именем
IXdtoType elementType;
if (element.SchemaType is XmlSchemaSimpleType)
{
elementType = new XdtoValueType(element.SchemaType as XmlSchemaSimpleType, _factory);
}
else if (element.SchemaType is XmlSchemaComplexType)
{
elementType = new XdtoObjectType(element, _factory);
}
else
{
// TODO: Присвоить anyType
throw new NotImplementedException();
}
_types.Add(elementType);
var property = new XdtoProperty(XmlFormEnum.Element,
element.QualifiedName.Namespace,
element.QualifiedName.Name,
elementType);
rootProperties.Add(property);
}
RootProperties = new XdtoPropertyCollection(rootProperties);
}
public IXdtoValue ReadXml(XmlReaderImpl reader, IXdtoType expectedType, XdtoFactory factory)
{
// TODO: дублирование кода в трёх ветках
var result = new XdtoDataObject(this, null, null);
// TODO: Перевести XML на простые перечисления
var xmlNodeTypeEnum = XmlNodeTypeEnum.CreateInstance();
var xmlElementStart = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.Element);
var xmlText = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.Text);
var xmlElementEnd = xmlNodeTypeEnum.FromNativeValue(System.Xml.XmlNodeType.EndElement);
while (reader.ReadAttribute())
{
if (reader.NamespaceURI.Equals("http://www.w3.org/2000/xmlns/") ||
reader.NamespaceURI.Equals(XmlNs.xsi) && reader.LocalName.Equals("type"))
{
continue;
}
var propertyName = reader.LocalName;
var attributeNamespace = reader.NamespaceURI;
var attributeProperty =
AllProperties().FirstOrDefault(p => p.Form == XmlFormEnum.Attribute &&
p.LocalName.Equals(propertyName) &&
p.NamespaceURI.Equals(attributeNamespace));
if (attributeProperty == null)
{
if (!Open)
{
throw new XdtoException($"Ошиба разбора XDTO: Получили неизвестный атрибут {propertyName}");
}
var type = factory.Type(new XmlDataType("string"));
attributeProperty = new XdtoProperty(null, result, XmlFormEnum.Attribute,
NamespaceUri, propertyName,
1, -1, type); // TODO: lower / upper для открытого типа
}
var attributeValue = attributeProperty.Type.Reader.ReadXml(reader, attributeProperty.Type, factory);
result.Set(attributeProperty, ValueFactory.Create(attributeValue));
}
while (reader.Read())
{
if (reader.NodeType.Equals(xmlElementEnd))
{
// TODO: result.Validate()
return(result);
}
if (reader.NodeType.Equals(xmlText))
{
// надо найти свойство с Form=Text
// оно должно быть одно
var textProperty = AllProperties().FirstOrDefault((p) => p.Form == XmlFormEnum.Text);
IXdtoType type;
IValue textValue;
if (textProperty == null)
{
if (!Open)
{
throw new XdtoException($"Ошибка разбора XDTO: Текст {reader.Value} в неположенном месте при разборе типа {this}!");
}
textProperty = new XdtoProperty(null, result, XmlFormEnum.Text, NamespaceUri, "#text");
type = factory.Type(new XmlDataType("string"));
textValue = ValueFactory.Create(reader.Value);
}
else
{
type = textProperty.Type;
textValue = ValueFactory.Create(type.Reader.ReadXml(reader, type, factory));
}
if (Sequenced)
{
result.Sequence().Add(textValue.AsString());
}
else
{
result.Set(textProperty, textValue);
}
}
else if (reader.NodeType.Equals(xmlElementStart))
{
var localName = reader.LocalName;
var ns = reader.NamespaceURI;
var property = AllProperties().FirstOrDefault((p) => p.LocalName.Equals(localName) &&
p.NamespaceURI.Equals(ns) &&
p.Form == XmlFormEnum.Element);
if (property == null)
{
if (!Open)
{
throw new XdtoException($"Ошибка разбора XDTO: Получили неизвестный элемент {localName}");
}
// TODO: lower / upper для открытого типа
property = new XdtoProperty(null, result, XmlFormEnum.Element, ns, localName, 1, 1);
}
var elementValue = factory.ReadXml(reader, property.Type);
// TODO: Разбор anyType
if (property.UpperBound != 1)
{
// TODO: проверка на null - на отсутствие/наличие списка
(result.GetList(property) as XdtoList).Add(elementValue);
}
else
{
result.Set(property, elementValue);
}
}
}
throw new XdtoException("Ошибка разбора XDTO!");
}
