public static void StreamType <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
string keyName, ref MegaloScriptVariableReferenceType type)
where TDoc : class
where TCursor : class
{
s.StreamAttributeEnum(keyName, ref type);
}
internal void SerializeTimer <TDoc, TCursor>(MegaloScriptModel model, IO.TagElementStream <TDoc, TCursor, string> s)
where TDoc : class
where TCursor : class
{
mReferenceKind = MegaloScriptVariableReferenceType.Timer;
Serialize(model, s, model.Database.VariableRefTypes[mReferenceKind]);
}
/// <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="dataValue">Actual 'data' value for the variable reference</param>
/// <param name="dataTypeName">Optional type info for <paramref name="dataValue"/></param>
/// <returns></returns>
public MegaloScriptVariableReferenceData NewVarReference(MegaloScriptVariableReferenceType refKind,
string refMemberName, int dataValue = TypeExtensions.kNone,
string dataTypeName = null)
{
Contract.Requires(!string.IsNullOrEmpty(refMemberName));
MegaloScriptVariableReferenceData result;
Proto.MegaloScriptProtoVariableReferenceMember member;
MegaloScriptVariableReferenceData.Initialize(this,
out result, refKind, out member, refMemberName, dataTypeName);
result.Data = dataValue;
return(result);
}
/// <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="indexName">Actual 'data' value for the variable reference</param>
/// <param name="dataTypeName">Optional type info for <paramref name="indexName"/></param>
/// <returns></returns>
public MegaloScriptVariableReferenceData NewVarReferenceWithIndexData(MegaloScriptVariableReferenceType refKind,
string refMemberName, string indexName,
string dataTypeName = null)
{
Contract.Requires(!string.IsNullOrEmpty(refMemberName));
Contract.Requires(indexName != null);
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 index data");
result.Data = GetTargetIndexFromName(member.ValueType.IndexTarget, indexName);
return(result);
}
/// <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);
}
/// <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;
}
internal void SerializeTimer(MegaloScriptModel model, IO.BitStream s)
{
mReferenceKind = MegaloScriptVariableReferenceType.Timer;
Serialize(model, s, model.Database.VariableRefTypes[mReferenceKind]);
}
