// Load Protocol XML and merge to current protocol group
public bool LoadFile(string strFileName)
{
try
{
TextReader reader = new StreamReader(strFileName);
XmlSerializer serializer = new XmlSerializer(typeof(ProtocolXml.ProtocolTypes));
ProtocolXml.ProtocolTypes protocolTypes = (ProtocolXml.ProtocolTypes)serializer.Deserialize(reader);
reader.Close();
foreach (var itDataType in protocolTypes.DataType)
{
SystemTypeInfo.AddTypeInfo(itDataType);
}
}
catch (XmlException xe)
{
Console.WriteLine("XML Parse Error: " + xe.Message);
return(false);
}
catch (InvalidOperationException ioe)
{
Console.WriteLine("XML Serialization Error: " + ioe.Message);
return(false);
}
catch (SystemException se)
{
Console.WriteLine("System Error: " + se.Message);
return(false);
}
return(true);
}
/// <summary>
/// 获取所有的功能树Json
/// </summary>
/// <returns></returns>
public ActionResult GetAllJsTreeJson()
{
List <JsTreeData> treeList = new List <JsTreeData>();
SystemTypeInfo typeInfo = BLLFactory <SystemType> .Instance.FindByOID(ConfigData.SystemType);
if (typeInfo != null)
{
var pid = typeInfo.OID;
JsTreeData pNode = new JsTreeData(pid, typeInfo.Name);
treeList.Add(pNode);
string systemType = typeInfo.OID;//系统标识ID
//绑定树控件
List <FunctionNodeInfo> functionList = BLLFactory <Function> .Instance.GetTree(systemType);
foreach (FunctionNodeInfo info in functionList)
{
JsTreeData item = new JsTreeData(info.ID, info.Name, "fa fa-key icon-state-danger icon-lg");
pNode.children.Add(item);
AddJsTreeChildNode(info.Children, item);
}
}
return(ToJsonContent(treeList));
}
public virtual string ToTargetTypeName(Parameter param)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (IsCPPOut)
{
return(typeInfo.CPPTypeName);// SystemTypeInfo.ToCPPType(type);
}
if (IsCSharpNative)
{
//if (csType == typeof(string))
if (typeInfo.IsString)
{
return("byte[]");
}
else if (typeInfo.IsCSharpStruct)
{
return("ref " + typeInfo.CSharpTypeName);
}
else if (typeInfo.IsEnum)
{
return("int");
}
else
{
return(typeInfo.CSharpTypeName);
}
}
return(typeInfo.CSharpTypeName);
}
/// <summary>
/// 新增状态下的数据保存
/// </summary>
/// <returns></returns>
public override bool SaveAddNew()
{
SystemTypeInfo info = new SystemTypeInfo();
SetInfo(info);
try
{
#region 新增数据
//检查是否还有其他相同关键字的记录
bool exist = BLLFactory <SystemType> .Instance.IsExistKey("OID", info.OID);
if (exist)
{
MessageDxUtil.ShowTips("指定的【系统标识】已经存在，不能重复添加，请修改");
return(false);
}
bool succeed = BLLFactory <SystemType> .Instance.Insert(info);
if (succeed)
{
//可添加其他关联操作
return(true);
}
#endregion
}
catch (Exception ex)
{
LogHelper.WriteLog(LogLevel.LOG_LEVEL_CRIT, ex, typeof(FrmEditSystemType));
MessageDxUtil.ShowError(ex.Message);
}
return(false);
}
// Builder parameters size
public void BuildParamSize(Parameter[] parameters, string strSizeVarName)
{
// size calculation
MatchIndent();
OutStream.Write(string.Format("int {0} = sizeof(UInt64)*2 ", strSizeVarName));
if (parameters != null)
{
foreach (Parameter param in parameters)
{
NewLine(); MatchIndent(1);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (typeInfo.IsString)
{
OutStream.Write("+ binWriter.StringEncoder.GetByteCount({0}) + 1 + 2", InParamName(param.Name));
}
else
{
if (param.IsArray)
{
OutStream.Write("+ Marshal.SizeOf({0})*({1}.Length) + sizeof(UInt16)", typeInfo.CSharpTypeName, InParamName(param.Name));
}
else
{
OutStream.Write("+ Marshal.SizeOf({0})", typeInfo.CSharpTypeName);
}
}
}
}
OutStream.WriteLine(";");
}
// Builder parameter string
public void PrepareSendFunctionParametersCPP(string strPrefix, Parameter[] parameter)
{
TypeUsage from = TypeUsage.CPPForSharp;
TypeUsage to = ParameterMode;
if (parameter == null)
{
return;
}
foreach (Parameter param in parameter)
{
string paramElementTypeName = SystemTypeInfo.ElementTypeNameFor(from, param);
string paramTypeNameOnly = SystemTypeInfo.TypeNameOnlyFor(from, param);
string paramTypeFrom = SystemTypeInfo.TypeNameFor(from, param);
string paramTypeTo = SystemTypeInfo.TypeNameFor(to, param);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type scharpType = SystemTypeInfo.ToCSharpType(param.Type);
bool paramTypeEquality = paramTypeFrom == paramTypeTo;
//bool bIsStruct = IsStruct(param.Type);
// Disable native conversion
if (param.IsArray) // string type
{
if (IsStrType(param))
{
string varName = string.Format("{0}{1}", strPrefix, InParamName(param.Name));
MatchIndent(); OutStream.WriteLine("auto& {0}Array_ = *NativeToObject<SF::ArrayObject<const char*>>({0});", varName);
}
}
}
}
/// <summary>
/// 数据显示的函数
/// </summary>
public override void DisplayData()
{
InitDictItem();//数据字典加载（公用）
if (Id > 0)
{
#region 显示客户信息
SystemTypeInfo info = BLLFactory <SystemType> .Instance.FindById(Id);
if (info != null)
{
this.txtOid.Text = info.Gid;
txtName.Text = info.Name;
txtCustomID.Text = info.ConsumerCode;
txtAuthorize.Text = info.Licence;
txtNote.Text = info.Remark;
this.txtOid.Enabled = false;
}
#endregion
}
else
{
}
}
/// <summary>
/// 数据显示的函数
/// </summary>
public override void DisplayData()
{
InitDictItem();//数据字典加载（公用）
if (!string.IsNullOrEmpty(ID))
{
#region 显示客户信息
SystemTypeInfo info = BLLFactory <SystemType> .Instance.FindByID(ID);
if (info != null)
{
this.txtOid.Text = info.OID;
txtName.Text = info.Name;
txtCustomID.Text = info.CustomID;
txtAuthorize.Text = info.Authorize;
txtNote.Text = info.Note;
this.txtOid.Enabled = false;
}
#endregion
}
else
{
}
}
/// <summary>
/// 编辑或者保存状态下取值函数
/// </summary>
/// <param name="info"></param>
private void SetInfo(SystemTypeInfo info)
{
info.Name = txtName.Text;
info.CustomID = txtCustomID.Text;
info.Authorize = txtAuthorize.Text;
info.Note = txtNote.Text;
info.CurrentLoginUserId = Portal.gc.UserInfo.ID;
}
/// <summary>
/// 编辑或者保存状态下取值函数
/// </summary>
/// <param name="info"></param>
private void SetInfo(SystemTypeInfo info)
{
info.Name = txtName.Text;
info.ConsumerCode = txtCustomID.Text;
info.Licence = txtAuthorize.Text;
info.Remark = txtNote.Text;
info.CurrentLoginUserId = Portal.gc.UserInfo.Id;
}
public void PrepareCallNative(Parameter[] parameter)
{
string strPrefix = "";
if (parameter == null)
{
return;
}
// 1. Prepare local variables;
foreach (Parameter param in parameter)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csharpType = SystemTypeInfo.ToCSharpType(param.Type);
bool IsArray = param.IsArray | typeInfo.IsCSharpArray;
if (IsArray) // array
{
// Nothing for now
}
else if (IsStrType(param)) // string type
{
// Nothing for now
}
else if (IsVariableSizeType(param))
{
MatchIndent(); OutStream.WriteLine("var {0}{1}_ = {0}{1}.ToByteArray();", strPrefix, InParamName(param.Name));
}
}
//2. Prepare pinned variables or something with using statement
foreach (Parameter param in parameter)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csharpType = SystemTypeInfo.ToCSharpType(param.Type);
bool IsArray = param.IsArray | typeInfo.IsCSharpArray;
if (IsArray) // array
{
if (IsStrType(param)) // string type
{
MatchIndent(); OutStream.WriteLine("using (var {0}{1}Array = new ArrayObjectString({0}{1}))", strPrefix, InParamName(param.Name));
}
}
else if (IsStrType(param)) // string type
{
// Nothing for now
}
else if (IsVariableSizeType(param))
{
MatchIndent(); OutStream.WriteLine("using (var {0}{1}_PinnedPtr_ = new PinnedByteBuffer({0}{1}_))", strPrefix, InParamName(param.Name));
}
}
}
// Builder parameter string
public string ParamInString(string strPrefix, Parameter[] parameter)
{
string strParams = "", strComma = "";
if (parameter == null)
{
return(strParams);
}
foreach (Parameter param in parameter)
{
strParams += strComma;
if (strComma.Length == 0)
{
strComma = ", ";
}
var typeName = ToTargetTypeName(param);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csharpType = SystemTypeInfo.ToCSharpType(param.Type);
bool bIsStruct = typeInfo.IsCSharpStruct;
bool IsArray = param.IsArray;
if (typeInfo.IsCSharpArray)
{
IsArray = true;
if (ParameterMode == TypeUsage.CPPForSharp)
{
typeName = typeInfo.CPPTypeName + "*";
}
}
if (IsStrType(param)) // string type
{
strParams += string.Format("{0} {1}{2}", typeName, strPrefix, InParamName(param.Name));
}
else if (IsArray) // array
{
if (ParameterMode == TypeUsage.CSharpNative || ParameterMode == TypeUsage.CPPForSharp)
{
strParams += string.Format("{0} {1}_sizeOf{2},", ToTargetTypeName(m_ArraySizeParam), strPrefix, InParamName(param.Name));
}
strParams += string.Format("{0} {1}{2}", typeName, strPrefix, InParamName(param.Name));
}
else // generic type
{
strParams += string.Format("{0} {1}{2}", typeName, strPrefix, InParamName(param.Name));
}
}
return(strParams);
}
// Builder parameter string
public string ParamInString(string strPrefix, Parameter[] parameter)
{
string strParams = "", strComma = "";
if (parameter == null)
{
return(strParams);
}
foreach (Parameter param in parameter)
{
strParams += strComma;
if (strComma.Length == 0)
{
strComma = ", ";
}
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csType = SystemTypeInfo.ToCSharpType(param);
//bool bIsStruct = IsStruct(csType);
if (IsStrType(param)) // string type
{
strParams += string.Format("string {0}{1}", strPrefix, InParamName(param.Name));
}
else if (param.IsArray) // array
{
strParams += string.Format("{0}[] {1}{2}", typeInfo.CSharpTypeName, strPrefix, InParamName(param.Name));
}
else // generic type
{
if (typeInfo.IsCSharpStruct)
{
strParams += string.Format("ref {0} {1}{2}", typeInfo.CSharpTypeName, strPrefix, InParamName(param.Name));
}
else
{
strParams += string.Format("{0} {1}{2}", typeInfo.CSharpTypeName, strPrefix, InParamName(param.Name));
}
}
}
return(strParams);
}
// Builder parameter string
public string ParamMemberString(Parameter[] parameter)
{
string strParams = "", strComma = "";
if (parameter == null)
{
return(strParams);
}
foreach (Parameter param in parameter)
{
strParams += strComma;
if (strComma.Length == 0)
{
strComma = ", ";
}
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csType = SystemTypeInfo.ToCSharpType(param.Type);
if (IsStrType(param)) // string type
{
strParams += string.Format("{0}", param.Name);
}
else if (param.IsArray) // array
{
strParams += string.Format("{0}", param.Name);
}
else // generic type
{
if (typeInfo.IsCSharpStruct)
{
strParams += string.Format("ref {0}", param.Name);
}
else
{
strParams += string.Format("{0}", param.Name);
}
}
}
return(strParams);
}
/// <summary>
/// 获取菜单树Json字符串(Bootstrap的JSTree)
/// </summary>
/// <returns></returns>
public ActionResult GetMenuJsTreeJson()
{
//如果是超级管理员，不根据角色获取，否则根据角色获取对应的分配权限
//也就是说，公司管理员只能分配自己被授权的功能，而超级管理员不受限制
bool isSuperAdmin = BLLFactory <User> .Instance.UserInRole(CurrentUser.Name, RoleInfo.SuperAdminName);
List <JsTreeData> treeList = new List <JsTreeData>();
//List<SystemTypeInfo> typeList = BLLFactory<SystemType>.Instance.GetAll();
//foreach (SystemTypeInfo typeInfo in typeList)
{
//仅仅显示本系统的类型的话
SystemTypeInfo typeInfo = BLLFactory <SystemType> .Instance.FindByOID(ConfigData.SystemType);
JsTreeData pNode = new JsTreeData(typeInfo.OID, typeInfo.Name, "fa fa-home icon-state-warning icon-lg");
treeList.Add(pNode);
string systemType = typeInfo.OID;//系统标识ID
//一般情况下，对Ribbon样式而言，一级菜单表示RibbonPage；二级菜单表示PageGroup;三级菜单才是BarButtonItem最终的菜单项。
List <MenuNodeInfo> menuList = null;
if (isSuperAdmin)
{
menuList = BLLFactory <Menu> .Instance.GetTree(systemType);
}
else
{
menuList = BLLFactory <Menu> .Instance.GetMenuNodesByUser(CurrentUser.ID, typeInfo.OID);
}
foreach (MenuNodeInfo info in menuList)
{
JsTreeData item = new JsTreeData(info.ID, info.Name);
pNode.children.Add(item);
SetFileIcon(info, item);
AddJsTreeChildNode(info.Children, item);
}
}
return(ToJsonContent(treeList));
}
/// <summary>
/// 根据用户角色获取其对应的所能访问的权限集合
/// </summary>
/// <param name="userId">当前用户ID</param>
/// <returns></returns>
public ActionResult GetRoleFunctionJsTreeByUser(int userId)
{
List <JsTreeData> treeList = new List <JsTreeData>();
bool isSuperAdmin = false;
UserInfo userInfo = BLLFactory <User> .Instance.FindByID(userId);
if (userInfo != null)
{
isSuperAdmin = BLLFactory <User> .Instance.UserInRole(userInfo.Name, RoleInfo.SuperAdminName);
}
SystemTypeInfo typeInfo = BLLFactory <SystemType> .Instance.FindByOID(ConfigData.SystemType);
if (typeInfo != null)
{
JsTreeData parentNode = new JsTreeData(typeInfo.OID, typeInfo.Name);
//如果是超级管理员，不根据角色获取，否则根据角色获取对应的分配权限
//也就是说，公司管理员只能分配自己被授权的功能，而超级管理员不受限制
List <FunctionNodeInfo> allNode = new List <FunctionNodeInfo>();
if (isSuperAdmin)
{
allNode = BLLFactory <Function> .Instance.GetTree(typeInfo.OID);
}
else
{
allNode = BLLFactory <Function> .Instance.GetFunctionNodesByUser(userId, typeInfo.OID);
}
AddJsTreeeFunctionNode(parentNode, allNode);
treeList.Add(parentNode);
}
if (treeList.Count == 0)
{
treeList.Insert(0, new JsTreeData(-1, "无"));
}
return(ToJsonContent(treeList));
}
/// <summary>
/// 编辑状态下的数据保存
/// </summary>
/// <returns></returns>
public override bool SaveUpdated()
{
//检查不同ID是否还有其他相同关键字的记录
string condition = string.Format("Name ='{0}' and OID <> '{1}' ", this.txtName.Text, ID);
bool exist = BLLFactory <SystemType> .Instance.IsExistRecord(condition);
if (exist)
{
MessageDxUtil.ShowTips("指定的【系统名称】已经存在，不能重复添加，请修改");
return(false);
}
SystemTypeInfo info = BLLFactory <SystemType> .Instance.FindByID(ID);
if (info != null)
{
SetInfo(info);
try
{
#region 更新数据
bool succeed = BLLFactory <SystemType> .Instance.Update(info, info.OID);
if (succeed)
{
//可添加其他关联操作
return(true);
}
#endregion
}
catch (Exception ex)
{
LogHelper.WriteLog(LogLevel.LOG_LEVEL_CRIT, ex, typeof(FrmEditSystemType));
MessageDxUtil.ShowError(ex.Message);
}
}
return(false);
}
protected virtual IActionIn CreateInput(IActionFieldInfo item)
{
var att = item.GetAttribute <ActionTypeSelection>();
if (item.IsGenericArgument || att != null)
{
var typeSelection = new TypeSelection()
{
Name = item.Name
};
if (att != null)
{
var assignableTo = new SystemTypeInfo(att.AssignableTo);
typeSelection.Filter = info => info.IsAssignableTo(assignableTo);
}
return(typeSelection);
}
return(new ActionIn());
}
public string VerifyUser(string userName, string userPassword, string serialNumber, string typeID)
{
string text = "";
bool flag = false;
SystemType type = new SystemType();
SystemTypeInfo info = type.FindByOID(typeID);
if (info == null)
{
text = "系统[" + typeID + "]编号不存在，请与开发商联系！";
flag = true;
}
if (flag)
{
return(text);
}
User user2 = new User();
return(user2.VerifyUser(userName, userPassword, this.m_SessionID));
}
/// <summary>
/// 获取用户的可操作功能
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public ActionResult GetFunctionJsTreeJsonByUser(int userId)
{
List <JsTreeData> treeList = new List <JsTreeData>();
SystemTypeInfo typeInfo = BLLFactory <SystemType> .Instance.FindByOID(ConfigData.SystemType);
if (typeInfo != null)
{
JsTreeData parentNode = new JsTreeData(typeInfo.OID, typeInfo.Name, "fa fa-sitemap icon-state-warning icon-lg");
List <FunctionNodeInfo> list = BLLFactory <Function> .Instance.GetFunctionNodesByUser(userId, typeInfo.OID);
AddJsTreeeFunctionNode(parentNode, list);
treeList.Add(parentNode);
}
if (treeList.Count == 0)
{
treeList.Insert(0, new JsTreeData(-1, "无"));
}
return(ToJsonContent(treeList));
}
// Builder parameter string
public string ParamInListString(TypeUsage from, string strPrefix, Parameter[] parameter)
{
TypeUsage to = ParameterMode;
StringBuilder strParams = new StringBuilder(512);
string strComma = ",";
if (parameter == null)
{
return(strParams.ToString());
}
foreach (Parameter param in parameter)
{
strParams.Append(strComma);
string paramElementTypeName = SystemTypeInfo.ElementTypeNameFor(from, param);
string paramTypeNameOnly = SystemTypeInfo.TypeNameOnlyFor(from, param);
string paramTypeFrom = SystemTypeInfo.TypeNameFor(from, param);
string paramTypeTo = SystemTypeInfo.TypeNameFor(to, param);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type scharpType = SystemTypeInfo.ToCSharpType(param.Type);
bool paramTypeEquality = paramTypeFrom == paramTypeTo;
if (IsStrType(param)) // string type
{
strParams.AppendFormat("{0}{1}", strPrefix, InParamName(param.Name));
}
else if (param.IsArray) // array
{
if (from == TypeUsage.CPPForSharp)
{
strParams.AppendFormat("SF::ArrayView<const {2}>({0}_sizeOf{1}, {0}_sizeOf{1}, const_cast<{3}>({0}{1}))", strPrefix, InParamName(param.Name), paramElementTypeName, paramTypeNameOnly);
}
else
{
if (from == TypeUsage.CSharp)
{
strParams.AppendFormat("(ushort){0}{1}.Length, ", strPrefix, InParamName(param.Name));
}
if (from == TypeUsage.CSharp && typeInfo.IsEnum)
{
strParams.AppendFormat("GameTypes.ToIntArray({0}{1})", strPrefix, InParamName(param.Name));
}
else
{
strParams.AppendFormat("{0}{1}", strPrefix, InParamName(param.Name));
}
}
}
else // generic type
{
if (typeInfo.IsCSharpStruct)
{
if (ParameterMode == TypeUsage.CSharp || ParameterMode == TypeUsage.CSharpNative)
{
strParams.AppendFormat("ref {0}{1}", strPrefix, InParamName(param.Name));
}
else
{
strParams.AppendFormat("{0}{1}", strPrefix, InParamName(param.Name));
}
}
else
{
if (paramTypeEquality)
{
strParams.AppendFormat(" {0}{1}", strPrefix, InParamName(param.Name));
}
else
{
strParams.AppendFormat("({2}) {0}{1}", strPrefix, InParamName(param.Name), paramTypeTo);
}
}
}
}
return(strParams.ToString());
}
// target type for output
public override string ToTargetTypeName(Parameter param)
{
return(SystemTypeInfo.TypeNameFor(ParameterMode, param));
}
// Build parser class implementation
void BuildMessageClassParserImpl(string Name, string typeName, Parameter[] parameters)
{
OpenSection("public override void", "ParseMsg(BinaryMemoryReader binaryReader)", false);
MatchIndent(); OutStream.WriteLine("var binReader = (PacketMemoryReader)binaryReader;");
if (parameters == null)
{
// nothing to process
MatchIndent(); OutStream.WriteLine("return;");
}
else
{
foreach (Parameter param in parameters)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//Type csType = SystemTypeInfo.ToCSharpType(param.Type);
switch (param.TypeName)
{
case "String":
MatchIndent(); OutStream.WriteLine(
string.Format("{0} = binReader.ReadString();", param.Name));
break;
default:
if (param.IsArray)
{
MatchIndent(); OutStream.WriteLine(
string.Format("UInt16 {0} = 0;", ArrayLenName(param.Name)));
MatchIndent(); OutStream.WriteLine(
string.Format("{0} = binReader.ReadUInt16();", ArrayLenName(param.Name)));
MatchIndent(); OutStream.WriteLine(
string.Format("{1} = new {0}[{2}];", typeInfo.CSharpTypeName, param.Name, ArrayLenName(param.Name)));
//if (csType == typeof(byte))
if (typeInfo.CSharpTypeName == typeof(byte).ToString())
{
MatchIndent(); OutStream.WriteLine("binReader.ReadBytes({0});", param.Name);
}
else
{
MatchIndent(); OutStream.WriteLine(
string.Format("for( int iElement = 0; iElement < {0}; iElement++) {{", ArrayLenName(param.Name)));
MatchIndent(); OutStream.WriteLine(
string.Format("{1}[iElement] = binReader.Read{0}();", CSharpTypeString(typeInfo.CSharpTypeName), param.Name, ArrayLenName(param.Name)));
MatchIndent(); OutStream.WriteLine("}");
}
}
else
{
MatchIndent(); OutStream.WriteLine(
string.Format("{1} = binReader.Read{0}();", CSharpTypeString(typeInfo.CSharpTypeName), param.Name, ArrayLenName(param.Name)));
}
break;
}
NewLine();
}
}
CloseSection();
}
// build message class
void BuildMessageClass(MessageBase baseMsg, string typeName, Parameter[] parameters)
{
string Name = baseMsg.Name;
string strClassName = MsgClassName(Name, typeName);
MatchIndent(); OutStream.WriteLine("[Preserve (AllMembers = true)]");
OpenSection("public class", strClassName + " : MessageBase", false);
NewLine();
MatchIndent(); OutStream.WriteLine("public static MessageID MID = new MessageID(MSGTYPE.{0}, {1}, {2}, POLICY.{3}, {4});",
typeName.ToUpper(), baseMsg.Reliable.ToString().ToLower(), Group.IsMobile.ToString().ToLower(), Group.Name.ToUpper(), MessageCodeIndex);
NewLine();
// member section
if (parameters != null)
{
foreach (Parameter param in parameters)
{
switch (param.TypeName)
{
case "String":
MatchIndent(); OutStream.WriteLine(string.Format("public string {0} {{ get; private set; }}", param.Name));
break;
default:
//Type csType = SystemTypeInfo.ToCSharpType(param.Type);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (param.IsArray)
{
MatchIndent(); OutStream.WriteLine(
string.Format("public {0}[] {1};", typeInfo.CSharpTypeName, param.Name));
}
else
{
MatchIndent(); OutStream.WriteLine(
string.Format("public {0} {1};", typeInfo.CSharpTypeName, param.Name));
}
break;
}
}
}
// Constructor
MatchIndent(); OutStream.WriteLine("public " + strClassName + "()");
MatchIndent(1); OutStream.WriteLine("{}");
NewLine();
MatchIndent(); OutStream.WriteLine("public " + strClassName + "( ref MessageHeader msgHeader )");
MatchIndent(1); OutStream.WriteLine(":base(ref msgHeader)");
MatchIndent(1); OutStream.WriteLine("{}");
NewLine();
NewLine();
// message trace function
BuildMessageTrace(Name, typeName, baseMsg.Trace.ToString(), parameters);
NewLine();
// Parse function
BuildMessageClassParserImpl(baseMsg.Name, typeName, parameters); NewLine();
NewLine();
// Build function
BuildBuilderSelfImpl(parameters);
NewLine();
BuildBuilderImpl(parameters);
NewLine();
CloseSection();
}
// Builder parameter string
public string CallCreateNativeParameterString(TypeUsage from, string strPrefix, Parameter[] parameter)
{
TypeUsage to = ParameterMode;
StringBuilder strParams = new StringBuilder(512);
string strComma = ",";
if (parameter == null)
{
return(strParams.ToString());
}
foreach (Parameter param in parameter)
{
strParams.Append(strComma);
string paramElementTypeName = SystemTypeInfo.ElementTypeNameFor(from, param);
string paramTypeNameOnly = SystemTypeInfo.TypeNameOnlyFor(from, param);
string paramTypeFrom = SystemTypeInfo.TypeNameFor(from, param);
string paramTypeTo = SystemTypeInfo.TypeNameFor(to, param);
bool paramTypeEquality = paramTypeFrom == paramTypeTo;
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
bool bIsStruct = typeInfo.IsCSharpStruct;
if (param.IsArray) // array
{
if (IsStrType(param)) // string type
{
strParams.AppendFormat("{0}{1}Array_", strPrefix, InParamName(param.Name));
}
else
{
strParams.AppendFormat("SF::ArrayView<{2}>({0}_sizeOf{1}, {0}_sizeOf{1}, const_cast<{3}>({0}{1}))", strPrefix, InParamName(param.Name), paramElementTypeName, paramTypeNameOnly);
}
}
else if (IsStrType(param)) // string type
{
strParams.AppendFormat("{0}{1}", strPrefix, InParamName(param.Name));
}
else if (IsVariableSizeType(param))
{
strParams.AppendFormat("SF::ArrayView<uint8_t>({0}_sizeOf{1}, {0}_sizeOf{1}, {0}{1})", strPrefix, InParamName(param.Name), paramElementTypeName, paramTypeNameOnly);
}
else // generic type
{
if (bIsStruct)
{
strParams.AppendFormat("{0}{1}", strPrefix, InParamName(param.Name));
}
else
{
if (paramTypeEquality)
{
strParams.AppendFormat(" {0}{1}", strPrefix, InParamName(param.Name));
}
else
{
strParams.AppendFormat("({2}) {0}{1}", strPrefix, InParamName(param.Name), paramTypeTo);
}
}
}
}
return(strParams.ToString());
}
public virtual bool IsVariableSizeType(Parameter param)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
return(typeInfo.IsVariableSize);
}
// Build parser class implementation
void BuildParserToVariableBuilderImpl(string Name, string typeName, Parameter[] parameters)
{
if (!AppConfig.GetValue("VariableMapParser", false))
{
return;
}
string strClassName = MsgClassName(Name, typeName);
OpenSection("Result", strClassName + "::ParseMessageTo(const MessageDataPtr& pIMsg, IVariableMapBuilder& variableBuilder )");
DefaultHRESULT(); NewLine();
bool bHasParameter = parameters != null && parameters.Length > 0;
NewLine();
MatchIndent(); OutStream.WriteLine("{0} parser;", strClassName);
MatchIndent(); OutStream.WriteLine("protocolCheck(parser.ParseMessage(*pIMsg));");
NewLine();
if (parameters != null)
{
foreach (Parameter param in parameters)
{
//var csharpType = SystemTypeInfo.ToCSharpType(param);
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (typeInfo.UseGenericVariableBuilderInterface)
{
if (param.IsArray)
{
MatchIndent(); OutStream.WriteLine("variableBuilder.SetVariableArray(\"{0}\", \"{1}\", parser.Get{0}());", param.Name, param.TypeName);
}
else
{
MatchIndent(); OutStream.WriteLine("variableBuilder.SetVariable(\"{0}\", \"{1}\", parser.Get{0}());", param.Name, param.TypeName);
}
}
else if (param.IsArray || typeInfo.IsString)
{
MatchIndent(); OutStream.WriteLine("variableBuilder.SetVariable(\"{0}\", parser.Get{0}());", param.Name);
}
else if (typeInfo.IsEnum)
{
MatchIndent(); OutStream.WriteLine("variableBuilder.SetVariable(\"{0}\", (int)parser.Get{0}());", param.Name);
}
else if (!typeInfo.IsCSharpStruct && typeInfo.IsVariableSize)
{
MatchIndent(); OutStream.WriteLine("variableBuilder.SetVariableArray(\"{0}\", \"{1}\", parser.Get{0}Raw());", param.Name, param.TypeName);
}
else
{
MatchIndent();
var isStruct = SystemTypeInfo.IsStruct(param);
if (isStruct)
{
OutStream.WriteLine("variableBuilder.SetVariable(\"{0}\", \"{1}\", parser.Get{0}());", param.Name, param.TypeName);
}
else
{
OutStream.WriteLine("variableBuilder.SetVariable(\"{0}\", parser.Get{0}());", param.Name);
}
}
}
}
NewLine();
ReturnHR(); NewLine();
CloseSection();
}
// build parser class
void BuildParserClass(ProtocolXml.MessageBase msg, MsgType msgType, string typeName, Parameter[] parameters)
{
string Name = msg.Name;
string strClassName = MsgClassName(Name, typeName);
OpenSection("class", strClassName + " : public MessageBase");
MatchIndent(-1); OutStream.WriteLine("public:");
MatchIndent(); OutStream.WriteLine("static const MessageID MID;");
// Generate parameter Indicators for Template implementations
MatchIndent(); OutStream.WriteLine("// Parameter type informations for template");
var parameterNameMap = new Dictionary <string, Parameter>();
if (parameters != null)
{
foreach (Parameter param in parameters)
{
parameterNameMap.Add(param.Name, param);
}
}
OpenSection("enum", "ParameterTypeInfo");
foreach (var parameterName in GenerateParameterTypeInfoList)
{
MatchIndent(); OutStream.WriteLine("Has{0} = {1},", parameterName.Name, parameterNameMap.ContainsKey(parameterName.Name) ? 1 : 0);
}
CloseSection();
// Add fake access functions
MatchIndent(-1); OutStream.WriteLine("public:");
foreach (var parameter in GenerateParameterTypeInfoList)
{
if (parameterNameMap.ContainsKey(parameter.Name))
{
continue;
}
MatchIndent(); OutStream.WriteLine("{1} Get{0}() {{ return {1}{{}}; }}", parameter.Name, ToTargetTypeName(parameter));
}
bool bHasInternalTypeOverride = HasInternalTypeOverride(parameters);
// Generate parameter variables
MatchIndent(-1); OutStream.WriteLine("private:");
// member section
if (parameters != null)
{
foreach (Parameter param in parameters)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (param.IsArray)
{
MatchIndent();
if (typeInfo.IsVariableSize)
{
OutStream.WriteLine("DynamicArray<{0}> m_{1};", ToTargetTypeName(param), param.Name);
}
else
{
OutStream.WriteLine("ArrayView<{0}> m_{1};", ToTargetTypeName(param), param.Name);
}
}
else if (!typeInfo.IsString && !typeInfo.IsCSharpStruct && typeInfo.IsVariableSize)
{
MatchIndent(); OutStream.WriteLine("ArrayView<uint8_t> m_{1}Raw;", ToTargetTypeName(param), param.Name);
MatchIndent(); OutStream.WriteLine("mutable bool m_{1}HasParsed = false;", ToTargetTypeName(param), param.Name);
MatchIndent(); OutStream.WriteLine("mutable {0} m_{1};", ToTargetTypeName(param), param.Name);
}
else
{
MatchIndent(); OutStream.WriteLine("{0} m_{1}{{}};", ToTargetTypeName(param), param.Name);
}
}
}
MatchIndent(-1); OutStream.WriteLine("public:");
// Constructors
MatchIndent(); OutStream.WriteLine(strClassName + "()");
MatchIndent(1); OutStream.WriteLine("{}");
NewLine();
MatchIndent(); OutStream.WriteLine(strClassName + "( const MessageDataPtr &pMsg )");
MatchIndent(1); OutStream.WriteLine(": MessageBase(pMsg)");
MatchIndent(1); OutStream.WriteLine("{}");
NewLine();
// Usage
MatchIndent(1); OutStream.WriteLine("MessageUsage GetMessageUsage() {{ return MessageUsage_{0}; }}", msg.Usage.ToString());
NewLine();
// Generate Get functions
if (parameters != null)
{
foreach (Parameter param in parameters)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
if (param.IsArray)
{
MatchIndent(); OutStream.WriteLine("const Array<{0}>& Get{1}() const\t{{ return m_{1}; }};", ToTargetTypeName(param), param.Name);
}
else if (IsStrType(param))
{
MatchIndent(); OutStream.WriteLine("{0} Get{1}() const\t{{ return m_{1}; }};", ToTargetTypeName(param), param.Name);
}
else if (!typeInfo.IsCSharpStruct && typeInfo.IsVariableSize)
{
MatchIndent(); OutStream.WriteLine("const Array<uint8_t>& Get{1}Raw() const\t{{ return m_{1}Raw; }};", ToTargetTypeName(param), param.Name);
//MatchIndent(); OutStream.WriteLine("const {0}& Get{1}() const\t{{ return m_{1}; }};", ToTargetTypeName(param.Type), param.Name);
MatchIndent(); OutStream.WriteLine("const {0}& Get{1}() const;", ToTargetTypeName(param), param.Name);
}
else
{
MatchIndent(); OutStream.WriteLine("const {0}& Get{1}() const\t{{ return m_{1}; }};", ToTargetTypeName(param), param.Name);
}
}
}
NewLine();
// message trace function
MatchIndent(); OutStream.WriteLine("static Result TraceOut(const char* prefix, const MessageDataPtr& pMsg);");
NewLine();
// Parse function
MatchIndent(); OutStream.WriteLine("virtual Result ParseMessage(const MessageData* pIMsg);");
if (AppConfig.GetValue("VariableMapParser", false))
{
MatchIndent(); OutStream.WriteLine("static Result ParseMessageTo(const MessageDataPtr& pIMsg, IVariableMapBuilder& variableBuilder );");
}
MatchIndent(); OutStream.WriteLine("static Result ParseMessageToMessageBase(IHeap& memHeap, const MessageDataPtr& pIMsg, MessageBase* &pMsgBase);");
NewLine();
// Build function
MatchIndent(); OutStream.WriteLine("static MessageData* Create( {0} );", BuilderParamString(parameters));
if (bHasInternalTypeOverride)
{
MatchIndent(); OutStream.WriteLine("static MessageData* Create( {0} );", BuilderParamString(parameters, bUseOriginalType: true));
}
NewLine();
// Override route context function
//if (Group.GenParameterRouteContext)
//{
// MatchIndent(); OutStream.WriteLine("Result OverrideRouteContextDestination( EntityUID to );");
// NewLine();
//}
// Override route hop function
//if (Group.GenParameterRouteHopCount)
//{
// MatchIndent(); OutStream.WriteLine("Result OverrideRouteInformation( EntityUID to, unsigned hopCount );");
// NewLine();
//}
CloseSection();
}
void BuildMessageTrace(string Name, string typeName, string traceChannel, Parameter[] parameters)
{
string strClassName = MsgClassName(Name, typeName);
OpenSection("Result", strClassName + "::TraceOut(const char* prefix, const MessageDataPtr& pMsg)");
string strTrace = string.Format("{0}, \"{1}:{{0}}:{{1}} ", traceChannel, Name, typeName);
string strTraceMember = "prefix, pMsg->GetMessageHeader()->Length";
int ParamCount = 2;
MatchIndent(); OutStream.WriteLine("{0} parser;", strClassName);
MatchIndent(); OutStream.WriteLine("parser.ParseMessage(*pMsg);");
if (parameters != null)
{
foreach (Parameter param in parameters)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
//var csharpType = SystemTypeInfo.ToCSharpType(param.Type);
switch (param.TypeName)
{
case "String":
{
strTrace += string.Format(", {0}:{{{1},60}}", param.Name, ParamCount++);
strTraceMember += string.Format(", parser.Get{0}()", param.Name);
} break;
default:
if (param.IsArray)
{
strTrace += string.Format(", {0}:{{{1},30}}", param.Name, ParamCount++);
strTraceMember += string.Format(", parser.Get{0}()", param.Name);
}
else if (param.TypeName == "Result")
{
strTrace += string.Format(", {0}:{{{1}:X8}}", param.Name, ParamCount++);
strTraceMember += string.Format(", parser.Get{0}()", param.Name);
}
else if (typeInfo.IsEnum)
{
strTrace += string.Format(", {0}:{{{1}}}", param.Name, ParamCount++);
strTraceMember += string.Format(", (int)parser.Get{0}()", param.Name);
}
else
{
strTrace += string.Format(", {0}:{{{1}}}", param.Name, ParamCount++);
strTraceMember += string.Format(", parser.Get{0}()", param.Name);
}
break;
}
}
}
MatchIndent(); OutStream.WriteLine("{0} {1},", LogFunctionPrefix, strTrace + "\"");
MatchIndent(1); OutStream.WriteLine("\t{0}); ", strTraceMember);
MatchIndent(); OutStream.WriteLine("return ResultCode::SUCCESS;");
CloseSection();
NewLine();
}
public bool IsStruct(Parameter param)
{
var typeInfo = SystemTypeInfo.GetParameterInfo(param);
return(typeInfo.IsCSharpStruct);
}