public bool StartsWith(UnicodeScalar unicodeScalar)
{
Span <char> span = stackalloc char[unicodeScalar.Utf16CodeUnitCount];
unicodeScalar.CopyUtf16CodeUnitsTo(span);
return(RawString.AsSpan().StartsWith(span, StringComparison.Ordinal));
}
public static void GetFromDisk()
{
List <Teacher> Desearlize(string RawString)
{
string[] inputs = RawString.Split(new char[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (inputs.Length != 1 + (int.Parse(inputs[0]) * Teacher.NoOfParametres))
{
throw new Exception();
}
List <Teacher> _output = new List <Teacher>();
for (int CurrentIndex = 1; CurrentIndex < inputs.Length; CurrentIndex += Teacher.NoOfParametres)
{
_output.Add(new Teacher(RawString, CurrentIndex));
}
return(_output);
}
string output = Task.Run(async() =>
{
return(await FileIO.ReadTextAsync(
await ApplicationData.Current.LocalFolder.GetFileAsync(
@"Database\Teachers")));
}).Result;
string[] lists = output.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < 7; ++i)
{
TeachersList[i] = Desearlize(lists[i]);
}
}
public Utf16SharedString PadRight(int totalWidth, UnicodeScalar paddingScalar)
{
if (totalWidth <= Length)
{
return(this);
}
int paddingScalarWidth = paddingScalar.Utf16CodeUnitCount;
int insertScalarCount = (totalWidth - Length) / paddingScalarWidth;
int paddedLength = Length + insertScalarCount * paddingScalarWidth;
Span <char> paddingSpan = stackalloc char[paddingScalarWidth];
paddingScalar.CopyUtf16CodeUnitsTo(paddingSpan);
Span <char> span = paddedLength <= maxStackallocSize ? stackalloc char[paddedLength] : new char[paddedLength];
RawString.AsSpan().CopyTo(span);
for (int i = Length; i < paddedLength; i += paddingScalarWidth)
{
for (int j = 0; j < paddingScalarWidth; j++)
{
span[i + j] = paddingSpan[j];
}
}
return(new Utf16SharedString(new string(span.ToArray()), Spans));
}
public void String_Can_Be_Null()
{
var raw = new RawString(null);
Assert.NotNull(raw);
Assert.Equal(raw.Value, string.Empty);
}
public int IndexOf(UnicodeScalar unicodeScalar)
{
Span <char> span = stackalloc char[unicodeScalar.Utf16CodeUnitCount];
unicodeScalar.CopyUtf16CodeUnitsTo(span);
return(RawString.AsSpan().IndexOf(span, StringComparison.Ordinal));
}
public NullModel(FbxNode node)
{
Debug.Assert(node.Properties[2].AsString().ToModelType() == ModelType.Null);
Node = node;
ID = node.Properties[0].AsInt64();
Name = node.Properties[1].AsString();
}
protected void Compress()
{
char[] chars = RawString.ToCharArray();
StringBuilder builder = new StringBuilder();
int count = 1;
char previous = chars[0];
for (int i = 1; i < chars.Length; i++)
{
char current = chars[i];
if (current == previous)
{
count++;
}
else
{
if (count > 1)
{
builder.Append(count);
}
builder.Append(previous);
count = 1;
}
previous = current;
}
if (count > 1)
{
builder.Append(count);
}
CompressedString = builder.Append(previous).ToString();
}
public static IEncodedString Link(this ResourceTemplateHelper helper, string path, string contentId, string mediaType,
TransferEncoding transferEncoding, CultureInfo culture = null)
{
Contract.Requires <ArgumentNullException>(helper != null);
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(path));
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(contentId));
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(mediaType));
var resource = helper.Get(path, culture);
if (resource == null)
{
var message = string.Format("Resource [{0}] was not found.", contentId);
throw new TemplateHelperException(message);
}
var linkedResource = new LinkedResource(resource, mediaType)
{
TransferEncoding = transferEncoding
};
helper.AddLinkedResource(linkedResource);
var renderedResult = new RawString(string.Format("cid:{0}", contentId));
return(renderedResult);
}
public unsafe void RawStringSlice()
{
const int memLen = 5;
var mem = stackalloc byte[memLen]
{
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e',
};
var abcde = new RawString((IntPtr)mem, memLen);
var abc = new RawString((IntPtr)mem, 3);
var cd = new RawString((IntPtr)(mem + 2), 2);
var de = new RawString((IntPtr)(mem + 3), 2);
AssertEqual(abcde.Slice(0, abcde.Length), abcde);
AssertEqual(abcde.Slice(0, 3), abc);
AssertEqual(abcde.Slice(2, 2), cd);
AssertEqual(abcde.Slice(3, 2), de);
AssertEqual(abcde.Slice(3), de);
AssertEqual(abcde.Slice(0), abcde);
Assert.True(abcde.Slice(5).IsEmpty);
Assert.True(abcde.Slice(5, 0).IsEmpty);
AssertEqual(abcde.AsSpan(0, abcde.Length), abcde);
AssertEqual(abcde.AsSpan(0, 3), abc);
AssertEqual(abcde.AsSpan(2, 2), cd);
AssertEqual(abcde.AsSpan(3, 2), de);
AssertEqual(abcde.AsSpan(3), de);
AssertEqual(abcde.AsSpan(0), abcde);
Assert.True(abcde.AsSpan(5).IsEmpty);
Assert.True(abcde.AsSpan(5, 0).IsEmpty);
}
/// <summary>
/// Begins a new statement.
/// </summary>
/// <param name="command">The initial command to emit.</param>
/// <returns>The created statement emitter.</returns>
public StatementEmitter BeginStatement(RawString command)
{
var emitter = new StatementEmitter(this);
emitter.AppendCommand(command.Value);
return(emitter);
}
public async Task Connect()
{
Protocol = new Protocol(true);
socket = new Websocket(Receive);
ApiToken = await FFB.Instance.Api.GetToken();
try
{
string uri = "ws://fumbbl.com:22223/command";
//string uri = "ws://localhost:22227/command";
await Task.Delay(100);
LogManager.Info($"Networking Connecting to {uri}");
MainHandler.Instance.AddReport(RawString.Create($"Connecting to {uri}"));
await socket.Connect(uri);
LogManager.Debug("Networking Connected");
RequestVersion();
}
catch (Exception e)
{
LogManager.Error($"<style=\"Error\">Error connecting: {e.Message}</style>");
MainHandler.Instance.AddReport(RawString.Create($"<style=\"Error\">Error connecting: {e.Message}</style>"));
}
}
public int LastIndexOf(UnicodeScalar unicodeScalar, int startIndex, int count)
{
Span <char> span = stackalloc char[unicodeScalar.Utf16CodeUnitCount];
unicodeScalar.CopyUtf16CodeUnitsTo(span);
return(RawString.AsSpan().Slice(startIndex, count).LastIndexOf(span));
}
public SkinDeformer(FbxNode skinDeformerNode)
{
#if DEBUG
Debug.Assert(skinDeformerNode.Properties[2].AsString() == "Skin");
#endif
ID = skinDeformerNode.Properties[0].AsInt64();
Name = skinDeformerNode.Properties[1].AsString();
}
public void ValueProperty_ReturnsValue()
{
string value = "value";
var raw = new RawString(value);
Assert.Equal(value, raw.Value);
}
public void TextWriter_Can_Not_Be_Null()
{
TextWriter writer = null;
var raw = new RawString("value");
Assert.Throws <ArgumentNullException>(() => { raw.WriteTo(writer); });
}
public static RawString PlayerList(List <PlayerInfo> players)
{
var links = players.Select(player => GetPlayerLink(player).ToString());
string markup = string.Join(", ", links);
var rawString = new RawString(markup);
return(rawString);
}
public Utf16SharedString PadRight(int totalWidth)
{
if (totalWidth <= Length)
{
return(this);
}
return(new Utf16SharedString(RawString.PadRight(totalWidth), Spans));
}
public Utf16SharedString PadLeft(int totalWidth)
{
if (totalWidth <= Length)
{
return(this);
}
return(new Utf16SharedString(RawString.PadLeft(totalWidth), swipeSpan(totalWidth - Length)));
}
public override int GetHashCode()
{
var hash = GetType().GetHashCode();
hash ^= Start.GetHashCode();
hash ^= RawString.GetHashCode();
hash ^= Number.GetHashCode();
return(hash);
}
public ClusterDeformer(FbxNode clusterDeformerNode)
{
#if DEBUG
Debug.Assert(clusterDeformerNode.Properties[2].AsString() == "Cluster");
#endif
_node = clusterDeformerNode;
ID = clusterDeformerNode.Properties[0].AsInt64();
Name = clusterDeformerNode.Properties[1].AsString();
}
private Utf16SharedString trimResult(ReadOnlySpan <char> trimedSpan)
{
if (trimedSpan.IsEmpty)
{
return(Empty);
}
int startIndex = RawString.IndexOf(trimedSpan[0]);
return(new Utf16SharedString(new string(trimedSpan.ToArray()), sliceSpan(startIndex, trimedSpan.Length)));
}
private void BindData()
{
string[] info = RawString.Split(",".ToCharArray());
string[] OutputColumninfo = info[0].Split("|".ToCharArray());
string[] InputColumninfo = info[1].Split("|".ToCharArray());
InputColumn = InputColumninfo[0];
OutputDataType = (AttributeTypes)int.Parse(OutputColumninfo[1]);
OutputColumn = OutputColumninfo[0];
}
public static int LastIndexOf(this RawString str, byte c)
{
for (int i = str.Length - 1; i >= 0; i--)
{
if (str[i] == c)
{
return(i);
}
}
return(-1);
}
public static bool Contains(this RawString rawString, byte c)
{
foreach (var x in rawString.AsSpan())
{
if (x == c)
{
return(true);
}
}
return(false);
}
private void DebugClicked(ClickEvent ev)
{
FFB.Instance.Model.HomeCoach = new Coach()
{
Name = "Foo",
IsHome = true
};
FFB.Instance.Model.AwayCoach = new Coach()
{
Name = "Bar",
IsHome = false
};
ev.StopPropagation();
var pos = new Fumbbl.Model.Types.Position();
pos.IconURL = "i/585610";
pos.PortraitURL = "i/318621";
Player p = new Player();
p.Position = pos;
p.Id = "Debug Player " + UnityEngine.Random.Range(1, 1000);
p.Coordinate = new Coordinate(UnityEngine.Random.Range(1, 25), UnityEngine.Random.Range(1, 14));
p.PlayerState = PlayerState.Get(UnityEngine.Random.Range(1, 5));
FFB.Instance.Model.Add(p);
var trackNumber = new TrackNumber()
{
Coordinate = new Coordinate(UnityEngine.Random.Range(1, 25), UnityEngine.Random.Range(1, 14)),
Number = UnityEngine.Random.Range(1, 10)
};
FFB.Instance.Model.Add(trackNumber);
var pushbackSquare = new PushbackSquare()
{
Coordinate = new Coordinate(UnityEngine.Random.Range(1, 25), UnityEngine.Random.Range(1, 14)),
Direction = "West"
};
FFB.Instance.Model.Add(pushbackSquare);
FFB.Instance.Model.ActingPlayer.PlayerId = p.Id;
for (int i = 0; i < 20; i++)
{
FFB.Instance.AddReport(RawString.Create($"<b>* * * Test message {i} * * *</b>"));
FFB.Instance.AddChatEntry(i % 2 == 0 ? "Foo" : "Bar", $"Test Chat message {i} - long line to force line wrapping to happen... Blah blah blah.");
}
}
internal void HandleNetCommand(NetCommand netCommand)
{
var commandHandler = CommandFactory.GetReflectedInstance(netCommand.GetType());
if (commandHandler != null)
{
commandHandler.HandleCommand(netCommand);
}
else
{
FFB.Instance.AddReport(RawString.Create($"Missing handler for NetCommand {netCommand.GetType().Name}"));
}
}
public void WriteTo_Writes_ToSpecifiedWriter()
{
string value = "value";
var raw = new RawString(value);
var writer = new StringWriter();
raw.WriteTo(writer);
string result = writer.ToString();
Assert.NotNull(result);
Assert.Equal(value, result);
}
public static ReferenceInformationType ToReferenceInformationType(this RawString str)
{
if (str.SequenceEqual(FbxConstStrings.Direct()))
{
return(ReferenceInformationType.Direct);
}
else if (str.SequenceEqual(FbxConstStrings.IndexToDirect()))
{
return(ReferenceInformationType.IndexToDirect);
}
else
{
throw new FormatException();
}
}
public static ModelType ToModelType(this RawString str)
{
ReadOnlySpan <byte> Null = stackalloc byte[4] {
(byte)'N', (byte)'u', (byte)'l', (byte)'l'
};
ReadOnlySpan <byte> LimbNode = stackalloc byte[8] {
(byte)'L', (byte)'i', (byte)'m', (byte)'b', (byte)'N', (byte)'o', (byte)'d', (byte)'e'
};
ReadOnlySpan <byte> Mesh = stackalloc byte[4] {
(byte)'M', (byte)'e', (byte)'s', (byte)'h'
};
return(str.SequenceEqual(Null) ? ModelType.Null
: str.SequenceEqual(LimbNode) ? ModelType.LimbNode
: str.SequenceEqual(Mesh) ? ModelType.Mesh
: ModelType.Unknown);
}
public override void Apply(Ffb.Dto.Commands.ServerModelSync command)
{
var list = command?.modelChangeList?.modelChangeArray;
if (list != null)
{
foreach (var obj in list)
{
ModelChange change = FFB.Instance.ModelChangeFactory.DeserializeJson(obj, obj?["modelChangeId"]?.ToString());
if (change != null)
{
FFB.Instance.Model.ApplyChange(change);
}
else
{
FFB.Instance.AddReport(RawString.Create($"<b>* * * Missing DTO for ModelChange {obj?["modelChangeId"]} * * *</b>"));
}
}
}
list = command?.reportList?.reports;
if (list != null)
{
foreach (var obj in list)
{
Report report = FFB.Instance.ReportFactory.DeserializeJson(obj, obj?["reportId"]?.ToString());
if (report != null)
{
FFB.Instance.AddReport(report);
}
else
{
FFB.Instance.AddReport(RawString.Create($"<b>* * * Missing DTO for Report {obj?["reportId"]} * * *</b>"));
}
}
}
var sound = command?.sound.key;
if (!string.IsNullOrEmpty(sound))
{
FFB.Instance.PlaySound(sound);
}
}
internal NameConst(RawString[] strings)
{
_strings = strings;
}
