/// <summary>Model helper only: Initialize the core properties of a variable reference</summary>
/// <param name="model"></param>
/// <param name="result">The initialized variable reference</param>
/// <param name="refKind">The kind of variable reference to create</param>
/// <param name="refTypeMember">Returns the proto member we've initialized the result to</param>
/// <param name="refMemberName">The specific member of the variable reference to initialize to</param>
/// <param name="dataTypeName">Only used if the reference member has a data type property</param>
internal static void Initialize(MegaloScriptModel model,
out MegaloScriptVariableReferenceData result, MegaloScriptVariableReferenceType refKind,
out Proto.MegaloScriptProtoVariableReferenceMember refTypeMember,
string refMemberName, string dataTypeName = null)
{
result.mReferenceKind = refKind;
var protoType = model.Database.VariableRefTypes[refKind];
result.Type = MegaloScriptVariableReferenceData.ToMemberIndex(protoType, refMemberName);
refTypeMember = protoType.Members[result.Type];
if (refTypeMember.HasDataType)
{
Contract.Assert(dataTypeName != null, "Reference type uses a data type parameter, but one wasn't defined");
var id_resolving_ctxt = new Proto.MegaloScriptEnum.EnumNameResolvingContext(model.Database, refTypeMember.EnumValueType);
result.DataType = Proto.MegaloScriptEnum.EnumNameResolvingContext.IdResolver(id_resolving_ctxt, dataTypeName);
}
else
{
result.DataType = TypeExtensions.kNone;
}
result.Data = TypeExtensions.kNone;
}
public void ChangeValue(MegaloScriptModel model, string enumMemberName)
{
Contract.Requires(!string.IsNullOrEmpty(enumMemberName));
var id_resolving_ctxt = new Proto.MegaloScriptEnum.EnumNameResolvingContext(model.Database, ValueType);
Value = Proto.MegaloScriptEnum.EnumNameResolvingContext.IdResolver(id_resolving_ctxt, enumMemberName);
}
internal static void SerializeValue <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s,
MegaloScriptValueType valueType, ref int value,
IO.TagElementNodeType nodeType = IO.TagElementNodeType.Text, string nodeName = null)
where TDoc : class
where TCursor : class
{
Contract.Requires(valueType.BaseType == MegaloScriptValueBaseType.Enum);
if ((model.TagElementStreamSerializeFlags & MegaloScriptModelTagElementStreamFlags.UseEnumNames) != 0)
{
var id_resolving_ctxt = new Proto.MegaloScriptEnum.EnumNameResolvingContext(model.Database, valueType);
var id_resolver = Proto.MegaloScriptEnum.EnumNameResolvingContext.IdResolver;
var name_resolver = Proto.MegaloScriptEnum.EnumNameResolvingContext.NameResolver;
switch (nodeType)
{
case IO.TagElementNodeType.Element:
s.StreamElementIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver);
break;
case IO.TagElementNodeType.Attribute:
s.StreamAttributeIdAsString(nodeName, ref value, id_resolving_ctxt, id_resolver, name_resolver);
break;
case IO.TagElementNodeType.Text:
s.StreamCursorIdAsString(ref value, id_resolving_ctxt, id_resolver, name_resolver);
break;
}
}
else
{
switch (nodeType)
{
case IO.TagElementNodeType.Element: s.StreamElement(nodeName, ref value); break;
case IO.TagElementNodeType.Attribute: s.StreamAttribute(nodeName, ref value); break;
case IO.TagElementNodeType.Text: s.StreamCursor(ref value); break;
}
}
}
/// <summary></summary>
/// <param name="refKind">The kind of variable we're this reference</param>
/// <param name="refMemberName">The variable's reference type</param>
/// <param name="enumMemberName">Actual 'data' value for the variable reference</param>
/// <param name="dataTypeName">Optional type info for <paramref name="enumMemberName"/></param>
/// <returns></returns>
public MegaloScriptVariableReferenceData NewVarReferenceWithEnumData(MegaloScriptVariableReferenceType refKind,
string refMemberName, string enumMemberName,
string dataTypeName = null)
{
Contract.Requires(!string.IsNullOrEmpty(refMemberName));
Contract.Requires(!string.IsNullOrEmpty(enumMemberName));
MegaloScriptVariableReferenceData result;
Proto.MegaloScriptProtoVariableReferenceMember member;
MegaloScriptVariableReferenceData.Initialize(this,
out result, refKind, out member, refMemberName, dataTypeName);
Contract.Assert(member.HasDataValue, "Member has no data field, let alone enum data");
var id_resolving_ctxt = new Proto.MegaloScriptEnum.EnumNameResolvingContext(Database, member.EnumValueType);
result.Data = Proto.MegaloScriptEnum.EnumNameResolvingContext.IdResolver(id_resolving_ctxt, enumMemberName);
return(result);
}
