private async void showMorseCode(string text)
{
MorseCodeRespository r = new MorseCodeRespository();
try
{
MorseCode morseCode = new MorseCode();
morseCode.morsecode = "";
morseCode.plaintext = "";
if (text != "")
{
morseCode = await r.EncodeByStringAsync(text);
}
txtAPITextTest.Text = morseCode.morsecode;
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("server"))
{
Jeeves.ShowMessage("Error", "No connection with the server.");
}
else
{
Jeeves.ShowMessage("Error", "Could not complete operation.");
}
}
}
public static void Main()
{
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
MorseCode mc = new MorseCode(led, 150);
mc.parseMorse("Hello World");
}
public static string Decode(string morseCode)
{
string Decoded = "";
morseCode = morseCode.Trim();
morseCode = morseCode.Replace(" ", " # ");
foreach (var character in morseCode.Split(' '))
{
if (character == "#")
{
Decoded = Decoded + ' ';
}
else
{
Decoded = Decoded + MorseCode.Get(character);
}
}
return(Decoded);
throw new System.NotImplementedException("Please provide some code.");
}
void RefreshTeacher()
{
teachingLabel.Text = "";
var sb = new StringBuilder();
var nexts = qmarker.GetNextNLetter(2);
foreach (var next in nexts)
{
if (next == "")
{
continue;
}
sb.Append(next);
sb.Append(" : ");
var code = MorseCode.GetCode(next);
foreach (char dh in code)
{
var dhstr = dh.ToString();
if (dhstr.Equals("0"))
{
sb.Append(" ―");
}
else
{
sb.Append(" ・");
}
}
sb.Append("\r\n");
}
teachingLabel.Text = sb.ToString();
}
void Start()
{
if (CharacterPanel == null)
{
Debug.LogError("characterPanel has no Text object associated with it.");
}
morseCode = GetComponent <MorseCode>();
int msgIndex = Stage - 1;
message = Messages[msgIndex].Content;
//DecodedMessagePanel.text = message;
// Remove whitespace in message
// TODO: Keep whitespace?
message = Messages[msgIndex].RemoveWhiteSpace(message);
// TODO: "Shuffle" message before encoding then save order;
// this is to avoid manually setting the order and at the same time still making the order of the message remain the same after each play,
// i.e. pseudo-predetermined
// -- (Unimplemented) --
encodedMessage = morseCode.Encode(message);
// Create a container for spawned objects
spawnedObjects = new GameObject("Spawned Symbols");
spawnedObjects.transform.parent = transform;
symbolsToSpawn = new List <Symbol>();
}
public void Morse_Basic(string morse, string expected)
{
var code = new MorseCode();
var result = code.Decode(morse);
Assert.AreEqual(expected, result);
}
public static string GetLetter(string w)
{
int index = w.IndexOf(" ") - 1;
string encodedWord = w.Substring(0, index);
return(MorseCode.Get(encodedWord));
}
public static string Decode(string morseCode)
{
Regex regex = new Regex("[ ]{3,}", RegexOptions.None);
morseCode = regex.Replace(morseCode.Trim(), " ");
return(String.Join("", morseCode.Split(' ').Select(x => x == "" ? " " : MorseCode.Get(x))));
}
public static string Decode(string morseCode)
{
string[] morseWords = morseCode.Split(" ");
string translatedMorseCode = "";
// foreach (string s in morseWords)
// {
// Console.WriteLine(s);
// }
foreach (string word in morseWords)
{
string[] letters = word.Split(" ");
foreach (string letter in letters)
{
translatedMorseCode += MorseCode.Get(letter);
}
translatedMorseCode += " ";
}
translatedMorseCode = translatedMorseCode.Trim(' ');
return(translatedMorseCode);
throw new System.NotImplementedException("Please provide some code.");
}
public static string Decode(string morseCode)
{
morseCode = morseCode.Replace(" ", " ");
string[] morseCodeArr = morseCode.Split(" ");
string result = "";
foreach (string x in morseCodeArr)
{
if (x == "")
{
result += " ";
}
else
{
result += MorseCode.Get(x);
}
}
while (result[0] == ' ')
{
result = result.Substring(1);
}
while (result[result.Length - 1] == ' ')
{
result = result.Substring(0, result.Length - 1);
}
return(result);
}
public static string Decode(string morseCode)
{
string letter = "";
string result = "";
morseCode = morseCode.Trim();
for (int i = 0; i < morseCode.Length; i++)
{
if (!morseCode[i].Equals(' '))
{
letter += morseCode[i];
}
else
{
result += MorseCode.Get(letter);
letter = "";
if (morseCode[i - 1].Equals(' ') && morseCode[i + 1].Equals(' '))
{
result += " ";
}
}
if (i == morseCode.Length - 1)
{
result += MorseCode.Get(letter);
}
}
return(result);
}
void DecodeChar(string mcode, char expected, bool pass = true)
{
var morseCode = new MorseCode();
char val = morseCode.DecodeChar(mcode);
bool equals = val == expected;
Assert.True(equals == pass);
}
public static string DecodeMorse(string morseCode)
{
var decode = new StringBuilder();
var code = new StringBuilder();
int spaceCount = 0;
bool openParentheses = false;
foreach (char c in morseCode)
{
switch (c)
{
case '.':
case '-':
if (spaceCount == 3)
{
decode.Append(' ');
}
code.Append(c);
spaceCount = 0;
break;
case ' ':
if (spaceCount == 0)
{
if (code.Length > 0)
{
string key = code.ToString();
if (key == "-.--.-")
{
decode.Append(openParentheses ? ')' : '(');
openParentheses = !openParentheses;
}
else
{
decode.Append(MorseCode.Get(key));
}
code.Length = 0;
spaceCount = 1;
}
}
else
{
spaceCount++;
}
break;
default:
throw new ArgumentException(nameof(morseCode));
}
}
if (code.Length > 0)
{
decode.Append(MorseCode.Get(code.ToString()));
}
return(decode.ToString());
}
public static string Decode(string morseCode)
{
string[] morseWords = morseCode.Split(' ');
for (int i = 0; i < morseWords.Length; i++)
{
morseWords[i] = morseWords[i].Length == 0? "¬" : MorseCode.Get(morseWords[i]);
}
return(string.Join("", morseWords).Replace("¬¬", " ").Replace("¬", "").Trim());
}
public static string DecodeLetters(string[] letters)
{
var sb = new StringBuilder();
foreach (var s in letters)
{
sb.Append(MorseCode.Get(s));
}
return(sb.ToString());
}
public void MorseCode()
{
MorseCode cipher = new MorseCode();
const string plaintext = "MORSE CODE";
const string ciphertext = "-- --- .-. ... . -.-. --- -.. .";
Assert.AreEqual(ciphertext, cipher.Encrypt(plaintext));
Assert.AreEqual(plaintext, cipher.Decrypt(ciphertext), true);
}
void EncodeFullText(string input, string expectedMorse, bool pass = true)
{
var morseCode = new MorseCode();
string morseCodeResult = morseCode.EncodeFullText(input);
bool equals = morseCodeResult == expectedMorse;
Assert.True(equals == pass);
}
public static string Decode(string morseCode)
{
var decodedCode = morseCode
.Trim()
.Replace(" ", " W ")
.Split(' ')
.Select(w => w == "W" ? " " : MorseCode.Get(w));
return(string.Join("", decodedCode));
}
public void DecodeMorse_ShouldReturnDecodedString_WhenPassedMultipleWordStr(string original, bool toMorse, string expected)
{
// arrange
var sut = new MorseCode();
// act
var actual = sut.MorseDecode(original, toMorse);
// assert
Assert.Equal(expected, actual);
}
public void MorseCodeWordInput_ReturnsCorrectString()
{
// Arrange
var input = "-... . .- ..- - .. ..-. ..- .-..";
var morseCodeDecoder = new MorseCode();
// Act
var item = morseCodeDecoder.Decoder(input);
// Assert
Assert.AreEqual("BEAUTIFUL", item);
}
public void MorseCodePhraseInput_ReturnsCorrectPhrase()
{
// Arrange
var input = ".... --- .-- -. --- .-- -... .-. --- .-- -. -.-. --- .--";
var morseCodeDecoder = new MorseCode();
// Act
var item = morseCodeDecoder.Decoder(input);
// Assert
Assert.AreEqual("HOW NOW BROWN COW", item);
}
public void MorseCodeLetterInput_ReturnsCorrectLetter()
{
// Arrange
var input = ".-..";
var morseCodeDecoder = new MorseCode();
// Act
var item = morseCodeDecoder.Decoder(input);
// Assert
Assert.AreEqual("L", item);
}
void DecodeFullText(string expected, string mcode, bool pass = true)
{
var morseCode = new MorseCode();
morseCode.DecodeWithDictionary = false;
string result = morseCode.DecodeFullTextToString(mcode);
bool equals = result.Equals(expected, StringComparison.OrdinalIgnoreCase);
Assert.True(equals == pass);
}
public static string Decode(string morseCode)
{
var code = morseCode.Trim().Replace(" ", " | ").Split(' ');
string message = "";
foreach (var codeLetter in code)
{
message += codeLetter == "|" ? " " : MorseCode.Get(codeLetter);
}
return(message);
}
public void DecodeMorse_ShouldReturnEmptyString_WhenPassedNullOrEmpty(string morseCode, bool toMorse)
{
// arrange
string expected = string.Empty;
var sut = new MorseCode();
// act
var actual = sut.MorseDecode(morseCode, toMorse);
// assert
Assert.Equal(expected, actual);
}
public void DecodeTest()
{
Assert.AreEqual(MorseCode.Decode(".-"), "A");
Assert.AreEqual(MorseCode.Decode("."), "E");
Assert.AreEqual(MorseCode.Decode(".."), "I");
Assert.AreEqual(MorseCode.Decode(". ."), "EE");
Assert.AreEqual(MorseCode.Decode(". ."), "E E");
Assert.AreEqual(MorseCode.Decode("... --- ..."), "SOS");
Assert.AreEqual(MorseCode.Decode("... --- ..."), "S O S");
Assert.AreEqual(MorseCode.Decode(".... . -.-- .--- ..- -.. ."), "HEY JUDE");
Assert.AreEqual(MorseCode.Decode(" . "), "E");
Assert.AreEqual(MorseCode.Decode(" . . "), "E E");
Assert.AreEqual(MorseCode.Decode(" ...---... -.-.-- - .... . --.- ..- .. -.-. -.- -... .-. --- .-- -. ..-. --- -..- .--- ..- -- .--. ... --- ...- . .-. - .... . .-.. .- --.. -.-- -.. --- --. .-.-.- "), "SOS! THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.");
}
public static string DecodeMorse(string morseCode)
{
var words = morseCode.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var text = "";
foreach (var word in words)
{
var letters = word.Split(" ", StringSplitOptions.RemoveEmptyEntries);
text = letters.Aggregate(text, (current, letter) => current + MorseCode.Get(letter));
text += " ";
}
text = text.Trim();
return(text);
}
public static string Decode(string morseCode)
{
string message = "";
foreach (string word in Regex.Split(morseCode, " ")) // If there are 3 spaces between chars, it's a new word
{
foreach (string letter in word.Split(' '))
{
message += MorseCode.Get(letter); // Decoding single letter in word and adding it to message
}
message += " "; // Adding space between words in message
}
return(message.Trim());
}
public Falcon4Support(F16CpdMfdManager manager)
{
Manager = manager;
InitializeFlightData();
_morseCodeGenerator = new MorseCode {
CharactersPerMinute = 53
};
_morseCodeGenerator.UnitTimeTick += MorseCodeUnitTimeTick;
_inputControlEventHandler = new InputControlEventHandler(Manager);
_clientSideInboundMessageProcessor = new ClientSideInboundMessageProcessor();
_serverSideInboundMessageProcessor = new ServerSideInboundMessageProcessor(Manager);
}
void Morse(bool encrypt, string text)
{
text = RemoveCzech(text);
text = text.ToLower();
InputText = text;
if (encrypt)
{
Output = MorseCode.TranslateTo(text);
}
else
{
Output = MorseCode.TranslateFrom(text);
}
}
public async Task <MorseCode> EncodeByStringAsync(string text)
{
var response = await client.GetAsync($"encode?string={text}");
if (response.IsSuccessStatusCode)
{
MorseCode morseCode = await response.Content.ReadAsAsync <MorseCode>();
return(morseCode);
}
else
{
return(new MorseCode());
}
}
