private void writeToOperator(string v, messageType type)
{
switch (type)
{
case (messageType.NORMAL):
operatorMessageBox.BackColor = Color.LightSkyBlue;
break;
case (messageType.URGENT):
operatorMessageBox.BackColor = Color.Tomato;
break;
case (messageType.PASSED):
operatorMessageBox.BackColor = Color.LightGreen;
break;
case (messageType.FAILED):
operatorMessageBox.BackColor = Color.IndianRed;
break;
case (messageType.INCOMPLETE):
operatorMessageBox.BackColor = Color.YellowGreen;
break;
default:
operatorMessageBox.BackColor = Color.LightSkyBlue;
break;
}
operatorMessageBox.Text = v;
logger.Info(v);
}
private void updateOperatorDisplayAfterTest()
{
string result = fiber.results.lastTestResult;
string displayText = "did not complete testing";
messageType msgtype = messageType.INCOMPLETE;
if (result == "P")
{
displayText = "Passed";
msgtype = messageType.PASSED;
}
else if (result == "F")
{
displayText = "Failed";
msgtype = messageType.FAILED;
}
string logMsg = string.Format("Test Result for {3}: Offset(PTS Value):{0}um Radius:{1}m Pass/Fail: {2}", fiber.results.curlResults.ISEvalue.ToString("000.0"), fiber.results.curlResults.ISEradius, fiber.results.curlResults.ISEresult, fiber.fiberId);
string operMsg = string.Format("Fiber {0}{1}", fiber.fiberId, displayText);
writeToOperator(operMsg, msgtype);
if (fiber.results.lastTestResult != "I")
{
writeToLog(logMsg);
writeToResultsBox(logMsg);
}
else
{
writeToLog(operMsg);
writeToResultsBox(operMsg);
}
}
private void GenerateIndexesAccessors(messageType message)
{
foreach (var index in message.index.OrderBy(_ => _.id))
{
GenerateClassIndex(message, index);
}
}
/// <summary>
/// This sends and message to the analytics dashboard.
/// </summary>
/// <param name="encoding"></param>
/// <returns></returns>
public bool SendEvent(messageType encoding, string[] argument)
{
AnalyticsResult result = AnalyticsResult.InvalidData;
switch (encoding)
{
case messageType.gameover:
result = Analytics.CustomEvent("Level Completed", new Dictionary <string, object>
{
{ "build_id", DirectorManager.DirectorInstance.GetBuildType },
{ "email", argument },
{ "monster_ratio", measurements.lethality },
{ "power_ups_ratio", measurements.itemsPicked },
{ "treasure_ratio", measurements.score },
{ "time", measurements.roomTime.Values.Average() },
{ "interactable_ratio", measurements.trapped + measurements.items },
{ "win_ration", DirectorManager.DirectorInstance.time / 300f }
});
break;
default:
result = AnalyticsResult.Ok;
break;
}
return(result == AnalyticsResult.Ok);
}
// метод отправки сообщений
private static void SendMessage(string msg, messageType type, string receiver)
{
// UdpClient для отправки
UdpClient udp = new UdpClient();
// конечная точка
IPEndPoint endPoint = new IPEndPoint(serverAddress, remotePort);
try
{
// формирование сообщения определенной структуры: сообщение~тип~получатель
string message = msg;
message += "~" + type.ToString();
message += "~" + receiver;
// переводим его в массив байтов
byte[] data = Encoding.Unicode.GetBytes(message);
// отправка массива байтов
int sended = udp.Send(data, data.Length, endPoint);
}
catch (Exception ex)
{
Console.WriteLine("UDP >> " + ex.Message);
}
finally
{
udp.Close();
}
}
protected override void GenerateFlush(messageType message)
{
IncludeWriter.WriteLine(@" void flush();");
CppWriter.WriteLine(
@"
void Abstract{0}::flush()
{{", message.name.Capitalize());
var allFields = message.field.OrderBy(_ => _.id);
var messageFields = from fld in allFields
where fld.messageType != null &&
fld.type == typeType.nestedMessage
select fld;
var has = false;
foreach (var field in messageFields)
{
has = true;
CppWriter.WriteLine(
field.modifier == modifierType.repeated
? @" m_{0}List.clear();"
: @" m_{0}.reset();", field.name);
}
if (!has)
{
CppWriter.WriteLine(@" // NOP");
}
CppWriter.WriteLine(@" }");
CppWriter.WriteLine();
}
protected override void EndAbstractClass(messageType message)
{
Writer.WriteLine(
@" }
}
");
}
protected override void InitializeAbstractClass(messageType message)
{
IncludeWriter.WriteLine(
@" class Abstract{0} : public ProtoOrBuilder
{{"
, message.name);
}
protected override void GenerateFlush(messageType message)
{
Writer.WriteLine(
@" public void Flush()
{"
);
var allFields = message.field.OrderBy(_ => _.id);
var messageFields = from fld in allFields
where fld.messageType != null &&
fld.type == typeType.nestedMessage
select fld;
foreach (var field in messageFields)
{
if (field.modifier == modifierType.repeated)
{
Writer.WriteLine(
@" _{0} = !IsBuilt ? (IStretchable<{1}>)new Stretchable<{1}>() : (IStretchable<{1}>)new WeakStretchable<{1}>();"
, field.name, field.messageType);
}
else
{
Writer.WriteLine(
@" _{0} = null;"
, field.name);
}
}
Writer.WriteLine(
@" }
"
);
}
/// <summary>
/// This sends and message to the analytics dashboard.
/// </summary>
/// <param name="encoding"></param>
/// <returns></returns>
public bool SendEvent(messageType encoding)
{
AnalyticsResult result = AnalyticsResult.InvalidData;
switch (encoding)
{
case messageType.gameover:
result = Analytics.CustomEvent("PlayerStatisticss", new Dictionary <string, object>
{
{ "build_id", DirectorManager.DirectorInstance.GetBuildType },
{ "unique_id", DirectorManager.DirectorInstance.UniqueIdentifier },
{ "win_ration", DirectorManager.DirectorInstance.time / DirectorManager.DirectorInstance.MaxTime },
{ "accurarcy", measurements.accuracy },
{ "score", measurements.score },
{ "money_gained", measurements.money },
{ "items_picked", measurements.items },
{ "items_ratio", measurements.itemsPicked },
{ "monsters_killed", measurements.monsterKilled },
{ "number_rooms", measurements.rooms },
{ "avg_time", measurements.roomTime.Values.Average() },
{ "dmg taken", measurements.monsterDmg },
{ "in_trapped", measurements.trapped },
{ "steps_taken", measurements.steps },
{ "lethality", measurements.lethality }
});
break;
default:
result = AnalyticsResult.Ok;
break;
}
return(result == AnalyticsResult.Ok);
}
public void ParseBSON(Kernys.Bson.BSONObject bsonObj)
{
try {
if (bsonObj["ipad"]["type"].stringValue == "up") {
if (lastMessage == messageType.down) {
//its a tap!
if (lastFingers == 1) {
messageQueue.Enqueue(new iPadTapInput());
} else {
//double tap here
}
}
lastMessage = messageType.up;
this.lastFingers = 0;
} else if (bsonObj["ipad"]["type"].stringValue == "down") {
this.lastFingers = bsonObj["ipad"]["n"].int32Value;
lastMessage = messageType.down;
} else {
this.lastMessage = messageType.move;
}
} catch (KeyNotFoundException) {
//unhandled keynotfoundexception. e.g. recieving letter inputs.
}
//TODO: Parse other types of messages, e.g. swipe, fingerdown, finger up...
}
public void ParseBSON(Kernys.Bson.BSONObject bsonObj)
{
try {
if (bsonObj["ipad"]["type"].stringValue == "up")
{
if (lastMessage == messageType.down)
{
//its a tap!
if (lastFingers == 1)
{
messageQueue.Enqueue(new iPadTapInput());
}
else
{
//double tap here
}
}
lastMessage = messageType.up;
this.lastFingers = 0;
}
else if (bsonObj["ipad"]["type"].stringValue == "down")
{
this.lastFingers = bsonObj["ipad"]["n"].int32Value;
lastMessage = messageType.down;
}
else
{
this.lastMessage = messageType.move;
}
} catch (KeyNotFoundException) {
//unhandled keynotfoundexception. e.g. recieving letter inputs.
}
//TODO: Parse other types of messages, e.g. swipe, fingerdown, finger up...
}
protected override void GenerateClassConstructor(messageType message)
{
Writer.WriteLine(
@"
/**
* {1}
**/
protected Abstract{0}()
{{
_header = {0}Header.newBuilder();
_positionInContent = -1;
flush();
}}
/**
* {1}
**/
protected Abstract{0}({0}Header header, int positionInContent)
{{
_header = header;
_positionInContent = positionInContent;
flush();
}}
", message.name, message.description.Safe());
}
public static void setMessage(Controller controller, string message, messageType message_type = messageType.success)
{
Alert alert = new Alert();
alert.message = message;
alert.message_type = message_type;
controller.TempData["message"] = JsonConvert.SerializeObject(alert);
}
protected override void EndAbstractClass(messageType message)
{
Writer.WriteLine(
@"}"
);
Writer.Dispose();
Writer = null;
}
public void messageReceived(string message, messageType msgType)
{
if (msgType.Equals(messageType.REGISTERED))
updateLabelStatus(statusLabel, "注册成功");
else if (msgType.Equals(messageType.KEEPALIVE))
PublishMessage(keepaliveTextbox, message);
else
PublishMessage(ReceiveTextBox, message);
}
protected override void GenerateToString(messageType message)
{
Writer.WriteLine(
@" public override string ToString()
{
return ToString(new BaseFormat() { Indentation = 0, NewLine = System.Environment.NewLine });
}
public virtual string ToString(IFormat format)
{
var bd = new StringBuilder();");
Writer.WriteLine(
@" format.FormatHeader(bd,""{0}"");
", message.name);
var fields = message.field.OrderBy(_ => _.id);
foreach (var field in fields)
{
switch (field.modifier)
{
case modifierType.repeated:
if (field.type == typeType.referenceMessage)
{
Writer.WriteLine(
@" format.FormatField(bd, ""{0}List"", this, _ => _.{0}List.Select(item => ""{0}"" + item.Index));
", field.name.Capitalize());
}
else
{
Writer.WriteLine(
@" format.FormatField(bd, ""{0}List"", this, _ => _.{0}List);
", field.name.Capitalize());
}
break;
case modifierType.optional:
Writer.WriteLine(
@" format.FormatField(bd, ""{0}"", this, _ => _.{0}, Has{0});
", field.name.Capitalize());
break;
default:
Writer.WriteLine(
@" format.FormatField(bd, ""{0}"", this, _ => _.{0});", field.name.Capitalize());
break;
}
}
Writer.WriteLine(
@" format.FormatFooter(bd);
return bd.ToString();
}
");
}
protected override void GenerateSerialization(messageType message)
{
if (message.IsRoot)
{
Writer.WriteLine(
@" public static {0} ParseFrom(Stream strm)
{{
// the root is always at the end of the stream
var size = sizeof(uint);
var offset = -size;
lock(strm)
{{
strm.Seek(offset, SeekOrigin.End);
uint msgSize = 0;
var success = CodedInputStream.CreateInstance(strm).ReadFixed32(ref msgSize);
Debug.Assert(success, ""Unable to read message size"");
offset -= (int) msgSize + CodedOutputStream.ComputeInt32SizeNoTag((int)msgSize);
var pos = strm.Seek(offset, SeekOrigin.End);
var header = {0}Header.ParseDelimitedFrom(strm);
Debug.Assert(header != null, ""Can't decode header!"");
var parsed = new {0}(header, pos);
parsed.ContentStream = strm;
return parsed;
}}
}}
public static {0} ParseFrom(byte[] bytes)
{{
return ParseFrom(new MemoryStream(bytes));
}}
", message.name);
return;
}
Writer.WriteLine(
@" internal static {0} ParseFrom(Stream strm, uint pos)
{{
lock(strm)
{{
strm.Seek(pos, SeekOrigin.Begin);
var header = {0}Header.ParseDelimitedFrom(strm);
Debug.Assert(header != null, ""Can't decode header!"");
var parsed = new {0}(header, pos);
return parsed;
}}
}}
", message.name);
}
internal override void GenerateFinalClientClass(messageType message)
{
Writer.WriteLine(
@" public partial class {0} : Abstract{0}
{{
public {0}() {{ /* NOP */ }}
public {0}({0}Header header, long posInContent) : base(header, posInContent) {{ /* NOP */ }}
}}
"
, message.name);
}
protected override void InitializeAbstractClass(messageType message)
{
Writer.WriteLine(
@"namespace generated
{{
/// <summary>
/// {1}
/// </summary>
public abstract partial class Abstract{0} : ProtoOrBuilder
{{"
, message.name, message.description.Safe());
}
public string getMessage(messageType whatFor, string username, itemType itemDefined, int typeID, bool isDetail, string option1, string option2)
{
//indexing | normal numbers resolve
// itemDefined += 1; typeID += 1; whatFor += 1;
string objectName = "";
string returnThis = "";
string userDefined = (from use in user.UserProfiles
where use.UserName == username
select use.UserName).First();
switch (itemDefined)
{
case itemType.person:
objectName = (from userd in user.UserProfiles
where userd.UserId == typeID
select userd.UserName).First();
break;
case itemType.headline:
objectName = (from hline in user.headlines
where hline.headlineDefinedId == typeID
select hline.title).First();
break;
}
if (objectName == "")
{
return "";
}
if (isDetail)
{
switch (whatFor)
{
case messageType.permissionRequest:
returnThis = "Hi, " + WebSecurity.CurrentUserName + " !<br/>" +
"You can edit this in <a href='/Headlines/editFollowing/" + objectName + "'>Edit Following</a> <br/>" +
"Including if you wish for them to be denied access.<br>" +
"Of course, if you wish, you can find them in chat or through vieiwng them <a href ='/Member/ViewMember" + userDefined + "'> here </a>" +
"and connect to them to ask what they wish to contribute first<br/>" +
"Depending on your settings, you may also be able to set them as a drafter so none of their edits are committed.";
break;
}
}
else
{
switch (whatFor)
{
case messageType.permissionRequest:
returnThis = userDefined + " has requested acess to " + objectName + " with access level: " + option1;
break;
}
}
return returnThis;
}
public serverMessage(messageType messageType, List <Tuple <string, string, DateTime, string> > ListOfForumModerators)
{
policy = null;
stringContent = null;
intContent = null;
time = DateTime.Now;
policy = null;
Threads = null;
getThread = null;
ListOfMemberMessages = null;
this._messageType = messageType;
this.ListOfForumModerators = ListOfForumModerators;
}
public serverMessage(messageType messageType, List <Tuple <string, DateTime, int> > returnForMemMesages3)
{
policy = null;
stringContent = null;
intContent = null;
time = DateTime.Now;
policy = null;
getThread = null;
ListOfForumModerators = null;
ListOfMemberMessages = null;
this._messageType = messageType;
this.Threads = returnForMemMesages3;
}
public serverMessage(messageType p1, List <string> p2, List <int> p3, DateTime p4)
{
// TODO: Complete member initialization
_messageType = p1;
stringContent = p2;
intContent = p3;
time = p4;
policy = null;
ListOfMemberMessages = null;
ListOfForumModerators = null;
Threads = null;
getThread = null;
}
public static void LogWriteLineinHTML(string msg, MessageSource source, string exception, messageType msgType)
{
lock (Obj)
{
if (!Directory.Exists(folderPath))
Directory.CreateDirectory(folderPath);
string header = "<html><title>CommitCRM integration with Repairshopr </title><head><head><body><div align='center'><h1> CommitCRM integration with Repairshopr </h1></div><table border=\"1\" style=\"width:100%\"><tr><th>Date Time</th><th>Source</th><th>Log Level </th><th>Message</th><th>Exception </th><tr>";
string message = null;//string.Format("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3} </td><td>{4}</td></tr>", DateTime.Now, source, msgType, msg, exception);
if (msgType == messageType.Error)
{
message = string.Format("<tr><td><font color='red'><b>{0}</b></font></td><td><font color='red'><b>{1}</b></font></td><td><font color='red'><b>{2}</b></font></td><td><font color='red'><b>{3}</b></font> </td><td><font color='red'><b>{4}</b></font></td></tr>", DateTime.Now, source, msgType, msg, exception);
}
else if(source==MessageSource.Complete)
{
message = string.Format("<tr><td><font color='Green'><b>{0}</b></font></td><td><font color='Green'><b>{1}</b></font></td><td><font color='Green'><b>{2}</b></font></td><td><font color='Green'><b>{3}</b></font> </td><td><font color='Green'><b>{4}</b></font></td></tr>", DateTime.Now, source, msgType, msg, exception);
}
else
{
message = string.Format("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3} </td><td>{4}</td></tr>", DateTime.Now, source, msgType, msg, exception);
}
if (File.Exists(path))
{
FileInfo fl = new FileInfo(path);
long size = fl.Length;
if (ConvertBytesToMegabytes(size) > 3)
{
path = folderPath + "\\" + string.Format("RepairshoprLog_{0}_{1}.Html", DateTime.Today.Date.ToString("dd/MM/yyyy").Replace("/", "_"), sufix);//Path.Combine(folderPath, "KarmaCRMLog.Html");
sufix++;
}
}
if (!File.Exists(path))
{
using (StreamWriter sw = File.CreateText(path))
{
//Creating file with new Content.
sw.WriteLine(string.Format("{0}", header));
sw.WriteLine(string.Format("{0}", message));
}
}
else
{
using (StreamWriter sw = File.AppendText(path))
{
sw.WriteLine(string.Format("{0}", message));
}
}
}
}
private void showMessage(messageType type, string text)
{
string typePrefix = String.Empty;
switch (type)
{
case messageType.Info: typePrefix = "Information:\r\n"; break;
case messageType.Warning: typePrefix = "Warning:\r\n"; break;
case messageType.Error: typePrefix = "Error:\r\n"; break;
}
this.Page.ClientScript.RegisterStartupScript(typeof(string), "postBackAlert", String.Format("window.alert('{0}');", Utility.QuoteJScriptString(typePrefix + text, false)), true);
}
public static void QueueMessage(messageType type, string message)
{
lock (Current._messages)
{
try
{
Current._messages.Add(new Message(type, message));
}
catch (Exception ex)
{
SafeDebug.LogError("\nMessage: " + ex.Message + "\nFunction: QueueMessage");
}
}
}
public void messageReceived(string message, messageType msgType)
{
publishMessage(message, msgType);
if (msgType.Equals(messageType.REGISTERED))
{
return;
}
if (msgType.Equals(messageType.TEST))
{
return;
}
if (msgType.Equals(messageType.KEEPALIVE))
{
return;
}
string operationType = TextFollowing(message, "OPERATION:", "");
string localRoomId = TextFollowing(message, "LOCALCONFROOMID:", "");
string serverRoomId = TextFollowing(message, "SERVERROOMID:", "");
string operatorName = TextFollowing(message, "OPERATORNAME:", "");
if (operationType == "ADDMEMBER")
{
foreach (KeyValuePair <string, int> kv in addIndex)
{
if (message.Contains(kv.Key))
{
string oneLine = TextFollowing(message, kv.Key + ":", "");
string type = kv.Key;
int index = addIndex[type];
addDelegates[index](oneLine, operatorName, localRoomId, serverRoomId);
}
}
}
else if (operationType == "DELETEMEMBER")
{
foreach (KeyValuePair <string, int> kv in deleteIndex)
{
if (message.Contains(kv.Key))
{
string oneLine = TextFollowing(message, kv.Key + ":", "");
string type = kv.Key;
int index = deleteIndex[type];
deleteDelegates[index](oneLine, operatorName, localRoomId, serverRoomId);
}
}
}
}
protected override void GenerateToString(messageType message)
{
Writer.WriteLine(
@" @Override
public String toString()
{
String ret = System.getProperty(""line.separator"");
return toString(new BaseFormat(0,ret));
}
@Override
public String toString(IFormat format)
{
StringBuilder bd = new StringBuilder();");
Writer.WriteLine(
@" format.formatHeader(bd,""{0}"");
", message.name);
var fields = message.field.OrderBy(_ => _.id);
foreach (var field in fields)
{
switch (field.modifier)
{
case modifierType.repeated:
Writer.WriteLine(
@" format.formatField(bd,""{0}"", get{1}List());
", field.name, field.name.Capitalize());
break;
case modifierType.optional:
Writer.WriteLine(
@" format.formatField(bd,""{0}"", has{0}() ? get{0}() : null);
", field.name.Capitalize());
break;
default:
Writer.WriteLine(
@" format.formatField(bd,""{0}"", get{0}());", field.name.Capitalize());
break;
}
}
Writer.WriteLine(
@" format.formatFooter(bd);
return bd.toString();
}
");
}
internal virtual void GenerateAbstractBaseClass(messageType message)
{
InitializeAbstractClass(message);
GenerateClassFields(message);
GenerateClassConstructor(message);
GeneratePrivateOrBuilderImpl(message);
GenerateBuild(message);
GenerateFlush(message);
GenerateSerialization(message);
GenerateEqualsAndHashCode(message);
GenerateToString(message);
GenerateFieldsAccessors(message);
GenerateIndexesAccessors(message);
EndAbstractClass(message);
}
public void messageReceived(string message, messageType msgType)
{
if (msgType.Equals(messageType.REGISTERED))
{
updateLabelStatus(statusLabel, "注册成功");
}
else if (msgType.Equals(messageType.KEEPALIVE))
{
PublishMessage(keepaliveTextbox, message);
}
else
{
PublishMessage(ReceiveTextBox, message);
}
}
public serverMessage(messageType p1, ForumPolicy p2, string forumName)
{
// TODO: Complete member initialization
_messageType = p1;
policy = p2;
stringContent = new List <string>();
stringContent.Add(forumName);
intContent = null;
time = DateTime.Now;
policy = null;
ListOfMemberMessages = null;
ListOfForumModerators = null;
Threads = null;
getThread = null;
}
protected override void InitializeAbstractClass(messageType message)
{
Writer = GetStream(OutputFolder, "Abstract" + message.name + ".java", GeneratedNamespace);
WriteAutoGenerationWarning(Writer);
Writer.WriteLine(
@"package {0};
", GeneratedNamespace);
GenerateImports(message);
Writer.WriteLine(
@"@SuppressWarnings(""all"")
public abstract class Abstract{0} implements ProtoOrBuilder
{{"
, message.name);
}
public CustomMessageBox(string messageText, string messageBoxTitle, messageType mType, resultType rType)
{
InitializeComponent();
messageTextBlock.Text = messageText;
this.Title = messageBoxTitle;
switch (mType)
{
case messageType.Info:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/info.png") as ImageSource;
break;
case messageType.Error:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/error.png") as ImageSource;
break;
case messageType.Warning:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/Warning.png") as ImageSource;
break;
case messageType.Question:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/Question.png") as ImageSource;
break;
default:
break;
}
switch (rType)
{
case resultType.OK:
okButton.Visibility = Visibility.Visible;
noButton.Visibility = Visibility.Hidden;
yesButton.Visibility = Visibility.Hidden;
break;
case resultType.YesNo:
okButton.Visibility = Visibility.Hidden;
noButton.Visibility = Visibility.Visible;
yesButton.Visibility = Visibility.Visible;
break;
default:
break;
}
}
public void messageReceived(string message, messageType msgType)
{
publishMessage(message, msgType);
if (msgType.Equals(messageType.REGISTERED))
return;
if (msgType.Equals(messageType.TEST))
return;
if (msgType.Equals(messageType.KEEPALIVE))
return;
string operationType = TextFollowing(message, "OPERATION:", "");
string localRoomId = TextFollowing(message, "LOCALCONFROOMID:", "");
string serverRoomId = TextFollowing(message, "SERVERROOMID:", "");
string operatorName = TextFollowing(message, "OPERATORNAME:", "");
if (operationType == "ADDMEMBER")
{
foreach (KeyValuePair<string, int> kv in addIndex)
{
if (message.Contains(kv.Key))
{
string oneLine = TextFollowing(message, kv.Key + ":", "");
string type = kv.Key;
int index = addIndex[type];
addDelegates[index](oneLine, operatorName, localRoomId, serverRoomId);
}
}
}
else if (operationType == "DELETEMEMBER")
{
foreach (KeyValuePair<string, int> kv in deleteIndex)
{
if (message.Contains(kv.Key))
{
string oneLine = TextFollowing(message, kv.Key + ":", "");
string type = kv.Key;
int index = deleteIndex[type];
deleteDelegates[index](oneLine, operatorName, localRoomId, serverRoomId);
}
}
}
}
public CustomMessageBox(string messageText, string messageBoxTitle, messageType mType, resultType rType)
{
InitializeComponent();
messageTextBlock.Text = messageText;
this.Title = messageBoxTitle;
switch (mType) {
case messageType.Info:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/info.png") as ImageSource;
break;
case messageType.Error:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/error.png") as ImageSource;
break;
case messageType.Warning:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/Warning.png") as ImageSource;
break;
case messageType.Question:
messageIcon.Source = new ImageSourceConverter().ConvertFromString("pack://application:,,,/ACS;component/images/Question.png") as ImageSource;
break;
default:
break;
}
switch (rType) {
case resultType.OK:
okButton.Visibility = Visibility.Visible;
noButton.Visibility = Visibility.Hidden;
yesButton.Visibility = Visibility.Hidden;
break;
case resultType.YesNo:
okButton.Visibility = Visibility.Hidden;
noButton.Visibility = Visibility.Visible;
yesButton.Visibility = Visibility.Visible;
break;
default:
break;
}
}
protected override void GenerateFlush(messageType message)
{
IncludeWriter.WriteLine(@" void flush();");
CppWriter.WriteLine(
@"
void Abstract{0}::flush()
{{", message.name.Capitalize());
var allFields = message.field.OrderBy(_ => _.id);
var messageFields = from fld in allFields
where fld.messageType != null
&& fld.type == typeType.nestedMessage
select fld;
var has = false;
foreach (var field in messageFields)
{
has = true;
CppWriter.WriteLine(
field.modifier == modifierType.repeated
? @" m_{0}List.clear();"
: @" m_{0}.reset();", field.name);
}
if (!has)
CppWriter.WriteLine(@" // NOP");
CppWriter.WriteLine(@" }");
CppWriter.WriteLine();
}
protected override void GenerateBuild(messageType message)
{
IncludeWriter.WriteLine(
@" virtual void preBuild() {} // use this method to customize the build process
std::iostream& contentStream() override;
void build();
void build(std::ostream& output, bool saveToOutput);
");
if(!message.IsRoot)
{
CppWriter.WriteLine(
@"
std::iostream& Abstract{0}::contentStream()
{{
return getRoot()->contentStream();
}}", message.name);
}
else
{
IncludeWriter.WriteLine(@" void setContentStream(std::shared_ptr<std::iostream> contentStream);");
CppWriter.WriteLine(
@"
std::iostream& Abstract{0}::contentStream()
{{
if (m_contentStream == nullptr)
m_contentStream.reset(new std::stringstream());
return *m_contentStream;
}}
void Abstract{0}::setContentStream(std::shared_ptr<std::iostream> contentStream)
{{
assert(m_contentStream == nullptr);
m_contentStream = contentStream;
}}
", message.name);
}
CppWriter.WriteLine(
@"
void Abstract{0}::build()
{{
build(contentStream(), false);
}}
void Abstract{0}::build(std::ostream& content, bool saveToOutput)
{{
auto alreadyBuilt = isBuilt();
if (alreadyBuilt && !saveToOutput)
return;
// prebuild hook
preBuild();
std::unique_ptr<{0}Header> headerCopy;
auto* builder = &m_header;
if (alreadyBuilt)
{{
headerCopy = std::make_unique<{0}Header>(m_header);
builder = headerCopy.get();
}}
", message.name);
foreach (var field in message.field.Where(_ => _.type == typeType.nestedMessage))
{
CppWriter.WriteLine(@" builder->clear_{0}();", field.name.ToLowerInvariant());
}
foreach (var index in message.index)
{
CppWriter.WriteLine(@" builder->clear_{0}();", index.name.ToLowerInvariant());
}
CppWriter.WriteLine(
@"
// build all nested messages to have their position in the content stream");
// do nothing for reference messages and pod types: the builder is already the owner of those fields
foreach (var field in message.field.Where(_ => _.type == typeType.nestedMessage))
{
if (field.modifier == modifierType.repeated)
{
CppWriter.WriteLine(
@" auto tmp_{0}List = {0}List();
for (auto* {0} : tmp_{0}List)
{{
auto oldPos = {0}->positionInContent();
{0}->build(content, saveToOutput);
builder->add_{1}({0}->positionInContent());
if (alreadyBuilt || saveToOutput)
{0}->setPositionInContent(oldPos);
}}"
, field.name, field.name.ToLowerInvariant());
}
else if (field.modifier == modifierType.optional)
{
CppWriter.WriteLine(
@"
auto* tmp_{0} = {0}();
if (tmp_{0} != nullptr)
{{
auto oldPos = tmp_{0}->positionInContent();
tmp_{0}->build(content, saveToOutput);
builder->set_{1}(tmp_{0}->positionInContent());
if (alreadyBuilt)
tmp_{0}->setPositionInContent(oldPos);
}}"
, field.name, field.name.ToLowerInvariant());
}
else
{
CppWriter.WriteLine(
@"
auto* tmp_{0} = &{0}();
if (tmp_{0} != nullptr)
{{
auto oldPos = tmp_{0}->positionInContent();
tmp_{0}->build(content, saveToOutput);
builder->set_{1}(tmp_{0}->positionInContent());
if (alreadyBuilt)
tmp_{0}->setPositionInContent(oldPos);
}}"
, field.name, field.name.ToLowerInvariant());
}
}
// create indexes
foreach (var index in message.index)
{
CppWriter.WriteLine(
@"
std::sort(tmp_{0}List.begin(), tmp_{0}List.end(), []({1}* left, {1}* right) {{ return left->{2}() < right->{2}(); }});
for (auto* {0} : tmp_{0}List)
{{
builder->add_{3}()->CopyFrom({0}->getLocalMessageDescriptor());
}}
", index.ReferenceField.name, index.ReferenceField.messageType, index.SortingField.name, index.name.ToLowerInvariant());
}
CppWriter.WriteLine(
@"
// write the header
content.seekp(0, std::ios::end);
// if we write to output, the position in the content stream
// will be restored when writing the parent header
// => this is not possible (and not needed) for root message
auto isRoot = {1};
auto dontSavePos = saveToOutput && isRoot;
if (!dontSavePos)
setPositionInContent((long)content.tellp());
{0}::Util::writeDelimited(*builder, content, isRoot);
if ((!alreadyBuilt && !saveToOutput) || (alreadyBuilt && saveToOutput))
{{
flush();
}}
}}
", ResourceNamespace, message.IsRoot ? "true" : "false");
if (!message.IsRoot)
return;
IncludeWriter.WriteLine(@" void writeDelimitedTo(std::ostream& output);");
CppWriter.WriteLine(
@" void Abstract{0}::writeDelimitedTo(std::ostream& output)
{{
build(output, true);
}}
"
, message.name);
}
protected override void GenerateToString(messageType message)
{
IncludeWriter.WriteLine(
@" using ProtoOrBuilder::toString;
std::string toString(BaseFormat& format) override;
");
CppWriter.WriteLine(
@" std::string Abstract{0}::toString(BaseFormat& format)
{{
auto bd = std::ostringstream();
", message.name);
CppWriter.WriteLine(
@" format.formatHeader(bd,""{0}"");
", message.name);
var fields = message.field.OrderBy(_ => _.id);
foreach (var field in fields)
{
switch (field.modifier)
{
case modifierType.repeated:
if (field.type == typeType.referenceMessage)
{
CppWriter.WriteLine(
@" format.formatField(bd, ""{1}List"", {0}Count());
", field.name, field.name.Capitalize());
}
else if (field.type == typeType.nestedMessage)
{
CppWriter.WriteLine(
@" format.formatProtoField(bd, ""{1}List"", {0}List());
", field.name, field.name.Capitalize());
}
else
{
CppWriter.WriteLine(
@" format.formatListField(bd, ""{1}List"", {0}List());
", field.name, field.name.Capitalize());
}
break;
case modifierType.optional:
if (field.type == typeType.referenceMessage || field.type == typeType.nestedMessage)
{
CppWriter.WriteLine(
@" format.formatProtoField(bd, ""{1}"", {0}(), has{1}());
", field.name, field.name.Capitalize());
}
else
{
CppWriter.WriteLine(
@" format.formatField(bd, ""{1}"", {0}(), has{1}());
", field.name, field.name.Capitalize());
}
break;
default:
if (field.type == typeType.referenceMessage || field.type == typeType.nestedMessage)
{
CppWriter.WriteLine(
@" format.formatProtoField(bd, ""{0}"", {0}());", field.name);
}
else
{
CppWriter.WriteLine(
@" format.formatField(bd, ""{0}"", {0}());", field.name);
}
break;
}
}
CppWriter.WriteLine(
@" format.formatFooter(bd);
return bd.str();
}
");
}
protected override void GenerateClassIndex(messageType message, indexType index)
{
// indexes are build at build time
var field = index.ReferenceField;
var fieldType = FieldType(field);
var sortByType = FieldType(index.SortingField);
Writer.WriteLine(
@" /// <summary>
/// {4}
/// </summary>
public IEnumerable<{1}> {0}List
{{
get
{{
Debug.Assert(IsBuilt, ""Index is not built yet!"");
return Enumerable.Range(0, {0}Count).Select(Get{0});
}}
}}
/// <summary>
/// {4}
/// </summary>
public {1} Get{0}(int index)
{{
Debug.Assert(IsBuilt, ""Index is not built yet!"");
return ({1})Root.Decode(_header.Get{0}(index));
}}
/// <summary>
/// {4}
/// </summary>
public int {0}Count
{{
get
{{
Debug.Assert(IsBuilt, ""Index is not built yet!"");
return _header.{0}Count;
}}
}}
/// <summary>
/// {4}
/// </summary>
public {1} Search{0}({2} item)
{{
Debug.Assert(IsBuilt, ""Index is not built yet!"");
return Search{0}(item, 0, {0}Count - 1);
}}
/// <summary>
/// {4}
/// </summary>
protected {1} Search{0}({2} item, int min, int max)
{{
Debug.Assert(IsBuilt, ""Index is not built yet!"");
if (max < min)
return null;
int avg = (min + max) >> 1;
var candidate = Get{0}(avg);
var candidateKey = candidate.{3};
if (candidateKey == item)
return candidate;
if (candidateKey < item)
return Search{0}(item, avg + 1, max);
return Search{0}(item, min, avg - 1);
}}
", index.name.Capitalize(), fieldType, sortByType, index.sortBy.Capitalize(), index.description.Safe());
}
protected override void GenerateClassReferenceField(messageType message, fieldType field)
{
var fieldType = FieldType(field);
if (field.modifier == modifierType.repeated)
{
Writer.WriteLine(
@" /// <summary>
/// {2}
/// </summary>
public void Add{0}({1} item)
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
Builder.Add{0}(item.LocalMessageDescriptor);
}}
/// <summary>
/// {2}
/// </summary>
public void Remove{0}({1} item)
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
Builder.{0}List.Remove(item.LocalMessageDescriptor);
}}
/// <summary>
/// {2}
/// </summary>
public {1} Get{0}(int index)
{{
return ({1})Root.Decode(_header.Get{0}(index));
}}
/// <summary>
/// {2}
/// </summary>
public IEnumerable<{1}> {0}List
{{
get
{{
return Enumerable.Range(0, {0}Count).Select(Get{0});
}}
}}
/// <summary>
/// {2}
/// </summary>
public int {0}Count
{{
get
{{
return _header.{0}Count;
}}
}}
"
, field.name.Capitalize(), fieldType, field.description.Safe());
return;
}
if (field.modifier == modifierType.optional)
{
Writer.WriteLine(
@" /// <summary>
/// {1}
/// </summary>
public bool Has{0}
{{
get
{{
return _header.Has{0};
}}
}}
/// <summary>
/// {1}
/// </summary>
public void Clear{0}()
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
Builder.Clear{0}();
}}
"
, field.name.Capitalize(), field.description.Safe());
}
Writer.WriteLine(
@" /// <summary>
/// {2}
/// </summary>
public {1} {0}
{{
get
{{
return ({1})Root.Decode(_header.{0});
}}
set
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
Builder.{0} = value.LocalMessageDescriptor;
}}
}}
"
, field.name.Capitalize(), fieldType, field.description.Safe());
}
protected override void GenerateClassFields(messageType message)
{
if (!message.IsRoot)
{
Writer.WriteLine(
@" private ProtoOrBuilder _parent;
internal ProtoOrBuilder Parent
{
get
{
return _parent;
}
set
{
_parent = value;
Root = _parent.Root;
}
}
public int FieldId {get; set; } // field's ID as defined in the protozbuf.xml file (=> the .proto file)
public int Index { get; set; } // instance's index in the parent's list
");
}
else
{
Writer.WriteLine(@" protected Stream _contentStream;");
}
Writer.WriteLine(
@" private {0}HeaderOrBuilder _header;
internal long PositionInContent {{ get; set; }}
public int SerializedSize
{{
get
{{
Debug.Assert(IsBuilt, ""Can't compute size of an unbuilt object!"");
return (_header as {0}Header).SerializedSize;
}}
}}"
, message.name);
var allFields = message.field.OrderBy(_ => _.id);
var messageFields = from fld in allFields
where fld.messageType != null && fld.type != typeType.referenceMessage
select fld;
foreach (var field in messageFields)
{
var fieldtype = FieldType(field);
switch (field.modifier)
{
case modifierType.repeated:
Writer.WriteLine(
@" internal IStretchable<{0}> _{1};"
, fieldtype, field.name);
break;
default:
Writer.WriteLine(
@" private {0} _{1};"
, fieldtype, field.name);
break;
}
}
}
protected override void GeneratePrivateOrBuilderImpl(messageType message)
{
Writer.WriteLine(message.IsRoot
?
@" public ProtoOrBuilder Root { get { return this; } }
"
:
@" public ProtoOrBuilder Root { get; private set; }
");
Writer.WriteLine(
@" public ProtoOrBuilder Decode(LocalMessageDescriptor field)
{
return Decode(field.CoordinateList, 0);
}
public ProtoOrBuilder Decode(IList<int> coordinates, int index)
{
if (coordinates.Count == 0)
return null;
var fieldIdIdx = index;
var fieldIndexIdx = index + 1;
var remainderIdx = index + 2;
switch(coordinates[fieldIdIdx])
{"
);
var allFields = message.field.Where(_ => _.type == typeType.nestedMessage || _.type == typeType.referenceMessage).OrderBy(_ => _.id);
foreach (var field in allFields)
{
Writer.WriteLine(
@" case {0}:"
, field.id);
if (field.modifier == modifierType.repeated)
{
Writer.WriteLine(
field.type != typeType.nestedMessage
?
@" return Get{0}(coordinates[fieldIndexIdx]);"
:
@" return coordinates.Count == remainderIdx ? Get{0}(coordinates[fieldIndexIdx]) : Get{0}(coordinates[fieldIndexIdx]).Decode(coordinates, remainderIdx);"
, field.name.Capitalize());
}
else if (field.modifier == modifierType.optional)
{
Writer.WriteLine(
field.type != typeType.nestedMessage
?
@" return {0};"
:
@" return coordinates.Count == remainderIdx ? Add{0}() : {0}.Decode(coordinates, remainderIdx);",
field.name.Capitalize());
}
else
{
Writer.WriteLine(
field.type != typeType.nestedMessage
?
@" return {0};"
:
@" return coordinates.Count == remainderIdx ? {0} : {0}.Decode(coordinates, remainderIdx);"
, field.name.Capitalize());
}
}
Writer.WriteLine(
@" default:
return null;
}
}
public void AddCoordinates(IList<int> coordinates)
{");
if (!message.IsRoot)
{
Writer.WriteLine(
@" coordinates.Insert(0, FieldId);
coordinates.Insert(1, Index);
if (Parent == null)
return;
Parent.AddCoordinates(coordinates);"
);
}
Writer.WriteLine(
@" }
public LocalMessageDescriptor LocalMessageDescriptor
{
get
{
var b = new LocalMessageDescriptor.Builder();
AddCoordinates(b.CoordinateList);
return b.Build();
}
}
");
Writer.WriteLine(
@" private {0}Header.Builder Builder {{ get {{ return _header as {0}Header.Builder; }} }}
public bool IsBuilt {{ get {{ return !(_header is {0}Header.Builder); }} }}
"
, message.name);
}
protected override void GenerateSerialization(messageType message)
{
if (message.IsRoot)
{
IncludeWriter.WriteLine(
@" static std::unique_ptr<{0}> ParseFrom(std::shared_ptr<std::iostream> s);
"
, message.name);
CppWriter.WriteLine(
@" std::unique_ptr<{0}> Abstract{0}::ParseFrom(std::shared_ptr<std::iostream> s)
{{
{0}Header header;
auto success = Util::readDelimited(*s, header, true); // the root is always at the end of the stream
assert((""Can't decode header!"", success));
auto parsed = std::make_unique<{0}>(header, (long)s->tellg());
parsed->setContentStream(s);
return parsed;
}}
"
, message.name);
return;
}
IncludeWriter.WriteLine(
@" static std::unique_ptr<{0}> ParseFrom(std::iostream& s, int pos);
"
, message.name);
CppWriter.WriteLine(
@" std::unique_ptr<{0}> Abstract{0}::ParseFrom(std::iostream& s, int pos)
{{
s.seekg(pos, std::ios::beg);
{0}Header header;
auto success = Util::readDelimited(s, header);
assert((""Can't decode header!"", success));
auto parsed = std::make_unique<{0}>(header, pos);
return parsed;
}}
"
, message.name);
}
protected override void EndAbstractClass(messageType message)
{
IncludeWriter.WriteLine(
@" };
");
}
protected override void InitializeAbstractClass(messageType message)
{
IncludeWriter.WriteLine(
@" class Abstract{0} : public ProtoOrBuilder
{{"
, message.name);
}
internal override void GenerateHeaderOrBuilderInterface(messageType message)
{
// NOP: C++ doesn't have interfaces
}
internal override void GenerateFinalClientClass(messageType message)
{
var filePathInclude = GetFilePath(IncludesFolder, message.name + ".h", Namespace);
if (File.Exists(filePathInclude)) return;
using (var strm = GetStreamFromPath(filePathInclude))
{
strm.WriteLine(
@"#pragma once
#include ""{0}/{1}.h""
{2}
class {3} : public {4}::Abstract{3}
{{
public:
{3}();
{3}(const generated::{3}Header& header, int posInContent);
}};
{5}
"
, GetNamespacePathSlash(GeneratedNamespace), // 0
DocumentName + ".lazy", // 1
GetNamespaceBegin(Namespace), // 2
message.name.Capitalize(), // 3
GeneratedNamespace, // 4
GetNamespaceEnd(Namespace)); // 5
}
var filePathCpp = GetFilePath(CppFolder, message.name + ".cpp", "");
if (File.Exists(filePathCpp)) return;
using (var strm = GetStreamFromPath(filePathCpp))
{
strm.WriteLine(
@"#include ""stdafx.h""
#include ""include/{0}/{1}.h"""
, GetNamespacePathSlash(Namespace), // 0
message.name.Capitalize() // 1
);
foreach (var field in message.field.Where(_ => _.type == typeType.nestedMessage))
{
strm.WriteLine(
@"#include ""include/{0}/{1}.h"""
, GetNamespacePathSlash(Namespace), // 0
field.messageType.Capitalize() // 1
);
}
strm.WriteLine(
@"{1}
{0}::{0}()
{{
// NOP
}}
{0}::{0}(const generated::{0}Header& header, int posInContent) : Abstract{0}(header, posInContent)
{{
// NOP
}}
{2}
"
, message.name.Capitalize(), // 0
GetNamespaceBegin(Namespace), // 1
GetNamespaceEnd(Namespace)); // 2);
}
}
protected override void GenerateClassReferenceField(messageType message, fieldType field)
{
var fieldType = FieldType(field);
if (field.modifier == modifierType.repeated)
{
IncludeWriter.WriteLine(
@" void add{1}({2}& item);
void remove{1}({2}& item);
std::vector<{2}*> {0}List();
{2}& get{1}(int index);
int {0}Count() const;
"
, field.name, field.name.Capitalize(), fieldType);
CppWriter.WriteLine(
@" void Abstract{4}::add{1}({3}& item)
{{
assert((""Can't modify an already built object!"", !isBuilt()));
m_header.add_{2}()->CopyFrom(item.getLocalMessageDescriptor());
}}
void Abstract{4}::remove{1}({3}& item)
{{
assert((""Can't modify an already built object!"", !isBuilt()));
auto vals = m_header.mutable_{2}();
auto newEnd = std::remove_if(vals->begin(), vals->end(), [this, &item](const LocalMessageDescriptor& check)
{{
return getRoot()->decode(check) == &item;
}});
vals->DeleteSubrange(newEnd - vals->begin(), vals->end() - newEnd);
}}
std::vector<{3}*> Abstract{4}::{0}List()
{{
auto count = {0}Count();
auto list = std::vector<{3}*>();
list.reserve(count);
for (auto i = 0; i < count; ++i)
{{
list.push_back(&get{1}(i));
}}
return list;
}}
{3}& Abstract{4}::get{1}(int index)
{{
return *dynamic_cast<{3}*>(getRoot()->decode(m_header.{2}(index)));
}}
int Abstract{4}::{0}Count() const
{{
return m_header.{2}_size();
}}
"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType, message.name);
return;
}
if (field.modifier == modifierType.optional)
{
IncludeWriter.WriteLine(
@" bool has{0}() const {{ return m_header.has_{1}(); }}
void clear{0}() {{ m_header.clear_{1}(); }}
"
, field.name.Capitalize(), field.name.ToLowerInvariant());
}
IncludeWriter.WriteLine(
@" void set{1}({2}& value);
{2}* {0}();
"
, field.name, field.name.Capitalize(), fieldType);
CppWriter.WriteLine(
@" void Abstract{4}::set{1}({3}& value)
{{
m_header.clear_{2}();
m_header.mutable_{2}()->CopyFrom(value.getLocalMessageDescriptor());
// TODO see if that works // m_header.set_allocated_{2}(value.getLocalMessageDescriptor());
}}
{3}* Abstract{4}::{0}()
{{
return dynamic_cast<{3}*>(getRoot()->decode(m_header.{2}()));
}}
"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType, message.name);
}
protected override void GenerateClassNestedField(messageType message, fieldType field)
{
var fieldType = FieldType(field);
if (field.modifier == modifierType.repeated)
{
IncludeWriter.WriteLine(
@" {2}& add{1}();
std::vector<{2}*> {0}List();
{2}& get{1}(int index);
int {0}Count() const;
"
, field.name, field.name.Capitalize(), fieldType);
CppWriter.WriteLine(
@" {3}& Abstract{4}::add{1}()
{{
assert((""Can't modify an already built object!"", !isBuilt()));
auto index = m_{0}List.size();
auto {0} = std::make_unique<{3}>();
{0}->setFieldId({5});
{0}->setIndex(index);
{0}->setParent(this);
m_{0}List.set(index, std::move({0}));
return *m_{0}List.get(index);
}}
std::vector<{3}*> Abstract{4}::{0}List()
{{
auto count = {0}Count();
auto list = std::vector<{3}*>();
list.reserve(count);
for (auto i = 0; i < count; ++i)
{{
list.push_back(&get{1}(i));
}}
return list;
}}
{3}& Abstract{4}::get{1}(int index)
{{
if (!m_{0}List.get(index))
{{
auto {0} = {3}::ParseFrom(contentStream(), m_header.{2}(index));
{0}->setFieldId({5});
{0}->setIndex(index);
{0}->setParent(this);
m_{0}List.set(index, std::move({0}));
}}
return *m_{0}List.get(index);
}}
int Abstract{4}::{0}Count() const
{{
return !isBuilt() ? m_{0}List.size() : m_header.{2}_size();
}}"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType, message.name, field.id);
return;
}
if (field.modifier == modifierType.optional)
{
IncludeWriter.WriteLine(
@" {2}& add{1}(); // adds the optional {1}
{2}* {0}();
bool has{1}() const;
void clear{1}();
"
, field.name, field.name.Capitalize(), fieldType);
CppWriter.WriteLine(
@" {3}& Abstract{4}::add{1}()
{{
if (m_{0} == nullptr)
{{
if (isBuilt() && has{1}())
{{
{0}(); // decode from body
}}
else
{{
assert((""Can't modify an already built object!"", !isBuilt()));
m_{0} = std::make_unique<{6}::{3}>();
m_{0}->setFieldId({5});
m_{0}->setParent(this);
}}
}}
return *m_{0};
}}
{3}* Abstract{4}::{0}()
{{
if (isBuilt() && has{1}() && m_{0} == nullptr)
{{
m_{0} = {3}::ParseFrom(contentStream(), m_header.{2}());
m_{0}->setFieldId({5});
m_{0}->setParent(this);
}}
return m_{0}.get();
}}
bool Abstract{4}::has{1}() const
{{
return (isBuilt() && m_header.has_{2}()) || (!isBuilt() && m_{0} != nullptr);
}}
void Abstract{4}::clear{1}()
{{
assert((""Can't modify an already built object!"", !isBuilt()));
m_{0}.reset();
}}
"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType, message.name, field.id, Namespace);
return;
}
IncludeWriter.WriteLine(@" {1}& {0}();", field.name, fieldType);
CppWriter.WriteLine(
@" {2}& Abstract{3}::{0}()
{{
if (m_{0} == nullptr)
{{
if (isBuilt())
{{
m_{0} = {2}::ParseFrom(contentStream(), m_header.{1}());
}}
else
{{
m_{0} = std::make_unique<{2}>();
}}
m_{0}->setFieldId({4});
m_{0}->setParent(this);
}}
return *m_{0};
}}
"
, field.name, field.name.ToLowerInvariant(), fieldType, message.name, field.id);
}
private void showMessage(messageType type, string text)
{
string typePrefix = String.Empty;
switch (type)
{
case messageType.Info: typePrefix = "Information:\r\n"; break;
case messageType.Warning: typePrefix = "Warning:\r\n"; break;
case messageType.Error: typePrefix = "Error:\r\n"; break;
}
this.Page.ClientScript.RegisterStartupScript(typeof(string), "postBackAlert", String.Format("window.alert('{0}');", Utility.QuoteJScriptString(typePrefix + text, false)), true);
}
protected override void GenerateClassIndex(messageType message, indexType index)
{
// indexes are build at build time
var field = index.ReferenceField;
var fieldType = FieldType(field);
var sortByType = FieldType(index.SortingField);
if (index.SortingField.type == typeType.@string)
sortByType = "const " + sortByType + "&";
IncludeWriter.WriteLine(
@" // Note: indexes are built during the build process, and aren't available before
std::vector<{2}*> {0}List();
{2}& get{1}(int index);
int {0}Count() const;
{2}* search{1}({3} item);
{2}* search{1}({3} item, int min, int max);
"
, index.name, index.name.Capitalize(), fieldType, sortByType);
CppWriter.WriteLine(
@" std::vector<{3}*> Abstract{4}::{0}List()
{{
assert((""Index is not built yet!"", isBuilt()));
auto count = {0}Count();
auto list = std::vector<{3}*>();
list.reserve(count);
for (auto i = 0; i < count; ++i)
{{
list.push_back(&get{1}(i));
}}
return list;
}}
{3}& Abstract{4}::get{1}(int index)
{{
assert((""Index is not built yet!"", isBuilt()));
return *dynamic_cast<{3}*>(getRoot()->decode(m_header.{2}(index)));
}}
int Abstract{4}::{0}Count() const
{{
assert((""Index is not built yet!"", isBuilt()));
return m_header.{2}_size();
}}
{3}* Abstract{4}::search{1}({5} item)
{{
assert((""Index is not built yet!"", isBuilt()));
// note: we don't use std::find so that
// we decode a minimum number of items
return search{1}(item, 0, {0}Count() - 1);
}}
{3}* Abstract{4}::search{1}({5} item, int min, int max)
{{
assert((""Index is not built yet!"", isBuilt()));
if (max < min)
return nullptr;
int avg = (min + max) >> 1;
auto& candidate = get{1}(avg);
{5} candidateKey = candidate.{6}();
if (candidateKey == item)
return &candidate;
if (candidateKey < item)
return search{1}(item, avg + 1, max);
return search{1}(item, min, avg - 1);
}}
"
, index.name, index.name.Capitalize(), index.name.ToLowerInvariant(), fieldType, message.name, sortByType, index.sortBy);
}
protected override void GenerateClassNestedField(messageType message, fieldType field)
{
var fieldType = FieldType(field);
if (field.modifier == modifierType.repeated)
{
Writer.WriteLine(
@" /// <summary>
/// {4}
/// </summary>
public {2} Add{1}()
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
{2} item = new {2}()
{{
FieldId = {3},
Index = _{0}.Count,
Parent = this
}};
_{0}.Add(item);
return item;
}}
/// <summary>
/// {4}
/// </summary>
public IEnumerable<{2}> {1}List
{{
get
{{
return Enumerable.Range(0, {1}Count).Select(Get{1});
}}
}}
/// <summary>
/// {4}
/// </summary>
public {2} Get{1}(int index)
{{
if (index >= {1}Count) return null;
var {0} = _{0}[index];
if ({0} == null)
{{
{0} = {2}.ParseFrom(ContentStream, _header.Get{1}(index));
_{0}[index] = {0};
{0}.FieldId = {3};
{0}.Index = index;
{0}.Parent = this;
}}
return {0};
}}
/// <summary>
/// {4}
/// </summary>
public int {1}Count
{{
get
{{
return !IsBuilt? _{0}.Count : _header.{1}Count;
}}
}}"
, field.name, field.name.Capitalize(), fieldType, field.id, field.description.Safe());
return;
}
if (field.modifier == modifierType.optional)
{
Writer.WriteLine(
@" /// <summary>
/// {3}
/// </summary>
public {2} Add{1}()
{{
if (_{0} == null)
{{
if (IsBuilt && Has{1})
{{
{1}.Equals(null); // decode from body (C# needs a function call)
}}
else
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
_{0} = new {2}()
{{
FieldId = {3},
Parent = this
}};
}}
}}
return _{0};
}}
/// <summary>
/// {3}
/// </summary>
public {2} {1}
{{
get
{{
if (IsBuilt && Has{1} && _{0} == null)
{{
_{0} = {2}.ParseFrom(ContentStream, _header.{1});
_{0}.FieldId = {3};
_{0}.Parent = this;
}}
return _{0};
}}
}}
/// <summary>
/// {3}
/// </summary>
public bool Has{1}
{{
get
{{
return (IsBuilt && _header.Has{1}) || (!IsBuilt && _{0} != null);
}}
}}
/// <summary>
/// {3}
/// </summary>
public void Clear{1}()
{{
Debug.Assert(!IsBuilt, ""Can't modify an already built object!"");
_{0} = null;
}}
"
, field.name, field.name.Capitalize(), fieldType, field.id);
return;
}
Writer.WriteLine(
@" /// <summary>
/// {4}
/// </summary>
public {2} {1}
{{
get
{{
if (_{0} == null)
{{
if (IsBuilt)
{{
_{0} = {2}.ParseFrom(ContentStream, _header.{1});
}}
else
{{
_{0} = new {2}();
}}
_{0}.FieldId = {3};
_{0}.Parent = this;
}}
return _{0};
}}
}}
"
, field.name, field.name.Capitalize(), fieldType, field.id, field.description.Safe());
}
protected override void GenerateClassConstructor(messageType message)
{
IncludeWriter.WriteLine(
@" protected:
Abstract{0}();
Abstract{0}(const {0}Header& header, int posInContent);
Abstract{0}(const Abstract{0}&) = delete;
Abstract{0}& operator=(const Abstract{0}&) = delete;
", message.name);
CppWriter.WriteLine(
@"
Abstract{0}::Abstract{0}() : {1} m_positionInContent(-1)
{{
}}
Abstract{0}::Abstract{0}(const {0}Header& header, int pos) : {1} m_header(header), m_positionInContent(pos)
{{
}}
", message.name, message.IsRoot ? "" : "m_parent(nullptr), m_root(nullptr),");
}
protected override void GenerateBuild(messageType message)
{
if (!message.IsRoot)
{
Writer.WriteLine(
@" public Stream ContentStream
{
get
{
return Root.ContentStream;
}
}
");
}
else
{
Writer.WriteLine(
@" public Stream ContentStream
{
get
{
if (_contentStream == null)
_contentStream = new MemoryStream();
return _contentStream;
}
set
{
if (_contentStream != null)
_contentStream.Dispose();
_contentStream = value;
}
}
");
}
Writer.WriteLine(
@" public virtual void PreBuild()
{{
// use this method to customize the build process
}}
public void Build()
{{
Build(ContentStream, false);
}}
internal void Build(Stream content, bool saveToOutput)
{{
var alreadyBuilt = IsBuilt;
if (alreadyBuilt && !saveToOutput)
return;
// prebuild hook
PreBuild();
var builder = Builder;
if (builder == null)
builder = new {0}Header.Builder(({0}Header) _header);", message.name);
foreach (var field in message.field.Where(_ => _.type == typeType.nestedMessage))
{
Writer.WriteLine(@" builder.Clear{0}();", field.name.Capitalize());
}
foreach (var index in message.index)
{
Writer.WriteLine(@" builder.Clear{0}();", index.name.Capitalize());
}
Writer.WriteLine(
@"
// build all nested messages to have their position in the content stream");
// do nothing for reference messages and pod types: the builder is already the owner of those fields
foreach (var field in message.field.Where(_ => _.type == typeType.nestedMessage))
{
if (field.modifier == modifierType.repeated)
{
Writer.WriteLine(
@" var tmp_{0}List = {1}List;
foreach(var {0} in tmp_{0}List)
{{
var oldPos = {0}.PositionInContent;
{0}.Build(content, saveToOutput);
builder.Add{1}((uint){0}.PositionInContent);
if (alreadyBuilt || saveToOutput)
{0}.PositionInContent = oldPos;
}}
", field.name, field.name.Capitalize());
}
else
{
Writer.WriteLine(
@" var tmp_{0} = {1};
if (tmp_{0} != null)
{{
var oldPos = tmp_{0}.PositionInContent;
tmp_{0}.Build(content, saveToOutput);
builder.{1} = (uint)tmp_{0}.PositionInContent;
if (alreadyBuilt)
tmp_{0}.PositionInContent = oldPos;
}}
", field.name, field.name.Capitalize());
}
}
// create indexes
foreach (var index in message.index)
{
Writer.WriteLine(
@"
foreach(var {0} in tmp_{0}List.OrderBy(item => item.{2}))
{{
builder.Add{1}({0}.LocalMessageDescriptor);
}}"
, index.ReferenceField.name, index.name.Capitalize(), index.sortBy.Capitalize());
}
Writer.WriteLine(
@" // write the header
content.Seek(0, SeekOrigin.End);
// if we write to output, the position in the content stream
// will be restored when writing the parent header
// => this is not possible (and not needed) for root message
var isRoot = {0};
var dontSavePos = saveToOutput && isRoot;
if (!dontSavePos)
PositionInContent = content.Position;
var builtHeader = builder.Build();
builtHeader.WriteDelimitedTo(content);
"
, message.IsRoot ? "true" : "false");
// write the message length at the end for later decoding
// Note: the length is fixed
if (message.IsRoot)
{
Writer.WriteLine(
@" var codedStream = CodedOutputStream.CreateInstance(content, sizeof(uint));
codedStream.WriteFixed32NoTag((uint)builtHeader.SerializedSize);
codedStream.Flush();
");
}
Writer.WriteLine(
@"
if (!alreadyBuilt && !saveToOutput)
{
_header = builtHeader;
Flush();
}
if (alreadyBuilt && saveToOutput)
{
Flush();
}
}
");
if (!message.IsRoot)
return;
Writer.WriteLine(
@" public void WriteDelimitedTo(Stream output)
{
Build(output, true);
}
public byte[] WriteDelimitedToBytes()
{
using (var strm = new MemoryStream())
{
WriteDelimitedTo(strm);
return strm.ToArray();
}
}
"
);
}
protected override void GeneratePrivateOrBuilderImpl(messageType message)
{
IncludeWriter.WriteLine(@" public:
");
IncludeWriter.Write(" ProtoOrBuilder* getRoot() override { return ");
IncludeWriter.Write(message.IsRoot ? @"this" : "m_root");
IncludeWriter.WriteLine("; }");
IncludeWriter.WriteLine(@" ProtoOrBuilder* decode(const LocalMessageDescriptor& field) override;
ProtoOrBuilder* decode(const CoordinateList& coordinates, int index) override;");
CppWriter.WriteLine(
@"
ProtoOrBuilder* Abstract{0}::decode(const LocalMessageDescriptor& field)
{{
return decode(field.coordinate(), 0);
}}
ProtoOrBuilder* Abstract{0}::decode(const CoordinateList& coordinates, int index)
{{
if (coordinates.size() == 0)
return nullptr;
auto fieldIdIdx = index;
auto fieldIndexIdx = index + 1;
auto remainderIdx = index + 2;
switch(coordinates.Get(fieldIdIdx))
{{", message.name);
var allFields = message.field.Where(_ => _.type == typeType.nestedMessage || _.type == typeType.referenceMessage).OrderBy(_ => _.id);
foreach (var field in allFields)
{
CppWriter.WriteLine(
@" case {0}:", field.id);
if (field.modifier == modifierType.repeated)
{
CppWriter.WriteLine(
field.type != typeType.nestedMessage
?
@" return &this->get{0}(coordinates.Get(fieldIndexIdx));"
:
@" return coordinates.size() == remainderIdx ? &this->get{0}(coordinates.Get(fieldIndexIdx)) : this->get{0}(coordinates.Get(fieldIndexIdx)).decode(coordinates, remainderIdx);",
field.name.Capitalize());
}
else if (field.modifier == modifierType.optional)
{
CppWriter.WriteLine(
field.type != typeType.nestedMessage
?
@" return this->{0}();"
:
@" return coordinates.size() == remainderIdx ? &this->add{1}() : this->{0}()->decode(coordinates, remainderIdx);",
field.name, field.name.Capitalize());
}
else
{
CppWriter.WriteLine(
field.type != typeType.nestedMessage
?
@" return this->{0}();"
:
@" return coordinates.size() == remainderIdx ? &this->{0}() : this->{0}().decode(coordinates, remainderIdx);",
field.name);
}
}
CppWriter.WriteLine(
@" default:
return nullptr;
}
}
");
IncludeWriter.WriteLine(@" void addCoordinates(CoordinateList& coordinates) override;");
CppWriter.WriteLine(
@" void Abstract{0}::addCoordinates(CoordinateList& coordinates)
{{", message.name);
if (!message.IsRoot)
{
CppWriter.WriteLine(
@"
coordinates.Add(0);
coordinates.Add(0);
for (auto i = coordinates.size() - 1; i >= 2; --i)
{
coordinates.Set(i, coordinates.Get(i - 2));
}
coordinates.Set(0, fieldId());
coordinates.Set(1, index());
if (getParent() == nullptr)
return;
getParent()->addCoordinates(coordinates);");
}
CppWriter.WriteLine(@" }
");
IncludeWriter.WriteLine(@" LocalMessageDescriptor getLocalMessageDescriptor() override;");
CppWriter.WriteLine(
@" LocalMessageDescriptor Abstract{0}::getLocalMessageDescriptor()
{{
auto b = LocalMessageDescriptor();
addCoordinates(*b.mutable_coordinate());
return b;
}}", message.name);
IncludeWriter.WriteLine(@" bool isBuilt() const { return m_positionInContent != -1; }");
}
protected override void GenerateClassFields(messageType message)
{
if (!message.IsRoot)
{
IncludeWriter.WriteLine(
@" private:
ProtoOrBuilder* m_root;
ProtoOrBuilder* m_parent;
int m_fieldId = -1; // field's ID as defined in the protozbuf.xml file (=> the .proto file)
int m_index = -1; // instance's index in the parent's list
public:
ProtoOrBuilder* getParent() { return m_parent; }
void setParent(ProtoOrBuilder* parent);
int fieldId() const { return m_fieldId; }
void setFieldId(int fieldId) { m_fieldId = fieldId; }
int index() const { return m_index; }
void setIndex(int index) { m_index = index; }
");
CppWriter.WriteLine(
@" void Abstract{0}::setParent(ProtoOrBuilder* parent)
{{
m_parent = parent;
m_root = parent->getRoot();
}}", message.name);
}
else
{
IncludeWriter.WriteLine(
@" protected:
std::shared_ptr<std::iostream> m_contentStream;");
}
IncludeWriter.WriteLine(
@" protected:
{0}Header m_header;
long m_positionInContent;
public:
int positionInContent() const {{ return m_positionInContent; }}
void setPositionInContent(int positionInContent) {{ m_positionInContent = positionInContent; }}
protected: "
, message.name);
var allFields = message.field.OrderBy(_ => _.id);
var messageFields = from fld in allFields
where fld.messageType != null && fld.type != typeType.referenceMessage
select fld;
foreach (var field in messageFields)
{
var fieldtype = FieldType(field);
switch (field.modifier)
{
case modifierType.repeated:
IncludeWriter.WriteLine(
@" {2}::ArrayList<{0}> m_{1}List;", fieldtype, field.name, ResourceNamespace);
break;
default:
IncludeWriter.WriteLine(
@" std::unique_ptr<{0}> m_{1};", fieldtype, field.name);
break;
}
}
}
protected override void GenerateEqualsAndHashCode(messageType message)
{
// throw new NotImplementedException();
}
protected override void GenerateClassSimpleField(messageType message, fieldType field)
{
var fieldTypeForList = FieldType(field);
var fieldType = fieldTypeForList;
if (field.type == typeType.@string)
fieldType = "const " + fieldType + "&";
// In C++, a repeated enum is stored as a RepeatedField<int>
var underlyingType = field.type == typeType.@enum ?
"int" :
fieldTypeForList;
if (field.modifier == modifierType.repeated)
{
IncludeWriter.WriteLine(
@" void add{1}({2} item);
void remove{1}({2} item);
std::vector<{3}> {0}List();
{2} get{1}(int index);
int {0}Count() const;
"
, field.name, field.name.Capitalize(), fieldType, fieldTypeForList);
CppWriter.WriteLine(
@" void Abstract{4}::add{1}({3} item)
{{
assert((""Can't modify an already built object!"", !isBuilt()));
m_header.add_{2}(item);
}}
void Abstract{4}::remove{1}({3} item)
{{
assert((""Can't modify an already built object!"", !isBuilt()));
auto vals = m_header.mutable_{2}();
auto newEnd = std::remove_if(vals->begin(), vals->end(), [&item]({6} check) {{ return check != item; }});
vals->Truncate(newEnd - vals->begin());
}}
std::vector<{5}> Abstract{4}::{0}List()
{{
auto count = {0}Count();
auto list = std::vector<{3}>();
list.reserve(count);
for (auto i = 0; i < count; ++i)
{{
list.push_back(get{1}(i));
}}
return list;
}}
{3} Abstract{4}::get{1}(int index)
{{
return m_header.{2}(index);
}}
int Abstract{4}::{0}Count() const
{{
return m_header.{2}_size();
}}
"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType, message.name, fieldTypeForList, underlyingType);
return;
}
if (field.modifier == modifierType.optional)
{
IncludeWriter.WriteLine(
@" bool has{0}() const {{ return m_header.has_{1}(); }}
void clear{0}() {{ m_header.clear_{1}(); }}
"
, field.name.Capitalize(), field.name.ToLowerInvariant());
}
IncludeWriter.WriteLine(
@" {3} {0}() const {{ return m_header.{2}(); }}
void set{1}({3} value) {{ m_header.set_{2}(value); }}
"
, field.name, field.name.Capitalize(), field.name.ToLowerInvariant(), fieldType);
}
protected override void GenerateClassConstructor(messageType message)
{
Writer.WriteLine(
@" /// <summary>
/// {1}
/// </summary>
protected Abstract{0}()
{{
_header = new {0}Header.Builder();
PositionInContent = -1;
Flush();
}}
/// <summary>
/// {1}
/// </summary>
protected Abstract{0}({0}Header header, long positionInContent)
{{
_header = header;
PositionInContent = positionInContent;
Flush();
}}
", message.name, message.description.Safe());
}
