public void TestEnumMember()
{
var obj = new EnumMember {
Member = TestEnum.Value1
};
var container = new NodeContainer();
// Construction
var containerNode = container.GetOrCreateNode(obj);
Helper.TestNonCollectionObjectNode(containerNode, obj, 1);
var memberNode = containerNode.Members.First();
Helper.TestMemberNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
// Update from object
obj.Member = TestEnum.Value2;
Helper.TestMemberNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
// Update from Quantum
containerNode.Members.First().Update(TestEnum.Value3);
Helper.TestMemberNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
}
private void CompareEnumMember(EnumType expectedEnumType, EnumMember expectedMemeber, EnumType actualEnumType, EnumMember actualMember)
{
this.SatisfiesEquals(expectedMemeber.Name, actualMember.Name, "Enum member name not match.");
this.SatisfiesEquals(this.GetIntegralEnumMemberValue(expectedEnumType, expectedMemeber), this.GetIntegralEnumMemberValue(actualEnumType, actualMember), "Enum member value does not match.");
this.CompareAnnotations(expectedMemeber.Annotations, actualMember.Annotations);
}
public void EndElement(string localName, string qName)
{
if (!abort)
{
if (qName.Equals(rdfProfileElement) || qName.Equals(cimsClassCategoryElement) ||
qName.Equals(rdfsClassElement) || qName.Equals(rdfPropertyElement)) //end of element
{
//novo
if (prop != null)
{
string type;
prop.TryGetValue(rdfType, out type);
if (ExtractSimpleNameFromResourceURI(type) == "ClassCategory")
{
ClassCategory cs = new ClassCategory();
foreach (KeyValuePair <string, string> pp in prop)
{
string str = pp.Value;
if ((pp.Key.Equals(cimsBelongsToCategory)) && (str != null))
{
cs.BelongsToCategory = str;
AddBelongingInformation(cs, cs.BelongsToCategory);
}
else if ((pp.Key.Equals(rdfsComment)) && (str != null))
{
cs.Comment = str;
}
else if ((pp.Key.Equals(rdfsLabel)) && (str != null))
{
cs.Label = str;
}
else if ((pp.Key.Equals(rdfType)) && (str != null))
{
cs.Type = str;
}
else if ((pp.Key.Equals(rdfProfileElement)) && (str != null))
{
cs.URI = str;
}
else if ((pp.Key.Equals(cimsMultiplicity)) && (str != null))
{
cs.MultiplicityAsString = ExtractSimpleNameFromResourceURI(str);
}
}
AddProfileElement(ProfileElementTypes.ClassCategory, cs);
}
else if (ExtractSimpleNameFromResourceURI(type) == "Class")
{
Class cs = new Class();
foreach (KeyValuePair <string, string> pp in prop)
{
string str = pp.Value;
if ((pp.Key.Equals(cimsBelongsToCategory)) && (str != null))
{
cs.BelongsToCategory = str;
AddBelongingInformation(cs, cs.BelongsToCategory);
}
else if ((pp.Key.Equals(rdfsComment)) && (str != null))
{
cs.Comment = str;
}
else if ((pp.Key.Equals(rdfsLabel)) && (str != null))
{
cs.Label = str;
}
else if ((pp.Key.Equals(cimsMultiplicity)) && (str != null))
{
cs.MultiplicityAsString = ExtractSimpleNameFromResourceURI(str);
}
else if ((pp.Key.Contains(cimsStereotype)) && (str != null))
{
cs.AddStereotype(str);
}
else if ((pp.Key.Contains(rdfsSubClassOf)) && (str != null))
{
cs.SubClassOf = str;
}
else if ((pp.Key.Equals(rdfType)) && (str != null))
{
cs.Type = str;
}
else if ((pp.Key.Equals(rdfProfileElement)) && (str != null))
{
cs.URI = str;
}
}
AddProfileElement(ProfileElementTypes.Class, cs);
}
else if (ExtractSimpleNameFromResourceURI(type) == "Property")
{
Property pr = new Property();
foreach (KeyValuePair <string, string> pp in prop)
{
string str = pp.Value;
if ((pp.Key.Equals(cimsDataType)) && (str != null))
{
pr.DataType = str;
}
else if ((pp.Key.Equals(cimsMultiplicity)) && (str != null))
{
pr.MultiplicityAsString = str;
}
else if ((pp.Key.Equals(rdfProfileElement)) && (str != null))
{
pr.URI = str;
}
else if ((pp.Key.Equals(rdfType)) && (str != null))
{
pr.Type = str;
}
else if ((pp.Key.Equals(rdfsDomain)) && (str != null))
{
pr.Domain = str;
AddBelongingInformation(pr, pr.Domain);
}
else if ((pp.Key.Contains(cimsStereotype)) && (str != null))
{
pr.AddStereotype(str);
}
else if ((pp.Key.Contains(rdfsComment)) && (str != null))
{
pr.Comment = str;
}
else if ((pp.Key.Equals(rdfsLabel)) && (str != null))
{
pr.Label = str;
}
else if ((pp.Key.Equals(rdfsRange)) && (str != null))
{
pr.Range = str;
}
}
AddProfileElement(ProfileElementTypes.Property, pr);
}
else
{
EnumMember en = new EnumMember();
foreach (KeyValuePair <string, string> pp in prop)
{
string str = pp.Value;
if ((pp.Key.Equals(rdfsComment)) && (str != null))
{
en.Comment = str;
}
else if ((pp.Key.Equals(rdfsLabel)) && (str != null))
{
en.Label = str;
}
else if ((pp.Key.Equals(rdfType)) && (str != null))
{
en.Type = str;
}
else if ((pp.Key.Equals(rdfProfileElement)) && (str != null))
{
en.URI = str;
}
else if ((pp.Key.Equals(cimsMultiplicity)) && (str != null))
{
en.MultiplicityAsString = ExtractSimpleNameFromResourceURI(str);
}
}
AddProfileElement(ProfileElementTypes.Unknown, en);
}
prop.Clear();
}
}
else if (qName.Equals(rdfsLabel)) //// end of label subelement
{
content = content.Trim();
if (!string.IsNullOrEmpty(content))
{
//novo
string ls;
prop.TryGetValue(qName, out ls);
if (ls == null)
{
ls = (string)content.Clone();
prop.Add(qName, ls);
}
content = string.Empty;
}
}
else if (qName.Equals(rdfsComment)) //// end of comment subelement
{
content = content.Trim();
if (!string.IsNullOrEmpty(content))
{
//novo
string ls;
prop.TryGetValue(qName, out ls);
if (ls == null)
{
ls = (string)content.Clone();
prop.Add(qName, ls);
}
content = string.Empty;
}
}
else if (qName.Equals(cimsIsAggregate)) //// end of isAggregate subelement
{
content = content.Trim();
if (!string.IsNullOrEmpty(content))
{
bool paresedValue;
//novo
string ls;
prop.TryGetValue(qName, out ls);
if (ls == null)
{
if (bool.TryParse((string)content.Clone(), out paresedValue))
{
ls = paresedValue.ToString();
}
prop.Add(qName, ls);
}
content = string.Empty;
}
}
}
}
protected override void VisitEdmEnumTypeMember(EnumMember item)
{
_schemaWriter.WriteEnumTypeMemberElementHeader(item);
base.VisitEdmEnumTypeMember(item);
_schemaWriter.WriteEndElement();
}
public static IEnumerable <object> GetFlags(EnumMember member) => FlagEnums.GetFlags(member);
protected virtual void VisitEdmEnumTypeMember(EnumMember item)
{
VisitMetadataItem(item);
}
private bool IsTheSame(EnumMember comparisonEnumMember)
{
return(IsTheSame(comparisonEnumMember, ComparisonDepth.Signature));
}
public void TestEnumMember()
{
var obj = new EnumMember { Member = TestEnum.Value1 };
var container = new NodeContainer();
// Construction
var containerNode = (GraphNode)container.GetOrCreateNode(obj);
Helper.TestNonCollectionObjectContentNode(containerNode, obj, 1);
var memberNode = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
// Update from object
obj.Member = TestEnum.Value2;
Helper.TestMemberContentNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
// Update from Quantum
containerNode.Children.First().Content.Update(TestEnum.Value3);
Helper.TestMemberContentNode(containerNode, memberNode, obj, obj.Member, nameof(EnumMember.Member), false);
}
public override void OnEnumMember(EnumMember node)
{
base.OnEnumMember(node);
Check(node);
}
public EnumNode(string type, string value, Location location) : base(location)
{
Type = type;
Value = value;
EnumMember = EnumData.GetEnumValue(type, value);
}
private bool IsTheSame(EnumMember comparisonEnumMember, ComparisonDepth depth)
{
if (Name == comparisonEnumMember.Name)
{
if ((ParentObject == null && comparisonEnumMember.ParentObject == null) ||
(ParentObject.GetType() == comparisonEnumMember.ParentObject.GetType() &&
ParentObject.Name == comparisonEnumMember.ParentObject.Name))
{
if (depth == ComparisonDepth.Signature)
{
return true;
}
if (!base.IsTheSame(comparisonEnumMember, depth))
{
return false;
}
return true;
}
}
return false;
}
private bool IsTheSame(EnumMember comparisonEnumMember)
{
return IsTheSame(comparisonEnumMember, ComparisonDepth.Signature);
}
private EnumMember(EnumMember emToCopyFrom)
: base(null)
{
emToCopyFrom.CloneInto(this);
Value = emToCopyFrom.Value;
}
public InternalEnumMember(TypeSystemServices tagManager, EnumMember member)
{
_member = member;
}
// Implemented in derived class int IComparable <EnumMember <TEnum> > .CompareTo(EnumMember <TEnum> other) => 0;
protected override Expression <Func <EnumMember, bool> > FindExisting(EnumMember record) => existing => existing.DocumentationCommentId == record.DocumentationCommentId && ((existing.EqualsValueId == null && record.EqualsValueId == null) || (existing.EqualsValueId == record.EqualsValueId)) && existing.IdentifierId == record.IdentifierId;
/// <summary>
/// Retrieves the <see cref="EnumMember"/>s of the flags that compose <paramref name="member"/>'s value.
/// </summary>
/// <param name="member">The enum member.</param>
/// <returns>The <see cref="EnumMember"/>s of the flags that compose <paramref name="member"/>'s value.</returns>
/// <exception cref="ArgumentNullException"><paramref name="member"/> is <c>null</c>.</exception>
public static IEnumerable <EnumMember> GetFlagMembers(this EnumMember member)
{
Preconditions.NotNull(member, nameof(member));
return(member.GetFlagMembers());
}
private EnumMember(EnumMember emToCopyFrom)
: base(null)
{
emToCopyFrom.CloneInto(this);
Value = emToCopyFrom.Value;
}
internal MetadataEnumMember(string name, TypeUsage enumType, EnumMember enumMember)
: base(MetadataMemberClass.EnumMember, name)
{
this.EnumType = enumType;
this.EnumMember = enumMember;
}
private void ParseEnumMember(TypeExpression typeExpression, List<ITypeDeclarationMember> members, TokenSet followers)
//^ requires this.currentToken == Token.LeftBracket || Parser.IdentifierOrNonReservedKeyword[this.currentToken];
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
SourceLocationBuilder sctx = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
List<SourceCustomAttribute>/*?*/ attributes = this.ParseAttributes(followers|Parser.AttributeOrTypeDeclarationStart|Parser.IdentifierOrNonReservedKeyword);
if (!Parser.IdentifierOrNonReservedKeyword[this.currentToken])
this.HandleError(Error.ExpectedIdentifier);
NameDeclaration name = this.ParseNameDeclaration();
Expression/*?*/ initializer = null;
if (this.currentToken == Token.Assign) {
this.GetNextToken();
initializer = this.ParseExpression(followers);
}
EnumMember member = new EnumMember(attributes, typeExpression, name, initializer, sctx);
members.Add(member);
this.SkipTo(followers);
}
internal void WriteEnumTypeMemberElementHeader(EnumMember enumTypeMember)
{
_xmlWriter.WriteStartElement(XmlConstants.Member);
_xmlWriter.WriteAttributeString(XmlConstants.Name, enumTypeMember.Name);
_xmlWriter.WriteAttributeString(XmlConstants.Value, enumTypeMember.Value.ToString());
}
public override void OnEnumMember(EnumMember node)
{
throw new NotImplementedException();
IL_0006 :;
}
public EnumValuePair(EnumMember member, bool constant, CodeType type) : base(member.CodeName, constant ? CompletionItemKind.Constant : CompletionItemKind.EnumMember)
{
Member = member;
CodeType = type;
}
public static IEnumerable <EnumMember> GetFlagMembers(EnumMember member) => FlagEnums.GetFlagMembers(member);
/// <summary>
/// Indicates whether <paramref name="member"/>'s value is a valid flag combination of its enum's defined values.
/// </summary>
/// <param name="member">The enum member.</param>
/// <returns>Indication of whether <paramref name="member"/>'s value is a valid flag combination of its enum's defined values.</returns>
/// <exception cref="ArgumentNullException"><paramref name="member"/> is <c>null</c>.</exception>
public static bool IsValidFlagCombination([NotNull] this EnumMember member)
{
return(member.IsValidFlagCombination());
}
protected virtual void Visit(EnumMember enumMember)
{
}
/// <summary>
/// Retrieves the <see cref="EnumMember{TEnum}"/>s of the flags that compose <paramref name="member"/>'s value.
/// </summary>
/// <typeparam name="TEnum">The enum type.</typeparam>
/// <param name="member">The enum member.</param>
/// <returns>The <see cref="EnumMember{TEnum}"/>s of the flags that compose <paramref name="member"/>'s value.</returns>
/// <exception cref="ArgumentNullException"><paramref name="member"/> is <c>null</c>.</exception>
public static IEnumerable <EnumMember <TEnum> > GetFlagMembers <TEnum>([NotNull] this EnumMember <TEnum> member)
where TEnum : struct, Enum, IComparable
{
return(member.GetGenericFlagMembers());
}
public static CompilerError EnumMemberMustBeConstant(EnumMember member)
{
return(Instantiate("BCE0170", member, member.FullName));
}
/// <summary>
/// Indicates if <paramref name="member"/>'s value has all of the flags that are defined in its enum type.
/// </summary>
/// <param name="member">The enum member.</param>
/// <returns>Indication if <paramref name="member"/> has all of the flags that are defined in its enum type.</returns>
/// <exception cref="ArgumentNullException"><paramref name="member"/> is <c>null</c>.</exception>
public static bool HasAllFlags([NotNull] this EnumMember member)
{
return(member.HasAllFlags());
}
/// <summary>
/// Indicates whether the specified <see cref="EnumMember{TEnum}"/> is equal to the current <see cref="EnumMember{TEnum}"/>.
/// </summary>
/// <param name="other">The other <see cref="EnumMember{TEnum}"/>.</param>
/// <returns>Indication whether the specified <see cref="EnumMember{TEnum}"/> is equal to the current <see cref="EnumMember{TEnum}"/>.</returns>
public bool Equals(EnumMember <TEnum> other) => ReferenceEquals(this, other);
/// <summary>
/// Retrieves the flag count of <paramref name="member"/>.
/// </summary>
/// <param name="member">The flags enum value.</param>
/// <returns>The flag count of <paramref name="member"/>.</returns>
public static int GetFlagCount([NotNull] this EnumMember member)
{
return(member.GetFlagCount());
}
public EnumNode(string type, string value, Range range) : base(range)
{
Type = type;
Value = value;
EnumMember = EnumData.GetEnumValue(type, value);
}
public EnumValuePair(EnumMember member, bool constant, CodeType type) : base(member.CodeName, constant ? CompletionItemKind.Constant : CompletionItemKind.EnumMember)
{
Member = member;
CodeType = type;
TokenType = Deltin.Deltinteger.Parse.TokenType.EnumMember;
}
/// <inheritdoc />
public (Stream stream, ContentType contentType) Select(IRequest <MetadataDocument> request)
{
var stream = new MemoryStream();
var metadata = Metadata.Get(MetadataLevel.Full);
using (var swr = new StreamWriter(stream, Encoding.UTF8, 1024, true))
{
swr.Write("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
swr.Write("<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\"><edmx:DataServices>");
swr.Write("<Schema Namespace=\"global\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">");
var(enumTypes, complexTypes) = metadata.PeripheralTypes.Split(t => t.Key.IsEnum);
#region Print enum types
foreach (var pair in enumTypes)
{
swr.Write($"<EnumType Name=\"{pair.Key.FullName}\">");
foreach (var member in EnumMember.GetMembers(pair.Key))
{
swr.Write($"<Member Name=\"{member.Name}\" Value=\"{member.NumericValue}\"/>");
}
swr.Write("</EnumType>");
}
#endregion
#region Print complex types
foreach (var pair in complexTypes)
{
var(type, members) = (pair.Key, pair.Value);
var(dynamicMembers, declaredMembers) = members.Split(IsDynamicMember);
var isOpenType = type.IsDynamic() || dynamicMembers.Any();
swr.Write($"<ComplexType Name=\"{type.FullName}\" OpenType=\"{isOpenType.XMLBool()}\">");
WriteMembers(swr, declaredMembers);
swr.Write("</ComplexType>");
}
#endregion
#region Print entity types
foreach (var pair in metadata.EntityResourceTypes.Where(t => t.Key != typeof(Metadata)))
{
var(type, members) = (pair.Key, pair.Value);
var(dynamicMembers, declaredMembers) = members.Split(IsDynamicMember);
var isOpenType = type.IsDynamic() || dynamicMembers.Any();
swr.Write($"<EntityType Name=\"{type.FullName}\" OpenType=\"{isOpenType.XMLBool()}\">");
var key = declaredMembers.OfType <DeclaredProperty>().FirstOrDefault(p => p.HasAttribute <KeyAttribute>());
if (key != null)
{
swr.Write($"<Key><PropertyRef Name=\"{key.Name}\"/></Key>");
}
WriteMembers(swr, declaredMembers.Where(p => !(p is DeclaredProperty d) || !d.Hidden || d.Equals(key)));
swr.Write("</EntityType>");
}
swr.Write("<EntityType Name=\"RESTar.DynamicResource\" OpenType=\"true\"/>");
#endregion
#region Write entity container and entity sets
swr.Write($"<EntityContainer Name=\"{EntityContainerName}\">");
foreach (var entitySet in metadata.EntityResources.Where(t => t.Type != typeof(Metadata)))
{
swr.Write($"<EntitySet EntityType=\"{GetEdmTypeName(entitySet.Type)}\" Name=\"{entitySet.Name}\">");
var methods = metadata.CurrentAccessScope[entitySet].Intersect(entitySet.AvailableMethods).ToList();
swr.Write(InsertableAnnotation(methods.Contains(Method.POST)));
swr.Write(UpdatableAnnotation(methods.Contains(Method.PATCH)));
swr.Write(DeletableAnnotation(methods.Contains(Method.DELETE)));
swr.Write("</EntitySet>");
}
swr.Write("</EntityContainer>");
swr.Write($"<Annotations Target=\"global.{EntityContainerName}\">");
swr.Write("<Annotation Term=\"Org.OData.Capabilities.V1.ConformanceLevel\"><EnumMember>Org.OData.Capabilities.V1." +
"ConformanceLevelType/Minimal</EnumMember></Annotation>");
swr.Write("<Annotation Term=\"Org.OData.Capabilities.V1.SupportedFormats\">");
swr.Write("<Collection>");
swr.Write("<String>application/json;odata.metadata=minimal;IEEE754Compatible=false;odata.streaming=true</String>");
swr.Write("</Collection>");
swr.Write("</Annotation>");
swr.Write("<Annotation Bool=\"true\" Term=\"Org.OData.Capabilities.V1.AsynchronousRequestsSupported\"/>");
swr.Write("<Annotation Term=\"Org.OData.Capabilities.V1.FilterFunctions\"><Collection></Collection></Annotation>");
swr.Write("</Annotations>");
swr.Write("</Schema>");
swr.Write("</edmx:DataServices></edmx:Edmx>");
#endregion
}
return(stream, ContentType);
}
/// <summary>
/// Visit Enum member
/// </summary>
/// <param name="enumMember">enum member to visit</param>
protected virtual void VisitEnumMember(EnumMember enumMember)
{
this.VisitAnnotatedItem(enumMember);
}
