private IEdmEnumType BuildEdmEnumType(EnumTypeElement enumTypeElement)
{
var enumType = new EdmEnumType(_namespaceName, enumTypeElement.ResolveName(), Convert(enumTypeElement.UnderlyingType), false);
foreach (var member in enumTypeElement.Members)
{
enumType.AddMember(member.Key, new EdmIntegerConstant(member.Value));
}
return(enumType);
}
private IEdmEnumType BuildEnumType(EnumTypeElement enumTypeElement)
{
IEdmSchemaType enumType;
if (!_builtTypes.TryGetValue(enumTypeElement.Identity, out enumType))
{
_builtTypes.Add(enumTypeElement.Identity, enumType = BuildEdmEnumType(enumTypeElement));
}
return((IEdmEnumType)enumType);
}
private static Type CreateEnum(ModuleBuilder moduleBuilder, EnumTypeElement element)
{
var typeName = element.ResolveName();
var underlyingType = ConvertType(element.UnderlyingType);
var typeBuilder = moduleBuilder.DefineEnum(typeName, underlyingType);
foreach (var member in element.Members)
{
typeBuilder.DefineLiteral(member.Key, Convert.ChangeType(member.Value, underlyingType));
}
return(typeBuilder.CreateType());
}
private IEdmEnumType ResolveEnumType(EnumTypeElement enumTypeElement)
{
var typeName = enumTypeElement.ResolveName();
IEdmSchemaType enumType;
if (!_registeredTypes.TryGetValue(typeName, out enumType))
{
_registeredTypes.Add(typeName, enumType = BuildEnumType(typeName, enumTypeElement));
AnnotateElement(enumType, enumTypeElement.Identity.Id);
}
return((IEdmEnumType)enumType);
}
private IEdmEnumType ResolveEnumType(EnumTypeElement enumTypeElement)
{
var typeName = enumTypeElement.ResolveName();
IEdmSchemaType enumType;
if (!_registeredTypes.TryGetValue(typeName, out enumType))
{
_registeredTypes.Add(typeName, enumType = BuildEnumType(typeName, enumTypeElement));
AnnotateElement(enumType, enumTypeElement.Identity.Id);
}
return (IEdmEnumType)enumType;
}
private IEdmEnumType BuildEnumType(string typeName, EnumTypeElement enumTypeElement)
{
var enumType = new EdmEnumType(NamespaceName, typeName, Convert(enumTypeElement.UnderlyingType), false);
foreach (var member in enumTypeElement.Members)
{
enumType.AddMember(member.Key, new EdmIntegerConstant(member.Value));
}
return enumType;
}
public void Update(GameTime gameTime)
{
NetIncomingMessage message;
while ((message = _client.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
EnumMessageFromServer typeMessage = (EnumMessageFromServer)message.ReadByte();
switch (typeMessage)
{
case EnumMessageFromServer.Init:
_ipEndPoint = message.SenderEndPoint;
uint nbElements = message.ReadUInt16();
for (int i = 0; i < nbElements; i++)
{
EnumTypeElement elementType = (EnumTypeElement)message.ReadByte();
switch (elementType)
{
case EnumTypeElement.Loup:
break;
case EnumTypeElement.Guerrier:
break;
}
}
break;
case EnumMessageFromServer.Update:
int ID = message.ReadUInt16();
var NetworkObject = _networkObjects.FirstOrDefault(p => p != null && p.id == ID);
if (NetworkObject != null)
{
NetworkObject.Synchronise(message);
}
break;
}
break;
case NetIncomingMessageType.StatusChanged:
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.None:
break;
case NetConnectionStatus.InitiatedConnect:
break;
case NetConnectionStatus.ReceivedInitiation:
break;
case NetConnectionStatus.RespondedAwaitingApproval:
break;
case NetConnectionStatus.RespondedConnect:
break;
case NetConnectionStatus.Connected:
break;
case NetConnectionStatus.Disconnecting:
break;
case NetConnectionStatus.Disconnected:
break;
default:
break;
}
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
_client.Recycle(message);
}
foreach (var NetworkObject in _networkObjects)
{
NetworkObject.Update(gameTime);
}
}
private static Type CreateEnum(ModuleBuilder moduleBuilder, EnumTypeElement element)
{
var typeName = element.ResolveName();
var underlyingType = ConvertType(element.UnderlyingType);
var typeBuilder = moduleBuilder.DefineEnum(typeName, underlyingType);
foreach (var member in element.Members)
{
typeBuilder.DefineLiteral(member.Key, Convert.ChangeType(member.Value, underlyingType));
}
return typeBuilder.CreateType();
}
/// <summary>
/// Gets the supportive feature information of all the metadata elements.
/// Note: This method is only used to validate all the terms with enumeration type.
/// </summary>
/// <param name="targetShortName">The short name of target element.</param>
/// <param name="termElement">The term information which will be validated.</param>
/// <param name="enumTypeElement">The enumeration type template.</param>
/// <param name="metadataDoc">The metadata document.</param>
/// <returns>Returns the validation.</returns>
public static List<KeyValuePair<string, int>> GetSupportiveFeatureInfo(string targetShortName, TermElement termElement, EnumTypeElement enumTypeElement, string metadataDoc)
{
if (string.IsNullOrEmpty(targetShortName) || null == termElement || null == enumTypeElement || !metadataDoc.IsXmlPayload())
{
return null;
}
var metadata = XElement.Parse(metadataDoc);
string aliasTermName = string.Format("{0}.{1}", termElement.Alias, termElement.Name);
string namespaceTermName = string.Format("{0}.{1}", termElement.Namespace, termElement.Name);
List<KeyValuePair<string, int>> result = new List<KeyValuePair<string, int>>();
for (int i = 0; i < termElement.AppliesTo.Length; i++)
{
// Get the annotation information from target element in metadata. (e.g. EntitySet)
string xPath = string.Format("//*[local-name()='{0}' and @Name='{1}']/*[local-name()='Annotation'][@Term='{2}' or @Term='{3}']/*[local-name()='EnumMember']",
termElement.AppliesTo[i],
targetShortName,
aliasTermName,
namespaceTermName);
var enumMemberElement = metadata.XPathSelectElement(xPath, ODataNamespaceManager.Instance);
if (null != enumMemberElement)
{
string[] enumMembers = enumMemberElement.Value.Split(' ');
foreach (var enumMember in enumMembers)
{
foreach (var m in enumTypeElement.Members)
{
if (enumMember.Contains(m.Key))
{
result.Add(new KeyValuePair<string, int>(m.Key, m.Value));
}
}
}
}
else
{
xPath = string.Format("//*[local-name()='{0}' and @Name='{1}']", termElement.AppliesTo[i], targetShortName);
var entitySetElement = metadata.XPathSelectElement(xPath, ODataNamespaceManager.Instance);
if (null != entitySetElement)
{
var localAliasNamespace = MetadataHelper.GetAliasAndNamespace(entitySetElement);
// Get the annotation information from Annotations element in metadata.
xPath = string.Format(
"//*[local-name()='Annotations'][@Target='{0}' or @Target='{1}' or @Target='{2}']/*[local-name()='Annotation'][@Term='{3}' or @Term='{4}']/*[local-name()='EnumMember']",
targetShortName,
string.Format("{0}.{1}", localAliasNamespace.Alias, targetShortName),
string.Format("{0}.{1}", localAliasNamespace.Namespace, targetShortName),
aliasTermName,
namespaceTermName);
enumMemberElement = metadata.XPathSelectElement(xPath, ODataNamespaceManager.Instance);
if (null != enumMemberElement)
{
string[] enumMembers = enumMemberElement.Value.Split(' ');
foreach (var enumMember in enumMembers)
{
foreach (var m in enumTypeElement.Members)
{
if (enumMember.Contains(m.Key))
{
result.Add(new KeyValuePair<string, int>(m.Key, m.Value));
}
}
}
}
}
}
if (result.Any())
{
return result;
}
}
return result;
}
private IEdmEnumType BuildEnumType(EnumTypeElement enumTypeElement)
{
IEdmSchemaType enumType;
if (!_builtTypes.TryGetValue(enumTypeElement.Identity, out enumType))
{
_builtTypes.Add(enumTypeElement.Identity, enumType = BuildEdmEnumType(enumTypeElement));
}
return (IEdmEnumType)enumType;
}
