/// <summary>
///
/// </summary>
public void Flush()
{
if (outputStream != null)
{
outputStream.Flush();
}
}
public void SerializesPickeDocString()
{
var pickleDocSring = new PickleDocString
{
Location = new Location
{
Line = 10,
Column = 20
},
ContentType = "text/plain",
Content = "some\ncontent\n"
};
byte[] serializedBytes;
using (MemoryStream stream = new MemoryStream())
{
var codedOutputStream = new Google.Protobuf.CodedOutputStream(stream);
codedOutputStream.WriteMessage(pickleDocSring);
codedOutputStream.Flush();
serializedBytes = stream.ToArray();
}
PickleDocString parsedCopy = PickleDocString.Parser.ParseDelimitedFrom(new MemoryStream(serializedBytes));
Assert.Equal(pickleDocSring, parsedCopy);
}
public bool SendPacket(Proto.MsgId msgId, Google.Protobuf.IMessage msg)
{
if (_state != NetworkState.Connected)
{
return(false);
}
int size = 0;
if (msg != null)
{
size = msg.CalculateSize();
}
if (msgId != Proto.MsgId.MiPing)
{
UnityEngine.Debug.Log("send msg. msg_id:" + msgId + " msg size:" + size);
}
var byteStream = new MemoryStream();
BinaryWriter bw = new BinaryWriter(byteStream);
var totalLen = size + PacketHead.HeadSize;
bw.Write((ushort)totalLen); // total size
bw.Write((ushort)2); // head size
bw.Write((ushort)msgId);
if (msg != null)
{
Google.Protobuf.CodedOutputStream outStream = new Google.Protobuf.CodedOutputStream(byteStream);
msg.WriteTo(outStream);
outStream.Flush();
}
Byte[] buf = byteStream.ToArray();
size = size + PacketHead.HeadSize;
try
{
int pos = 0;
while (size > 0)
{
int sent = _sock.Send(buf, pos, size, SocketFlags.None);
size -= sent;
pos += sent;
}
}
catch (Exception ex)
{
UnityEngine.Debug.LogError(ex.Message);
Disconnect();
return(false);
}
return(true);
}
public static byte[] Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
var decompressed = Conversion.DecompressBody(req.Body);
if (decompressed != null)
{
Initialize();
var readrequest = ReadRequest.Parser.ParseFrom(decompressed);
log.LogMetric("querycount", readrequest.Queries.Count, new Dictionary <String, object>()
{
{ "type", "count" }
});
ReadResponse response = CreateResponse(readrequest, log);
log.LogMetric("result", response.Results.Count, new Dictionary <String, object>()
{
{ "type", "count" }
});
log.LogMetric("timeseriesread", response.Results.Select(_ => _.Timeseries.Count).Sum(__ => __), new Dictionary <String, object>()
{
{ "type", "count" }
});
MemoryStream ms = new MemoryStream();
Google.Protobuf.CodedOutputStream output = new Google.Protobuf.CodedOutputStream(ms);
response.WriteTo(output);
output.Flush();
var resultUncompressed = ms.ToArray();
if (resultUncompressed.Length > 0)
{
//should be at least the size of the uncompressed one
byte[] resultCompressed = new byte[resultUncompressed.Length * 2];
var compressedSize = compressor.Compress(resultUncompressed, 0, resultUncompressed.Length, resultCompressed);
Array.Resize(ref resultCompressed, compressedSize);
return(resultCompressed);
}
else
{
return(resultUncompressed);
}
}
return(null);
}
async public Task send(Google.Protobuf.WellKnownTypes.Any any)
{
using (MemoryStream stream = new MemoryStream())
{
Google.Protobuf.CodedOutputStream s = new Google.Protobuf.CodedOutputStream(stream);
any.WriteTo(s);
s.Flush();
ArraySegment <byte> buffer = new ArraySegment <byte>(stream.ToArray());
await client.SendAsync(buffer, WebSocketMessageType.Binary, true, cancelActionToken);
}
}
public static byte[] SerializeProtoBuf3 <T>(T data) where T : Google.Protobuf.IMessage
{
using (MemoryStream rawOutput = new MemoryStream())
{
Google.Protobuf.CodedOutputStream output = new Google.Protobuf.CodedOutputStream(rawOutput);
//output.WriteRawVarint32((uint)len);
output.WriteMessage(data);
output.Flush();
byte[] result = rawOutput.ToArray();
return(result);
}
}
public static async Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequest req,
ILogger log)
{
var decompressed = HttpConversion.DecompressBody(req.Body);
if (decompressed != null)
{
InitializeKustoClient(log);
var readRequest = ReadRequest.Parser.ParseFrom(decompressed);
log.LogMetric("querycount", readRequest.Queries.Count,
new Dictionary<string, object>() { { "type", "count" } });
var response = CreateResponse(readRequest, log);
log.LogMetric("result", response.Results.Count, new Dictionary<string, object>() { { "type", "count" } });
log.LogMetric("timeseriesread", response.Results.Select(_ => _.Timeseries.Count).Sum(__ => __),
new Dictionary<string, object>() { { "type", "count" } });
var ms = new MemoryStream();
var output = new Google.Protobuf.CodedOutputStream(ms);
response.WriteTo(output);
output.Flush();
var resultUncompressed = ms.ToArray();
if (resultUncompressed.Length > 0)
{
// Should be at least the size of the uncompressed one
byte[] resultCompressed = new byte[resultUncompressed.Length * 2];
var compressedSize = Compressor.Compress(resultUncompressed, 0, resultUncompressed.Length,
resultCompressed);
Array.Resize(ref resultCompressed, compressedSize);
return new FileContentResult(resultCompressed, "application/x-protobuf");
}
else
{
return new FileContentResult(resultUncompressed, "application/x-protobuf");
}
}
return null;
} // - function Read
static void Main(string[] args)
{
var m1 = new Winner3Way(
new Outcome.Priced(1.85m),
new Outcome.PricedWithProb(3.3m, 0.33f),
new Outcome.Resulted(OutcomeResult.Canceled));
Console.WriteLine($"Orig: {m1}");
using var outputStream = new MemoryStream();
using var output = new Google.Protobuf.CodedOutputStream(outputStream);
m1.FromDomain().WriteTo(output);
output.Flush();
var bytes = outputStream.ToArray();
Console.WriteLine($"Protobuf Bytes Length={bytes.Length}, {BitConverter.ToString(bytes)}");
using var inputStream = new MemoryStream(bytes);
using var input = new Google.Protobuf.CodedInputStream(inputStream);
var protoCopy = new Domain.Protobuf.Winner3Way();
protoCopy.MergeFrom(input);
var copy = protoCopy.ToDomain();
Console.WriteLine($"Copy: {copy}");
using var jsonStream = new MemoryStream();
using var jsonWriter = new System.Text.Json.Utf8JsonWriter(jsonStream);
m1.WriteJson(jsonWriter);
jsonWriter.Flush();
var jsonString = Encoding.UTF8.GetString(jsonStream.ToArray());
Console.WriteLine($"Json {jsonString}");
var jsonDoc = System.Text.Json.JsonDocument.Parse(jsonString);
var jsonCopy = Json.ReadWinner3Way(jsonDoc.RootElement);
Console.WriteLine($"Json Copy: {jsonCopy}");
ComplexDomainDemo.Run();
}
/**
* Common logic for sending messages via protocol buffers.
*
* @param command
* @param message
* @param originator
* @param label
* @throws SiteWhereAgentException
*/
protected void sendMessage(Lib.SiteWhere.SiteWhere.Types.Command command, Google.Protobuf.IMessage message, String originator, String label)
{
System.IO.MemoryStream stream = new System.IO.MemoryStream();
Google.Protobuf.CodedOutputStream output = new Google.Protobuf.CodedOutputStream(stream);
try
{
Lib.SiteWhere.SiteWhere.Types.Header h = new SiteWhere.SiteWhere.Types.Header();
h.Command = command;
if (originator != null)
{
h.Originator = originator;
}
h.WriteTo(output);
message.WriteTo(output);
output.Flush();
//string s = "2,8,1,50,10,10,121,117,110,103,111,97,108,50,50,50,18,36,55,100,102,100,54,100,54,51,45,53,101,56,100,45,52,51,56,48,45,98,101,48,52,45,102,99,53,99,55,51,56,48,49,100,102,98";
//List<byte> bytes = new List<byte>();
//foreach(var b in s.Split(','))
//{
// byte br;
// if (int.Parse(b) < 0)
// br = (byte)(0xff & int.Parse(b));
// else
// br = byte.Parse(b);
// bytes.Add(br);
//}
//connection.Publish(getTopic(), bytes.ToArray(), MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE, false);
connection.Publish(getTopic(), stream.ToArray(), MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE, false);
output.Dispose();
}
catch (Exception e)
{
LOGGER.info(e.Message);
}
}
//public bool CryptoPackage<T>(T msg, Func<MemoryStream, MemoryStream, bool> func)
//{
// MemoryStream body = new MemoryStream();
// ProtoBuf.Serializer.Serialize(body, msg);
// UInt16 protobufLen = (ushort)body.Length;
// if (blowFishInst != null && protobufLen > 0)
// {
// body = blowFishInst.Encrypt_CBC(body);
// }
// UInt16 len = (ushort)body.Length;
// MemoryStream header = new MemoryStream(PacketHeader.Size);
// header.Write(BitConverter.GetBytes(len), 0, 2);
// header.Write(BitConverter.GetBytes(protobufLen), 0, 2);
// header.Write(BitConverter.GetBytes(Engine.Foundation.Id<T>.Value), 0, 4);
// return func(header, body);
//}
//public bool Package<T>(T msg, Func<MemoryStream, bool> func)
//{
// MemoryStream body = new MemoryStream();
// ProtoBuf.Serializer.Serialize(body, msg);
// UInt16 protobufLen = (ushort)body.Length;
// UInt16 len = (ushort)body.Length;
// //if (blowFishInst != null && protobufLen > 0)
// //{
// // body = blowFishInst.Encrypt_CBC(body);
// //}
// MemoryStream packet = new MemoryStream(PacketHeader.Size);
// packet.Write(BitConverter.GetBytes(len), 0, 2);
// packet.Write(BitConverter.GetBytes(protobufLen), 0, 2);
// packet.Write(BitConverter.GetBytes(Engine.Foundation.Id<T>.Value), 0, 4);
// packet.Write(body.GetBuffer(), 0, len);
// return func(packet);
//}
public bool Package1 <T>(T msg, Func <MemoryStream, bool> func, uint msgid) where T : Google.Protobuf.IMessage <T>
{
MemoryStream body = new MemoryStream();
Google.Protobuf.CodedOutputStream outbody = new Google.Protobuf.CodedOutputStream(body);
outbody.WriteGroup(msg);
outbody.Flush();
UInt16 protobufLen = (ushort)body.Length;
UInt16 len = (ushort)body.Length;
//if (blowFishInst != null && protobufLen > 0)
//{
// body = blowFishInst.Encrypt_CBC(body);
//}
MemoryStream packet = new MemoryStream(PacketHeader.Size);
packet.Write(BitConverter.GetBytes(len), 0, 2);
//packet.Write(BitConverter.GetBytes(protobufLen), 0, 2);
packet.Write(BitConverter.GetBytes(msgid), 0, 4);
packet.Write(body.GetBuffer(), 0, len);
return(func(packet));
}
private void ImportYarn(AssetImportContext ctx)
{
var sourceText = File.ReadAllText(ctx.assetPath);
string fileName = System.IO.Path.GetFileNameWithoutExtension(ctx.assetPath);
Yarn.Program compiledProgram = null;
IDictionary <string, Yarn.Compiler.StringInfo> stringTable = null;
compilationErrorMessage = null;
try
{
// Compile the source code into a compiled Yarn program (or
// generate a parse error)
compilationStatus = Yarn.Compiler.Compiler.CompileString(sourceText, fileName, out compiledProgram, out stringTable);
isSuccesfullyCompiled = true;
compilationErrorMessage = string.Empty;
}
catch (Yarn.Compiler.ParseException e)
{
isSuccesfullyCompiled = false;
compilationErrorMessage = e.Message;
ctx.LogImportError(e.Message);
}
// Create a container for storing the bytes
if (programContainer == null)
{
programContainer = ScriptableObject.CreateInstance <YarnProgram>();
}
byte[] compiledBytes = null;
if (compiledProgram != null)
{
using (var memoryStream = new MemoryStream())
using (var outputStream = new Google.Protobuf.CodedOutputStream(memoryStream))
{
// Serialize the compiled program to memory
compiledProgram.WriteTo(outputStream);
outputStream.Flush();
compiledBytes = memoryStream.ToArray();
}
}
programContainer.compiledProgram = compiledBytes;
// Add this container to the imported asset; it will be
// what the user interacts with in Unity
ctx.AddObjectToAsset("Program", programContainer, YarnEditorUtility.GetYarnDocumentIconTexture());
ctx.SetMainObject(programContainer);
if (stringTable?.Count > 0)
{
var lines = stringTable.Select(x => new StringTableEntry
{
ID = x.Key,
Language = baseLanguageID,
Text = x.Value.text,
File = x.Value.fileName,
Node = x.Value.nodeName,
LineNumber = x.Value.lineNumber.ToString(),
Lock = GetHashString(x.Value.text, 8),
}).OrderBy(entry => int.Parse(entry.LineNumber));
var stringTableCSV = StringTableEntry.CreateCSV(lines);
var textAsset = new TextAsset(stringTableCSV);
textAsset.name = $"{fileName} ({baseLanguageID})";
ctx.AddObjectToAsset("Strings", textAsset);
programContainer.baseLocalizationId = baseLanguageID;
baseLanguage = textAsset;
programContainer.localizations = localizations.Append(new YarnProgram.YarnTranslation(baseLanguageID, textAsset)).ToArray();
programContainer.baseLocalizationId = baseLanguageID;
stringIDs = lines.Select(l => l.ID).ToArray();
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
#if YARNSPINNER_DEBUG
UnityEngine.Profiling.Profiler.enabled = true;
#endif
var project = ScriptableObject.CreateInstance <YarnProject>();
project.name = Path.GetFileNameWithoutExtension(ctx.assetPath);
// Start by creating the asset - no matter what, we need to
// produce an asset, even if it doesn't contain valid Yarn
// bytecode, so that other assets don't lose their references.
ctx.AddObjectToAsset("Project", project);
ctx.SetMainObject(project);
foreach (var script in sourceScripts)
{
string path = AssetDatabase.GetAssetPath(script);
if (string.IsNullOrEmpty(path))
{
// This is, for some reason, not a valid script we can
// use. Don't add a dependency on it.
continue;
}
ctx.DependsOnSourceAsset(path);
}
// Parse declarations
var localDeclarationsCompileJob = CompilationJob.CreateFromFiles(ctx.assetPath);
localDeclarationsCompileJob.CompilationType = CompilationJob.Type.DeclarationsOnly;
IEnumerable <Declaration> localDeclarations;
compileError = null;
try
{
var result = Compiler.Compiler.Compile(localDeclarationsCompileJob);
localDeclarations = result.Declarations;
}
catch (ParseException e)
{
ctx.LogImportError($"Error in Yarn Project: {e.Message}");
compileError = $"Error in Yarn Project {ctx.assetPath}: {e.Message}";
return;
}
// Store these so that we can continue displaying them after
// this import step, in case there are compile errors later.
// We'll replace this with a more complete list later if
// compilation succeeds.
serializedDeclarations = localDeclarations
.Where(decl => decl.DeclarationType == Declaration.Type.Variable)
.Select(decl => new SerializedDeclaration(decl)).ToList();
// We're done processing this file - we've parsed it, and
// pulled any information out of it that we need to. Now to
// compile the scripts associated with this project.
var scriptImporters = sourceScripts.Where(s => s != null).Select(s => AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(s)) as YarnImporter);
// First step: check to see if there's any parse errors in the
// files.
var scriptsWithParseErrors = scriptImporters.Where(script => script.isSuccessfullyParsed == false);
if (scriptsWithParseErrors.Count() != 0)
{
// Parse errors! We can't continue.
string failingScriptNameList = string.Join("\n", scriptsWithParseErrors.Select(script => script.assetPath));
compileError = $"Parse errors exist in the following files:\n{failingScriptNameList}";
return;
}
// Get paths to the scripts we're importing, and also map them
// to their corresponding importer
var pathsToImporters = scriptImporters.ToDictionary(script => script.assetPath, script => script);
if (pathsToImporters.Count == 0)
{
return; // nothing further to do here
}
// We now now compile!
var job = CompilationJob.CreateFromFiles(pathsToImporters.Keys);
job.VariableDeclarations = localDeclarations;
CompilationResult compilationResult;
try
{
compilationResult = Compiler.Compiler.Compile(job);
}
catch (TypeException e)
{
ctx.LogImportError($"Error compiling: {e.Message}");
compileError = e.Message;
var importer = pathsToImporters[e.FileName];
importer.parseErrorMessage = e.Message;
EditorUtility.SetDirty(importer);
return;
}
catch (ParseException e)
{
ctx.LogImportError(e.Message);
compileError = e.Message;
var importer = pathsToImporters[e.FileName];
importer.parseErrorMessage = e.Message;
EditorUtility.SetDirty(importer);
return;
}
if (compilationResult.Program == null)
{
ctx.LogImportError("Internal error: Failed to compile: resulting program was null, but compiler did not throw a parse exception.");
return;
}
// Store _all_ declarations - both the ones in this
// .yarnproject file, and the ones inside the .yarn files
serializedDeclarations = localDeclarations
.Concat(compilationResult.Declarations)
.Where(decl => decl.DeclarationType == Declaration.Type.Variable)
.Select(decl => new SerializedDeclaration(decl)).ToList();
// Clear error messages from all scripts - they've all passed
// compilation
foreach (var importer in pathsToImporters.Values)
{
importer.parseErrorMessage = null;
}
// Will we need to create a default localization? This variable
// will be set to false if any of the languages we've
// configured in languagesToSourceAssets is the default
// language.
var shouldAddDefaultLocalization = true;
foreach (var pair in languagesToSourceAssets)
{
// Don't create a localization if the language ID was not
// provided
if (string.IsNullOrEmpty(pair.languageID))
{
Debug.LogWarning($"Not creating a localization for {project.name} because the language ID wasn't provided. Add the language ID to the localization in the Yarn Project's inspector.");
continue;
}
IEnumerable <StringTableEntry> stringTable;
// Where do we get our strings from? If it's the default
// language, we'll pull it from the scripts. If it's from
// any other source, we'll pull it from the CSVs.
if (pair.languageID == defaultLanguage)
{
// We'll use the program-supplied string table.
stringTable = GenerateStringsTable();
// We don't need to add a default localization.
shouldAddDefaultLocalization = false;
}
else
{
try
{
if (pair.stringsFile == null)
{
// We can't create this localization because we
// don't have any data for it.
Debug.LogWarning($"Not creating a localization for {pair.languageID} in the Yarn Project {project.name} because a text asset containing the strings wasn't found. Add a .csv file containing the translated lines to the Yarn Project's inspector.");
continue;
}
stringTable = StringTableEntry.ParseFromCSV(pair.stringsFile.text);
}
catch (System.ArgumentException e)
{
Debug.LogWarning($"Not creating a localization for {pair.languageID} in the Yarn Project {project.name} because an error was encountered during text parsing: {e}");
continue;
}
}
var newLocalization = ScriptableObject.CreateInstance <Localization>();
newLocalization.LocaleCode = pair.languageID;
newLocalization.AddLocalizedStrings(stringTable);
project.localizations.Add(newLocalization);
newLocalization.name = pair.languageID;
if (pair.assetsFolder != null)
{
var assetsFolderPath = AssetDatabase.GetAssetPath(pair.assetsFolder);
if (assetsFolderPath == null)
{
// This was somehow not a valid reference?
Debug.LogWarning($"Can't find assets for localization {pair.languageID} in {project.name} because a path for the provided assets folder couldn't be found.");
}
else
{
var stringIDsToAssets = FindAssetsForLineIDs(stringTable.Select(s => s.ID), assetsFolderPath);
#if YARNSPINNER_DEBUG
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
#endif
newLocalization.AddLocalizedObjects(stringIDsToAssets.AsEnumerable());
#if YARNSPINNER_DEBUG
stopwatch.Stop();
Debug.Log($"Imported {stringIDsToAssets.Count()} assets for {project.name} \"{pair.languageID}\" in {stopwatch.ElapsedMilliseconds}ms");
#endif
}
}
ctx.AddObjectToAsset("localization-" + pair.languageID, newLocalization);
if (pair.languageID == defaultLanguage)
{
// If this is our default language, set it as such
project.baseLocalization = newLocalization;
}
else
{
// This localization depends upon a source asset. Make
// this asset get re-imported if this source asset was
// modified
ctx.DependsOnSourceAsset(AssetDatabase.GetAssetPath(pair.stringsFile));
}
}
if (shouldAddDefaultLocalization)
{
// We didn't add a localization for the default language.
// Create one for it now.
var developmentLocalization = ScriptableObject.CreateInstance <Localization>();
developmentLocalization.LocaleCode = defaultLanguage;
var stringTableEntries = compilationResult.StringTable.Select(x => new StringTableEntry
{
ID = x.Key,
Language = defaultLanguage,
Text = x.Value.text,
File = x.Value.fileName,
Node = x.Value.nodeName,
LineNumber = x.Value.lineNumber.ToString(),
Lock = YarnImporter.GetHashString(x.Value.text, 8),
});
developmentLocalization.AddLocalizedStrings(stringTableEntries);
project.baseLocalization = developmentLocalization;
project.localizations.Add(project.baseLocalization);
developmentLocalization.name = $"Default ({defaultLanguage})";
ctx.AddObjectToAsset("default-language", developmentLocalization);
}
// Store the compiled program
byte[] compiledBytes = null;
using (var memoryStream = new MemoryStream())
using (var outputStream = new Google.Protobuf.CodedOutputStream(memoryStream))
{
// Serialize the compiled program to memory
compilationResult.Program.WriteTo(outputStream);
outputStream.Flush();
compiledBytes = memoryStream.ToArray();
}
project.compiledYarnProgram = compiledBytes;
#if YARNSPINNER_DEBUG
UnityEngine.Profiling.Profiler.enabled = false;
#endif
}