public WorkBookBD(string fileName, bool loadFile)
{
this.FileName = fileName;
if (loadFile)
{
xml = XElement.Load(fileName);
}
else
{
createTree();
}
typeList = new TypeListCollection();
copyList = new CopyListCollection();
typeInfo = new TypeModel();
history = new WBOHistory(this);
err = new WBOError(this);
}
public MyViewModel()
{
Types = new ObservableCollection<TypeModel>();
for (var a = 0; a < 5; a++)
{
var lvl1 = new TypeModel { Name = "Type " + a, Fields = new ObservableCollection<TypeModel>() };
for (var b = 0; b < 5; b++)
{
var lvl2 = new TypeModel { Name = lvl1.Name + "." + b, Fields = new ObservableCollection<TypeModel>() };
for (var c = 0; c < 5; c++)
{
var lvl3 = new TypeModel { Name = lvl2.Name + "." + c, Fields = new ObservableCollection<TypeModel>() };
for (var d = 0; d < 5; d++)
lvl3.Fields.Add(new TypeModel { Name = lvl3.Name + "." + d, Fields = new ObservableCollection<TypeModel>() });
lvl2.Fields.Add(lvl3);
}
lvl1.Fields.Add(lvl2);
}
Types.Add(lvl1);
}
}
public ProtobufInputFormatter(TypeModel typeModel)
{
SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(ContentType));
this.SupportedMediaTypes.Add(ContentType);
_typeModel = typeModel;
}
static void TestEnumModel(TypeModel model)
{
var obj = model.GetSerializerCore <Foo>(default);
public static TypeRef FromDefinitionIndex(TypeModel model, int index)
=> new TypeRef
{
model = model, definitionIndex = index
};
static bool SerializeDateTimeKind(TypeModel model)
{
return((bool)typeof(TypeModel).GetMethod(
"SerializeDateTimeKind", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(model, null));
}
public ProtocolBufferBinaryConverter()
{
_typeModel = TypeModelBuilder.Create <T>();
}
public NullProtoWriter(TypeModel model, SerializationContext context) : base(model, context)
{
}
internal static bool TrySerializeAny(int fieldNumber, SerializerFeatures features, Type type, TypeModel model, ref ProtoWriter.State state, object value) => Get(type).TrySerializeAny(fieldNumber, features, model, ref state, value);
internal static bool TryDeserialize(ObjectScope scope, Type type, TypeModel model, ref ProtoReader.State state, ref object value) => Get(type).TryDeserialize(scope, model, ref state, ref value);
protected override bool TryDeepClone(TypeModel model, ref object value)
{
value = model.DeepClone <T>(TypeHelper <T> .FromObject(value));
return(true);
}
internal static bool TrySerializeRoot(Type type, TypeModel model, ref ProtoWriter.State state, object value) => Get(type).TrySerializeRoot(model, ref state, value);
protected override bool TrySerializeAny(int fieldNumber, SerializerFeatures features, TypeModel model, ref ProtoWriter.State state, object value)
{
var serializer = TypeModel.TryGetSerializer <T>(model);
if (serializer == null)
{
return(false);
}
// note this null-check is non-trivial; for value-type T it promotes the null to a default
T typed = TypeHelper <T> .FromObject(value);
CheckAnyAuxFlow(features, serializer);
if ((features & SerializerFeatures.CategoryMessageWrappedAtRoot) == SerializerFeatures.CategoryMessageWrappedAtRoot)
{
if (fieldNumber != TypeModel.ListItemTag)
{
ThrowHelper.ThrowInvalidOperationException($"Special root-like wrapping is limited to field {TypeModel.ListItemTag}");
}
state.WriteAsRoot <T>(typed, serializer);
}
else
{
state.WriteAny <T>(fieldNumber, features, typed, serializer);
}
return(true);
}
internal static bool TryDeserializeRoot(Type type, TypeModel model, ref ProtoReader.State state, ref object value, bool autoCreate) => Get(type).TryDeserializeRoot(model, ref state, ref value, autoCreate);
public MethodModel(ApiModel api, string name, TypeModel returnType, int index)
: base(api, name, returnType)
{
Index = index;
}
/// <summary>
/// Creates a new writer against a stream
/// </summary>
/// <param name="dest">The destination stream</param>
/// <param name="model">The model to use for serialization; this can be null, but this will impair the ability to serialize sub-objects</param>
/// <param name="context">Additional context about this serialization operation</param>
public static ProtoWriter Create(Stream dest, TypeModel model, SerializationContext context = null)
#pragma warning disable CS0618
=> new ProtoWriter(dest, model, context);
private IEnumerable<PropertyModel> CreatePropertiesForElements(Uri source, TypeModel typeModel, XmlSchemaParticle particle, IEnumerable<Particle> items)
{
var properties = new List<PropertyModel>();
var order = 0;
foreach (var item in items)
{
PropertyModel property = null;
var element = item.XmlParticle as XmlSchemaElement;
// ElementSchemaType must be non-null. This is not the case when maxOccurs="0".
if (element != null && element.ElementSchemaType != null)
{
var elementQualifiedName = element.ElementSchemaType.QualifiedName;
if (elementQualifiedName.IsEmpty)
{
elementQualifiedName = element.RefName;
if (elementQualifiedName.IsEmpty)
{
// inner type, have to generate a type name
var typeName = ToTitleCase(typeModel.Name) + ToTitleCase(element.QualifiedName.Name);
elementQualifiedName = new XmlQualifiedName(typeName, typeModel.XmlSchemaName.Namespace);
// try to avoid name clashes
if (NameExists(elementQualifiedName))
elementQualifiedName = new[] { "Item", "Property", "Element" }
.Select(s => new XmlQualifiedName(elementQualifiedName.Name + s, elementQualifiedName.Namespace))
.First(n => !NameExists(n));
}
}
var propertyName = ToTitleCase(element.QualifiedName.Name);
if (propertyName == typeModel.Name) propertyName += "Property"; // member names cannot be the same as their enclosing type
property = new PropertyModel(_configuration)
{
OwningType = typeModel,
XmlSchemaName = element.QualifiedName,
Name = propertyName,
Type = CreateTypeModel(source, element.ElementSchemaType, elementQualifiedName),
IsNillable = element.IsNillable,
IsNullable = item.MinOccurs < 1.0m,
IsCollection = item.MaxOccurs > 1.0m || particle.MaxOccurs > 1.0m, // http://msdn.microsoft.com/en-us/library/vstudio/d3hx2s7e(v=vs.100).aspx
DefaultValue = element.DefaultValue,
Form = element.Form == XmlSchemaForm.None ? element.GetSchema().ElementFormDefault : element.Form,
XmlNamespace = element.QualifiedName.Namespace != "" && element.QualifiedName.Namespace != typeModel.XmlSchemaName.Namespace ? element.QualifiedName.Namespace : null,
};
}
else
{
var any = item.XmlParticle as XmlSchemaAny;
if (any != null)
{
property = new PropertyModel(_configuration)
{
OwningType = typeModel,
Name = "Any",
Type = new SimpleModel(_configuration) { ValueType = (UseXElementForAny ? typeof(XElement) : typeof(XmlElement)), UseDataTypeAttribute = false },
IsNullable = item.MinOccurs < 1.0m,
IsCollection = item.MaxOccurs > 1.0m || particle.MaxOccurs > 1.0m, // http://msdn.microsoft.com/en-us/library/vstudio/d3hx2s7e(v=vs.100).aspx
IsAny = true,
};
}
else
{
var groupRef = item.XmlParticle as XmlSchemaGroupRef;
if (groupRef != null)
{
if (GenerateInterfaces)
CreateTypeModel(new Uri(groupRef.SourceUri), Groups[groupRef.RefName], groupRef.RefName);
var groupItems = GetElements(groupRef.Particle);
var groupProperties = CreatePropertiesForElements(source, typeModel, item.XmlParticle, groupItems);
properties.AddRange(groupProperties);
}
}
}
// Discard duplicate property names. This is most likely due to:
// - Choice or
// - Element and attribute with the same name
if (property != null && !properties.Any(p => p.Name == property.Name))
{
var itemDocs = GetDocumentation(item.XmlParticle);
property.Documentation.AddRange(itemDocs);
if (EmitOrder)
property.Order = order++;
property.IsDeprecated = itemDocs.Any(d => d.Text.StartsWith("DEPRECATED"));
properties.Add(property);
}
}
return properties;
}
internal static bool TryDeepClone(Type type, TypeModel model, ref object value) => Get(type).TryDeepClone(model, ref value);
public Int64Serializer(TypeModel model)
{
}
internal static bool IsKnownType(Type type, TypeModel model, CompatibilityLevel ambient) => Get(type).IsKnownType(model, ambient);
public ImaqServer(TypeModel customSerializer)
: base(new ImaqCoordinator(),
(r, c) => new ImaqFlow(r, c),
customSerializer)
{
}
internal static bool CanSerialize(Type type, TypeModel model, out SerializerFeatures features) => Get(type).CanSerialize(model, out features);
public ProtocolBufferBinaryConverter(Model model)
{
_typeModel = TypeModelBuilder.Create(model);
}
public StreamProtoReader(Stream source, TypeModel model, SerializationContext context, long length) => Init(source, model, context, length);
public static TypeRef FromReferenceIndex(TypeModel model, int index)
=> new TypeRef
{
model = model, referenceIndex = index
};
public StreamProtoReader(Stream source, TypeModel model, SerializationContext context) => Init(source, model, context, TO_EOF);
// Token: 0x06000243 RID: 579 RVA: 0x000022E5 File Offset: 0x000004E5
public SByteSerializer(TypeModel model)
{
}
public static ProtoReader Create(Stream source, TypeModel model, SerializationContext context = null, long length = TO_EOF) => Create(source, model, (object)context, length);
public TypeSerializer(TypeModel model, Type forType, int[] fieldNumbers, IProtoSerializer[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, CallbackSet callbacks, Type constructType, MethodInfo factory)
{
Helpers.DebugAssert(forType != null);
Helpers.DebugAssert(fieldNumbers != null);
Helpers.DebugAssert(serializers != null);
Helpers.DebugAssert(fieldNumbers.Length == serializers.Length);
Helpers.Sort(fieldNumbers, serializers);
bool hasSubTypes = false;
for (int i = 1; i < fieldNumbers.Length; i++)
{
if (fieldNumbers[i] == fieldNumbers[i - 1])
{
throw new InvalidOperationException("Duplicate field-number detected; " +
fieldNumbers[i].ToString() + " on: " + forType.FullName);
}
if (!hasSubTypes && serializers[i].ExpectedType != forType)
{
hasSubTypes = true;
}
}
this.forType = forType;
this.factory = factory;
if (constructType == null)
{
constructType = forType;
}
else
{
if (!forType.IsAssignableFrom(constructType))
{
throw new InvalidOperationException(forType.FullName + " cannot be assigned from " + constructType.FullName);
}
}
this.constructType = constructType;
this.serializers = serializers;
this.fieldNumbers = fieldNumbers;
this.callbacks = callbacks;
this.isRootType = isRootType;
this.useConstructor = useConstructor;
if (baseCtorCallbacks != null && baseCtorCallbacks.Length == 0)
{
baseCtorCallbacks = null;
}
this.baseCtorCallbacks = baseCtorCallbacks;
if (Helpers.GetUnderlyingType(forType) != null)
{
throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType");
}
if (model.MapType(iextensible).IsAssignableFrom(forType))
{
if (forType.IsValueType || !isRootType || hasSubTypes)
{
throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance");
}
isExtensible = true;
}
hasConstructor = !constructType.IsAbstract && Helpers.GetConstructor(constructType, Helpers.EmptyTypes, true) != null;
if (constructType != forType && useConstructor && !hasConstructor)
{
throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, "constructType");
}
}
internal static bool IdentifyImmutable(TypeModel model, Type declaredType, out MethodInfo builderFactory, out PropertyInfo isEmpty, out PropertyInfo length, out MethodInfo add, out MethodInfo addRange, out MethodInfo finish)
{
builderFactory = add = addRange = finish = null;
isEmpty = length = null;
if (model == null || declaredType == null)
{
return(false);
}
#if COREFX || PROFILE259
TypeInfo declaredTypeInfo = declaredType.GetTypeInfo();
#else
Type declaredTypeInfo = declaredType;
#endif
// try to detect immutable collections; firstly, they are all generic, and all implement IReadOnlyCollection<T> for some T
if (!declaredTypeInfo.IsGenericType)
{
return(false);
}
#if COREFX || PROFILE259
Type[] typeArgs = declaredTypeInfo.GenericTypeArguments, effectiveType;
#else
Type[] typeArgs = declaredTypeInfo.GetGenericArguments(), effectiveType;
#endif
switch (typeArgs.Length)
{
case 1:
effectiveType = typeArgs;
break; // fine
case 2:
Type kvp = model.MapType(typeof(System.Collections.Generic.KeyValuePair <,>));
if (kvp == null)
{
return(false);
}
kvp = kvp.MakeGenericType(typeArgs);
effectiveType = new Type[] { kvp };
break;
default:
return(false); // no clue!
}
if (ResolveIReadOnlyCollection(declaredType, null) == null)
{
return(false); // no IReadOnlyCollection<T> found
}
// and we want to use the builder API, so for generic Foo<T> or IFoo<T> we want to use Foo.CreateBuilder<T>
string name = declaredType.Name;
int i = name.IndexOf('`');
if (i <= 0)
{
return(false);
}
name = declaredTypeInfo.IsInterface ? name.Substring(1, i - 1) : name.Substring(0, i);
Type outerType = model.GetType(declaredType.Namespace + "." + name, declaredTypeInfo.Assembly);
// I hate special-cases...
if (outerType == null && name == "ImmutableSet")
{
outerType = model.GetType(declaredType.Namespace + ".ImmutableHashSet", declaredTypeInfo.Assembly);
}
if (outerType == null)
{
return(false);
}
#if PROFILE259
foreach (MethodInfo method in outerType.GetTypeInfo().DeclaredMethods)
#else
foreach (MethodInfo method in outerType.GetMethods())
#endif
{
if (!method.IsStatic || method.Name != "CreateBuilder" || !method.IsGenericMethodDefinition || method.GetParameters().Length != 0 ||
method.GetGenericArguments().Length != typeArgs.Length)
{
continue;
}
builderFactory = method.MakeGenericMethod(typeArgs);
break;
}
Type voidType = model.MapType(typeof(void));
if (builderFactory == null || builderFactory.ReturnType == null || builderFactory.ReturnType == voidType)
{
return(false);
}
#if COREFX
TypeInfo typeInfo = declaredType.GetTypeInfo();
#else
Type typeInfo = declaredType;
#endif
isEmpty = Helpers.GetProperty(typeInfo, "IsDefaultOrEmpty", false); //struct based immutabletypes can have both a "default" and "empty" state
if (isEmpty == null)
{
isEmpty = Helpers.GetProperty(typeInfo, "IsEmpty", false);
}
if (isEmpty == null)
{
//Fallback to checking length if a "IsEmpty" property is not found
length = Helpers.GetProperty(typeInfo, "Length", false);
if (length == null)
{
length = Helpers.GetProperty(typeInfo, "Count", false);
}
if (length == null)
{
length = Helpers.GetProperty(ResolveIReadOnlyCollection(declaredType, effectiveType[0]), "Count", false);
}
if (length == null)
{
return(false);
}
}
add = Helpers.GetInstanceMethod(builderFactory.ReturnType, "Add", effectiveType);
if (add == null)
{
return(false);
}
finish = Helpers.GetInstanceMethod(builderFactory.ReturnType, "ToImmutable", Helpers.EmptyTypes);
if (finish == null || finish.ReturnType == null || finish.ReturnType == voidType)
{
return(false);
}
if (!(finish.ReturnType == declaredType || Helpers.IsAssignableFrom(declaredType, finish.ReturnType)))
{
return(false);
}
addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] { declaredType });
if (addRange == null)
{
Type enumerable = model.MapType(typeof(System.Collections.Generic.IEnumerable <>), false);
if (enumerable != null)
{
addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] { enumerable.MakeGenericType(effectiveType) });
}
}
return(true);
}
internal string SerializeType(Type type)
{
return(TypeModel.SerializeType(model, type));
}
private CompiledSerializer(IProtoTypeSerializer head, TypeModel model)
{
this.head = head;
serializer = Compiler.CompilerContext.BuildSerializer(head, model);
deserializer = Compiler.CompilerContext.BuildDeserializer(head, model);
}
private IEnumerable<PropertyModel> CreatePropertiesForAttributes(Uri source, TypeModel typeModel, IEnumerable<XmlSchemaObject> items)
{
var properties = new List<PropertyModel>();
foreach (var item in items)
{
var attribute = item as XmlSchemaAttribute;
if (attribute != null)
{
if (attribute.Use != XmlSchemaUse.Prohibited)
{
var attributeQualifiedName = attribute.AttributeSchemaType.QualifiedName;
if (attributeQualifiedName.IsEmpty)
{
attributeQualifiedName = attribute.QualifiedName;
if (attributeQualifiedName.IsEmpty || attributeQualifiedName.Namespace == "")
{
// inner type, have to generate a type name
var typeName = ToTitleCase(typeModel.Name) + ToTitleCase(attribute.QualifiedName.Name);
attributeQualifiedName = new XmlQualifiedName(typeName, typeModel.XmlSchemaName.Namespace);
// try to avoid name clashes
if (NameExists(attributeQualifiedName))
attributeQualifiedName = new[] { "Item", "Property", "Element" }
.Select(s => new XmlQualifiedName(attributeQualifiedName.Name + s, attributeQualifiedName.Namespace))
.First(n => !NameExists(n));
}
}
var attributeName = ToTitleCase(attribute.QualifiedName.Name);
if (attributeName == typeModel.Name) attributeName += "Property"; // member names cannot be the same as their enclosing type
var property = new PropertyModel(_configuration)
{
OwningType = typeModel,
Name = attributeName,
XmlSchemaName = attribute.QualifiedName,
Type = CreateTypeModel(source, attribute.AttributeSchemaType, attributeQualifiedName),
IsAttribute = true,
IsNullable = attribute.Use != XmlSchemaUse.Required,
DefaultValue = attribute.DefaultValue,
Form = attribute.Form == XmlSchemaForm.None ? attribute.GetSchema().AttributeFormDefault : attribute.Form,
XmlNamespace = attribute.QualifiedName.Namespace != "" && attribute.QualifiedName.Namespace != typeModel.XmlSchemaName.Namespace ? attribute.QualifiedName.Namespace : null,
};
var attributeDocs = GetDocumentation(attribute);
property.Documentation.AddRange(attributeDocs);
properties.Add(property);
}
}
else
{
var attributeGroupRef = item as XmlSchemaAttributeGroupRef;
if (attributeGroupRef != null)
{
if (GenerateInterfaces)
CreateTypeModel(new Uri(attributeGroupRef.SourceUri), AttributeGroups[attributeGroupRef.RefName], attributeGroupRef.RefName);
var groupItems = AttributeGroups[attributeGroupRef.RefName].Attributes;
var groupProperties = CreatePropertiesForAttributes(source, typeModel, groupItems.Cast<XmlSchemaObject>());
properties.AddRange(groupProperties);
}
}
}
return properties;
}
/// <summary>
/// Queries an extensible object for an additional (unexpected) data-field for the instance.
/// Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
/// (list) fields.
/// </summary>
/// <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
/// <param name="model">The model to use for configuration.</param>
/// <param name="type">The data-type of the field.</param>
/// <param name="instance">The extensible object to obtain the value from.</param>
/// <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
/// <param name="format">The data-format to use when decoding the value.</param>
/// <returns>An enumerator that yields each occurrence of the field.</returns>
public static IEnumerable GetValues(TypeModel model, System.Type type, IExtensible instance, int tag, DataFormat format)
{
return(ExtensibleUtil.GetExtendedValues(model, type, instance, tag, format, false, false));
}
private static void Verify(GoalPlanningModel1 obj, TypeModel model, string caption)
{
var clone = (GoalPlanningModel1)model.DeepClone(obj);
Assert.IsNull(clone.PublishedGoals, caption + ":published");
Assert.IsNotNull(clone.ProposedGoals, caption + ":proposed");
Assert.AreEqual(1, clone.ProposedGoals.Count(), caption + ":count");
Assert.AreEqual(23, clone.ProposedGoals.Single().X, caption + ":X");
}
/// <summary>
/// Appends the value as an additional (unexpected) data-field for the instance.
/// Note that for non-repeated sub-objects, this equates to a merge operation;
/// for repeated sub-objects this adds a new instance to the set; for simple
/// values the new value supercedes the old value.
/// </summary>
/// <remarks>Note that appending a value does not remove the old value from
/// the stream; avoid repeatedly appending values for the same field.</remarks>
/// <param name="model">The model to use for configuration.</param>
/// <param name="format">The data-format to use when encoding the value.</param>
/// <param name="instance">The extensible object to append the value to.</param>
/// <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
/// <param name="value">The value to append.</param>
public static void AppendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value)
{
ExtensibleUtil.AppendExtendValue(model, instance, tag, format, value);
}