public JsonTcpCommunication(TcpClient socket)
: base(socket)
{
JsonResolverStrategy resolver = new JsonResolverStrategy();
_jsonIn = new JsonReader(new DataReaderSettings(resolver));
_jsonOut = new JsonWriter(new DataWriterSettings(new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.CamelCase)));
}
public static string DynamicToString(dynamic c)
{
JsonFx.Json.JsonWriter cJsonWriter = new JsonFx.Json.JsonWriter();
cJsonWriter.Settings.PrettyPrint = false;
return(cJsonWriter.Write(c));
}
public void SaveSettings(bool refresh = false)
{
if (refresh) GetSceneInfomation(false);
string apath = Application.dataPath.Replace("/Assets", "");
string ufile = Path.Combine(apath, "UnityBabylonOptions.ini");
var settings = new DataWriterSettings() { PrettyPrint = true };
var jsWriter = new JsonWriter(settings);
File.WriteAllText(ufile, jsWriter.Write(exportationOptions));
}
public IEncoder GetEncoder()
{
var jsonWriter = new JsonWriter(new DataWriterSettings(DefaultEncoderDecoderConfiguration.CombinedResolverStrategy()
, new TeamCityDateFilter()), new[] { "application/.*json", "text/.*json" });
var writers = new List<IDataWriter> { jsonWriter };
var dataWriterProvider = new RegExBasedDataWriterProvider(new List<IDataWriter> { jsonWriter });
return new DefaultEncoder(dataWriterProvider);
}
public override string Serialize <T>(T obj)
{
var w = new JsonFx.Json.JsonWriter();
var s = Environment.TickCount;
var r = w.Write(obj);
SerializeTimeList.Add(Environment.TickCount - s);
return(r);
}
protected override void Render(JsonWriter writer)
{
writer.TextWriter.Write(JbstPlaceholder.PlaceholderStatementStart);
writer.Write(JbstInline.InlinePrefix+this.NameExpr);
writer.TextWriter.Write(
JbstPlaceholder.PlaceholderStatementEndFormat,
this.DataExpr,
this.IndexExpr,
this.CountExpr);
}
public void Encode()
{
var id = new InstrumentData() { Pitch = 31, Roll = 89 };
var x = new JsonWriter();
var js = x.Write(id);
var y = new JsonReader();
var decoded = y.Read<InstrumentData>(js);
Assert.AreEqual(id.Roll, decoded.Roll);
Assert.AreEqual(id.Pitch, decoded.Pitch);
}
public Packet()
{
type = 0;
operation = 0;
output = new StringBuilder();
JsonWriterSettings settings = new JsonWriterSettings();
settings.PrettyPrint = false;
settings.AddTypeConverter (new VectorConverter());
settings.AddTypeConverter( new QuaternionConverter());
// TODO: Add any other TypeConverters here
writer = new JsonWriter (output,settings);
}
public void Write_StringArrayDefaults_SerializesArray()
{
var input = new string[]
{
"aaa",
"bbb"
};
var expected = @"[""aaa"",""bbb""]";
var actual = new JsonWriter().Write(input);
Assert.Equal(expected, actual);
}
/// <summary>
/// Serialize the specified message using either JSONFX or NEWTONSOFT.JSON.
/// The functionality is based on the pre-compiler flag
/// </summary>
/// <param name="message">Message.</param>
public static string Serialize(object message)
{
string retMessage;
#if (USE_JSONFX)
var writer = new JsonFx.Json.JsonWriter();
retMessage = writer.Write(message);
retMessage = ConvertHexToUnicodeChars(retMessage);
#else
retMessage = JsonConvert.SerializeObject(message);
#endif
return(retMessage);
}
public void WriteToBabylonFile()
{
babylonScene.Prepare();
var outputFile = Path.Combine(OutputPath, SceneName + ".babylon");
var jsWriter = new JsonWriter(new DataWriterSettings(new DataContractResolverStrategy()));
string babylonJSformat = jsWriter.Write(babylonScene);
using (var sw = new StreamWriter(outputFile))
{
sw.Write(babylonJSformat);
sw.Close();
}
}
public void Write_OnlyDefaults_SerializesIso8601Dates()
{
var input = new object[]
{
"Normal string before",
new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc),
new DateTime(2010, 7, 5, 10, 51, 17, 768, DateTimeKind.Unspecified),
"Normal string after"
};
var expected = @"[""Normal string before"",""2008-02-29T23:59:59.999Z"",""2010-07-05T10:51:17.768"",""Normal string after""]";
var actual = new JsonWriter().Write(input);
Assert.Equal(expected, actual);
}
public static string ToBase64Json(string code, string name = null)
{
var program = new Program
{
AuthorId = GetWindowsLiveAnonymousId(),
Name = name ?? string.Empty,
Code = Convert.ToBase64String(Encoding.UTF8.GetBytes(code))
};
program.Hash = Program.CreateHash(program);
var writer =
new JsonWriter(
new DataWriterSettings(
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.PascalCase)));
return writer.Write(program);
}
public void SetProjectParameters(Action<IBuildProjectHavingBuilder> having, Action<IBuildParameterValueBuilder> parameters)
{
var buildConfigurationHavingBuilder = m_BuildProjectHavingBuilderFactory.CreateBuildProjectHavingBuilder();
having(buildConfigurationHavingBuilder);
var projectLocator = buildConfigurationHavingBuilder.GetLocator();
var writer = new JsonWriter(new DataWriterSettings(new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.CamelCase)));
BuildParameterValueBuilder buildParameterValueBuilder = new BuildParameterValueBuilder();
parameters(buildParameterValueBuilder);
buildParameterValueBuilder.GetParameters()
.ForEach(p => m_TeamCityCaller.PutFormat(writer.Write(p), HttpContentTypes.ApplicationJson,
"/app/rest/projects/{0}/parameters/{1}", projectLocator, p.Name));
}
public IEncoder GetEncoder()
{
var jsonWriter = new JsonWriter(new DataWriterSettings(CombinedResolverStrategy()),
new[] {"application/.*json", "text/.*json"});
var xmlWriter = new XmlWriter(new DataWriterSettings(CombinedResolverStrategy()),
new[] {"application/xml", "text/.*xhtml", "text/xml", "text/html"});
var urlEncoderWriter = new UrlEncoderWriter(new DataWriterSettings(CombinedResolverStrategy()),
new[] {"application/x-www-form-urlencoded"});
var writers = new List<IDataWriter> { jsonWriter, xmlWriter, urlEncoderWriter };
var dataWriterProvider = new RegExBasedDataWriterProvider(writers);
return new DefaultEncoder(dataWriterProvider);
}
/// <summary>
/// Method to write all not-yet-translated keys as well as already translated ones to a file for translation.
/// </summary>
public static void WriteTranslationsToFile(Dictionary <string, string> translationsToWrite)
{
#if UNITY_EDITOR
if (translationsToWrite == null)
{
log.Error(_Logger.User.Msaw, "WriteTranslationsToFile() failed because given translationsToWrite was null. Not writing anything.");
return;
}
DictHolder dh = new DictHolder();
dh.Translations = translationsToWrite;
using (System.IO.StreamWriter singleProfileFile = new System.IO.StreamWriter(CurrentLanguageFileResources, false, new UTF8Encoding(false)))
{
#if removeJsonFX
System.Text.StringBuilder jsonLine = new System.Text.StringBuilder();
JsonFx.Json.JsonWriter writer = new JsonFx.Json.JsonWriter(jsonLine);
writer.Write(dh);
singleProfileFile.WriteLine(jsonLine.ToString());
#else
StringBuilder sb = new StringBuilder(translationsToWrite.Count * 80); // assumption
sb.Append("{\n \"Translations\": {\n");
bool firstLine = true;
foreach (KeyValuePair <string, string> kvp in translationsToWrite.OrderBy(o => o.Key))
{
if (firstLine == false)
{
sb.Append(",\n");
}
sb.Append(" \"");
sb.Append(kvp.Key);
sb.Append("\": \"");
sb.Append(kvp.Value.Replace("\n", "\\n").Replace("\"", "\\\""));
sb.Append("\"");
firstLine = false;
}
sb.Append("\n }\n}");
if (log.IsDebugEnabled)
{
log.Debug(_Logger.User.Msaw, "Writing loca to " + CurrentLanguageFileResources + ": " + sb.ToString());
}
singleProfileFile.WriteLine(sb.ToString());
#endif
}
#endif
}
public static string SerializeToString <T>(object type)
{
try
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
JsonFx.Json.JsonWriter writer = new JsonFx.Json.JsonWriter(output, writesettings);
writer.Write((T)type);
return(output.ToString());
}
catch
{
Debug.Log("SerializeToString Exception");
return(string.Empty);
}
}
public void ReportError(Exception ex)
{
var report = new ErrorReport {Text = ex.ToString().Base64Encode()};
report.Hash = ErrorReport.CreateHash(report);
var writer =
new JsonWriter(
new DataWriterSettings(
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.PascalCase)));
var json = writer.Write(report);
var webClient = new WebClient();
webClient.Headers[HttpRequestHeader.ContentType] = "application/json";
webClient.Headers[HttpRequestHeader.Accept] = "application/json";
Uri address = UriFactory.Create("exceptions/report");
webClient.UploadStringCompleted += UploadStringCompleted;
webClient.UploadStringAsync(address, json);
}
public static void SerializeToJson <T>(string pathfile, object type)
{
try
{
System.Text.StringBuilder output = new System.Text.StringBuilder();
JsonFx.Json.JsonWriter writer = new JsonFx.Json.JsonWriter(output, writesettings);
writer.Write((T)type);
//File.WriteAllText(pathfile, output.ToString());
}
catch (Exception ex1)
{
Debug.Log(ex1.InnerException.Message);// .printStackTrace();
}
catch
{
Debug.Log("SerializeToJson Exception");
}
}
public static string SerializeUsingJSONFx (object message)
{
string retMessage;
var writer = new JsonFx.Json.JsonWriter ();
retMessage = writer.Write (message);
retMessage = ConvertHexToUnicodeChars (retMessage);
/*StringBuilder builder = new StringBuilder();
using (TextWriter textWriter = new EncodingStringWriter(builder, Encoding.UTF8))
{
var writer = new JsonFx.Json.JsonWriter ();
writer.Write (message, textWriter);
return PubnubCryptoBase.ConvertHexToUnicodeChars("");
}*/
return retMessage;
}
/// <summary>
/// Serialize the specified message using either JSONFX or NEWTONSOFT.JSON.
/// The functionality is based on the pre-compiler flag
/// </summary>
/// <param name="message">Message.</param>
public static string Serialize(object message)
{
string retMessage;
#if (USE_JSONFX) || (USE_JSONFX_UNITY)
var writer = new JsonFx.Json.JsonWriter();
retMessage = writer.Write(message);
retMessage = ConvertHexToUnicodeChars(retMessage);
#elif (USE_JSONFX_UNITY_IOS)
retMessage = JsonWriter.Serialize(message);
retMessage = ConvertHexToUnicodeChars(retMessage);
#elif (USE_MiniJSON)
retMessage = Json.Serialize(message);
UnityEngine.Debug.Log("retMessage: " + retMessage);
#else
retMessage = JsonConvert.SerializeObject(message);
#endif
return(retMessage);
}
public void WriteToBabylonFile(string outputFile)
{
ExporterWindow.ReportProgress(1, "Preparing babylon scene file...");
babylonScene.Prepare(false);
if (SceneController != null && SceneController.manifestOptions.exportManifest)
{
if (!String.IsNullOrEmpty(this.ManifestData))
{
var manifestFile = outputFile + ".manifest";
File.WriteAllText(manifestFile, this.ManifestData);
}
}
ExporterWindow.ReportProgress(1, "Serializing babylon scene file... This may take a while.");
using (var file = File.CreateText(outputFile))
{
var settings = new DataWriterSettings(new BabylonSceneContractResolver()) { PrettyPrint = true };
var jsWriter = new JsonWriter(settings);
jsWriter.Write(babylonScene, file);
}
}
/// <summary>
/// Serialize the specified message using either JSONFX or NEWTONSOFT.JSON.
/// The functionality is based on the pre-compiler flag
/// </summary>
/// <param name="message">Message.</param>
public static string Serialize (object message)
{
string retMessage;
#if (USE_JSONFX)
//var resolver = new JsonFx.Serialization.Resolvers.CombinedResolverStrategy(new JsonFx.Serialization.Resolvers.DataContractResolverStrategy());
//JsonFx.Serialization.DataWriterSettings dataWriterSettings = new JsonFx.Serialization.DataWriterSettings(resolver);
/*byte[] b = ObjectToByteArray(message);
char[] c = System.Text.Encoding.Unicode.GetString(b).ToCharArray();
string str = new string(c);
StringInfo stri = new StringInfo(str);
Console.WriteLine("str:" + stri.String);*/
var writer = new JsonFx.Json.JsonWriter();
retMessage = writer.Write(message);
retMessage = ConvertHexToUnicodeChars(retMessage);
/*var readerSettings = new JsonFx.Serialization.DataReaderSettings();
JsonFx.Serialization.DataWriterSettings dataWriterSettings = new JsonFx.Serialization.DataWriterSettings(readerSettings);
var writer = new JsonFx.Json.JsonWriter(dataWriterSettings);
retMessage = writer.Write(message);
retMessage = ConvertHexToUnicodeChars(retMessage);*/
/*StringBuilder builder = new StringBuilder();
//using (TextWriter textWriter = new EncodingStringWriter(builder, Encoding.Unicode))
//{
//var readerSettings = new JsonFx.Serialization.DataReaderSettings();
//JsonFx.Serialization.DataWriterSettings dataWriterSettings = new JsonFx.Serialization.DataWriterSettings(readerSettings);
TextWriter textWriter = new EncodingStringWriter(builder, Encoding.UTF8);
var writer = new JsonFx.Json.JsonWriter ();
writer.Write (message, textWriter);
return PubnubCryptoBase.ConvertHexToUnicodeChars(builder.ToString());*/
//}
#else
retMessage = JsonConvert.SerializeObject (message);
#endif
return retMessage;
}
/// <summary>
/// Controls the control rendering style
/// </summary>
/// <param name="writer"></param>
protected override void Render(JsonWriter writer)
{
if (!this.ChildControlsSpecified)
{
if (String.IsNullOrEmpty(this.NameExpr))
{
throw new InvalidOperationException("jbst:Control requires either a named template or anonymous inline template.");
}
// name without child controls
this.RenderSimpleControlReference(writer);
}
else if (String.IsNullOrEmpty(this.NameExpr))
{
// anonymous with child controls
this.RenderAnonymousTemplate(writer);
}
else
{
// both name and child controls
this.RenderWrapperControlReference(writer);
}
}
void IJsonSerializable.WriteJson(JsonWriter writer)
{
if (this.NormalizeWhitespace)
{
writer.Write(this.NormalizedText);
}
else
{
writer.Write(this.Text);
}
}
public void Write(TextWriter w)
{
JsonWriter jsw = new JsonWriter();
jsw.Write(Operations, w);
}
public void Write_RecognizesMultipleDateTimeFiltersIsoFirst_SerializesIso8601Dates()
{
var input = new object[]
{
"Normal string before",
new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc),
new DateTime(2010, 7, 5, 10, 51, 17, 768, DateTimeKind.Utc),
"Normal string after"
};
var expected = @"[""Normal string before"",""2008-02-29T23:59:59.999Z"",""2010-07-05T10:51:17.768Z"",""Normal string after""]";
var writer = new JsonWriter(
new DataWriterSettings(new Iso8601DateFilter(), new MSAjaxDateFilter()));
var actual = writer.Write(input);
Assert.Equal(expected, actual);
}
static void DateSerializer(JsonFx.Json.JsonWriter writer, DateTime value)
{
writer.Write(new EJSON.EJSONDate(value));
}
public void GetTokens_MultipleConventions_ReturnsData()
{
var input = new CustomNamedObject
{
UpperPropertyName = "Foo.",
OtherPropertyName = "Bar."
};
var expected = "{\"upperPropertyName\":\"Foo.\",\"arbitraryOther\":\"Bar.\"}";
var resolver = new CombinedResolverStrategy(
new JsonResolverStrategy(),
new DataContractResolverStrategy(),
new XmlResolverStrategy(),
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.PascalCase),
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.CamelCase),
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.Lowercase, "-"),
new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.Uppercase, "_"));
var actual = new JsonWriter(new DataWriterSettings(resolver)).Write(input);
Assert.Equal(expected, actual, false);
}
/// <summary>
/// Renders a simple data binding call to a named template.
/// </summary>
/// <param name="writer"></param>
private void RenderSimpleControlReference(JsonWriter writer)
{
writer.TextWriter.Write(
JbstControlReference.SimpleReferenceFormat,
this.NameExpr,
this.DataExpr,
this.IndexExpr,
this.CountExpr);
}
public void Write_RecognizesMultipleDateTimeFiltersAjaxFirst_SerializesMSAjaxDates()
{
var input = new object[]
{
"Normal string before",
new DateTime(2008, 2, 29, 23, 59, 59, 999, DateTimeKind.Utc),
new DateTime(2010, 7, 5, 10, 51, 17, 768, DateTimeKind.Utc),
"Normal string after"
};
var expected = @"[""Normal string before"",""/Date(1204329599999)/"",""/Date(1278327077768)/"",""Normal string after""]";
var writer = new JsonWriter(
new DataWriterSettings(new MSAjaxDateFilter(), new Iso8601DateFilter()));
var actual = writer.Write(input);
Assert.Equal(expected, actual);
}
public override string ToString()
{
dynamic[] lines = new dynamic[intlines.Count];
int i = 0;
foreach (var lf in intlines)
{
lines[i] = new {
id = lf.id, line = new int[]
{
lf.line.p.X, lf.line.p.Y,
lf.line.q.X, lf.line.q.Y
}
};
i++;
}
var settings = new JsonFx.Serialization.DataWriterSettings();
settings.PrettyPrint = true;
var writer = new JsonWriter(settings);
var output = new { imagefile = imagefile, intlines = lines };
return writer.Write(output);
}
public void QueryArrayItems_OrderByThenByLast_ReturnsMultipleObjects()
{
// use convention over configuration on the way out
var reader = new JsonReader(new DataReaderSettings(new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.CamelCase)));
// use POCO on the way out
var writer = new JsonWriter(new DataWriterSettings() { PrettyPrint=true });
string input =
@"[
{ ""personId"": 1, ""firstName"": ""Sally"", ""lastName"": ""Smith"" },
{ ""personId"": 2, ""firstName"": ""Bob"", ""lastName"": ""Smith"" },
{ ""personId"": 3, ""firstName"": ""John"", ""lastName"": ""Jones"" },
{ ""personId"": 4, ""firstName"": ""Suzie"", ""lastName"": ""Jones"" }
]";
var people = reader.Query<Person>(input);
var query =
from person in people.ArrayItems()
orderby person.LastName, person.FirstName
select person.PersonID;
Assert.Equal(1, query.Last());
const string expected =
@"[
3,
4,
2,
1
]";
string actual = writer.Write(query);
Assert.Equal(expected, actual);
}
public void QueryDescendants_WhereOrderByLast_ReturnsMultipleObjects()
{
// respect DataContracts on the way in
var reader = new JsonReader(new DataReaderSettings(new DataContractResolverStrategy()));
// use convention over configuration on the way out
var writer = new JsonWriter(new DataWriterSettings(new ConventionResolverStrategy(ConventionResolverStrategy.WordCasing.Lowercase, "-")));
string input =
@"[
{ ""id"": 1, ""first"": ""Foo"", ""last"": ""Bar"" },
{ ""id"": 2, ""first"": ""etc."", ""last"": ""et al."" },
{ ""id"": 3, ""first"": ""Blah"", ""last"": ""Yada"" }
]";
var people = reader.Query<Person>(input);
var query =
from person in people.Descendants()
where person.PersonID == 1 || person.FirstName == "Blah"
orderby person.PersonID
select person;
Assert.Equal("Yada", query.Last().LastName);
const string expected = @"[{""person-id"":1,""first-name"":""Foo"",""last-name"":""Bar""},{""person-id"":3,""first-name"":""Blah"",""last-name"":""Yada""}]";
string actual = writer.Write(query);
Assert.Equal(expected, actual);
}
// example: https://github.com/numenta/grok-js-ua/blob/master/hello-grok/apiProxy.js
public void ProcessRequest(HttpContext context)
{
dynamic proxyData;
using (var inputReader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
{
//proxyData = Json.Decode(inputReader.ReadToEnd());
var reader = new JsonFx.Json.JsonReader();
proxyData = reader.Read(inputReader);
//var serializer = new DataContractJsonSerializer(typeof(ProxyBody));
//var proxyData = (ProxyBody)serializer.ReadObject(context.Request.InputStream);
}
string endpoint = proxyData.proxy.endpoint;
bool hasData = ((System.Collections.Generic.IDictionary<String, Object>)proxyData.proxy).ContainsKey("data");
// write the request data
if (hasData && proxyData.proxy.method=="GET")
{
var ub = new UriBuilder(endpoint);
var queryString = HttpUtility.ParseQueryString(ub.Query);
foreach (var dataItem in ((System.Collections.Generic.IDictionary<String, Object>)proxyData.proxy.data))
{
if (dataItem.Value == null) continue;
queryString.Add(dataItem.Key, dataItem.Value.ToString());
}
ub.Query = queryString.ToString();
endpoint = ub.Uri.AbsoluteUri;
}
var request = WebRequest.CreateHttp(endpoint);
request.Method = proxyData.proxy.method;
request.Headers.Add(
HttpRequestHeader.ContentEncoding,
"UTF8");
request.Headers.Add(
HttpRequestHeader.Authorization,
GenerateBasicAuthenticationValue(username: proxyData.apiKey, password: string.Empty));
try
{
// write the request data
if (hasData && proxyData.proxy.method != "GET")
{
using (var dataWriter = new StreamWriter(request.GetRequestStream(), new UTF8Encoding(false)))
{
var writer = new JsonFx.Json.JsonWriter();
writer.Write(proxyData.proxy.data, dataWriter);
}
}
// read the response
var response = (HttpWebResponse) request.GetResponse();
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.Headers.Add("Content-Encoding", response.ContentEncoding);
byte[] buffer = new byte[ushort.MaxValue];
using (var responseStream = response.GetResponseStream())
{
int r;
while((r = responseStream.Read(buffer, 0, buffer.Length)) != 0)
{
context.Response.OutputStream.Write(buffer, 0, r);
}
}
return;
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.ProtocolError)
{
context.Response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
return;
}
var httpResponse = (HttpWebResponse)ex.Response;
context.Response.StatusCode = (int)httpResponse.StatusCode;
return;
}
}
/// <summary>
/// Renders a data binding call to a named template with a nested inline anonymous placeholder template.
/// </summary>
/// <param name="writer"></param>
private void RenderWrapperControlReference(JsonWriter writer)
{
writer.TextWriter.Write(
JbstControlReference.ControlWrapperStartFormat,
this.NameExpr,
this.DataExpr,
this.IndexExpr,
this.CountExpr);
Dictionary<string, object> args = new Dictionary<string, object>();
if (this.ChildControls.HasAnonymousInlineTemplate)
{
// anonymous inline template
args[JbstInline.InlinePrefix] = new EnumerableAdapter(this);
}
if (this.ChildControls.InlineTemplatesSpecified)
{
// named inline templates
foreach (JbstInline inline in this.ChildControls.InlineTemplates)
{
args[JbstInline.InlinePrefix+inline.NameExpr] = new EnumerableAdapter(inline);
}
}
writer.Write(args);
writer.TextWriter.Write(JbstControlReference.ControlWrapperEnd);
}
public void Write_ObjectContainingEnum_SerializesObject()
{
var input = new Foo { Baz = Bar.First };
var expected = "{\"Baz\":\"First\"}";
var actual = new JsonWriter().Write(input);
Assert.Equal(expected, actual);
}
static void ByteArraySerializer(JsonFx.Json.JsonWriter writer, byte[] value)
{
writer.Write(new EJSON.EJSONUInt8Array(value));
}
/// <summary>
/// Renders a data binding call to an inline anonymous template.
/// </summary>
/// <param name="writer"></param>
private void RenderAnonymousTemplate(JsonWriter writer)
{
writer.TextWriter.Write(JbstControlReference.InlineTemplateStart);
writer.Write(new EnumerableAdapter(this));
writer.TextWriter.Write(
JbstControlReference.InlineTemplateEndFormat,
this.DataExpr,
this.IndexExpr,
this.CountExpr);
}
/// <summary>
/// A helper method for serializing an object to JSON
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string Serialize(object value)
{
StringBuilder output = new StringBuilder();
using (JsonWriter writer = new JsonWriter(output))
{
writer.Write(value);
}
return output.ToString();
}
public void Export(bool run)
{
try
{
string sceneName = SceneManager.GetActiveScene().name;
exportationOptions.DefaultFolder = EditorUtility.SaveFolderPanel("Please select a folder", exportationOptions.DefaultFolder, "");
if (string.IsNullOrEmpty(exportationOptions.DefaultFolder))
{
return;
}
Stopwatch watch = new Stopwatch();
watch.Start();
var jsWriter = new JsonWriter();
File.WriteAllText("Unity3D2Babylon.ini", jsWriter.Write(exportationOptions));
logs.Clear();
ReportProgress(0);
var sceneBuilder = new SceneBuilder(exportationOptions.DefaultFolder, sceneName, exportationOptions);
sceneBuilder.ConvertFromUnity();
ReportProgress(1, "Generating output file");
var outputFile = sceneBuilder.WriteToBabylonFile();
watch.Stop();
ReportProgress(1, string.Format("Exportation done in {0:0.00}s", watch.Elapsed.TotalSeconds));
EditorUtility.ClearProgressBar();
sceneBuilder.GenerateStatus(logs);
ShowMessage("Exportation done");
if (run)
{
WebServer.SceneFolder = Path.GetDirectoryName(outputFile);
WebServer.SceneFilename = Path.GetFileName(outputFile);
Process.Start("http://localhost:" + WebServer.Port);
}
}
catch (Exception ex)
{
EditorUtility.ClearProgressBar();
ShowMessage("A problem occurred: " + ex.Message + ex.StackTrace, "Error");
}
}
