private void StringSplitTest()
{
//Normal Split fonksiyonundan ek olarak ayarlar ve tek/çift tırnak içerisini ayırmama gibi özellikler barındırır.
StringSplitter splitter = new StringSplitter("item1 => item2 => item3 = item4", "=", "=>");
splitter.OnSplit = (handler) =>
{
//her metindeki boşlukları kırpıyoruz.
handler.Text = handler.Text.Trim();
//item2 ismindeki metni listeye dâhil ettirmiyoruz.
if (handler.Text == "item2")
{
handler.Cancel = true;
}
//Mevcut metin * ile başlıyorsa ayrıştırma işlemini bu kısımda durdurur.
if (handler.Text.StartsWith("*"))
{
handler.Stop = true;
}
};
//Çift Tırnak/Tek tırnak içerisindeki metinlerin ayraca dâhil edip etmeyeceği buradan ayarlanır.
splitter.SplitQuoteOption = StringQuoteOption.SingleQuote;
var result = splitter.Split();
MessageBox.Show(string.Join("\r\n", result));
//Ayrıca aşağıdaki gibide kullanılabilir.
//using CommonUtils.Extensions; içermelidir.
result = "item1 item2 item3".SplitEx(" ");
}
public static Document CreateFromFile(string filePath)
{
var doc = new Document();
doc.rows.Add(StringSplitter.Split(File.ReadAllText(filePath)));
return(doc);
}
public List <object> Deserialize(IFormatProvider provider, char delimiter, bool skipHeader, ReadOnlyMemory <char> csv)
{
bool firstRow = true;
List <object> items = new List <object>();
while (csv.Length > 0)
{
List <ReadOnlyMemory <char> > columns = StringSplitter.ReadNextLine(ref csv, delimiter);
if (firstRow && skipHeader)
{
firstRow = false;
continue;
}
if (_properties.Length != columns.Count)
{
int endOfLine = csv.Span.IndexOf('\n');
string line = endOfLine == -1 ? csv.ToString() : csv.Slice(0, endOfLine).ToString();
throw new CsvFormatException(typeof(T), line, $"Row must consists of {_properties.Length} columns.");
}
T item = Activator.CreateInstance <T>();
for (int i = 0; i < _properties.Length; i++)
{
switch (_deserializeAs[i])
{
case DeserializeAs.SByte:
if (columns[i].Length >= 2 && columns[i].Span[0] == '"' && sbyte.TryParse(columns[i].Span[1..^ 1], NumberStyles.Integer, provider, out sbyte vSByte))
public void Preserve_Spaces_At_End()
{
var splitter = new StringSplitter();
var result = splitter.Split("hello ").ToList(); ;
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0], Is.EqualTo(new WordWithSpace("hello", " ")));
}
internal ScalingSequentialPipeline(PipelineContext context)
{
m_Pause = new ManualResetEvent(true);
m_LatestPauseState = false;
m_DummyProgress = new Progress <int>();
m_ActualProgress = new Progress <int>();
m_PauseSyncRoot = new object();
m_Context = context;
m_LineBuffers = new List <BoundedConcurrentQueu <string> >();
m_RecordBuffers = new List <BoundedConcurrentQueu <object[]> >();
m_RowBuffers = new List <BoundedConcurrentQueu <Row> >();
if (context.SourceFilePath.Contains(".xls"))
{
m_ExcelReader = new ExcelDataExtractor();
}
else
{
m_Reader = new DIALFlatFileExtractor();
m_StringSplitter = new StringSplitter(context.Qualifier)
{
Delimiter = context.Delimiter
};
}
m_RowBuilder = new RecordToRowTransformer(context.ColumnNames, context.IsSkippingError);
m_Loader = new SQLTableLoader();
//register event
m_ActualProgress.ProgressChanged += OnReaderEvent;
}
public void Test_One_Word_With_Dollars()
{
var splitter = new StringSplitter();
var result = splitter.Split("$temp$").ToList();
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0], Is.EqualTo(new WordWithSpace("$temp$", "")));
}
void SplitStringWithEscape2(string input, char splitChar, char escapeChar, string output)
{
var strings = StringSplitter.SplitWithEscape(input, splitChar, escapeChar).ToArray();
var result = string.Join(",", strings);
Assert.Equal(output, result);
}
static bool IsSpecMarkedToSkip(string rawObjectSpecPrefixesToSkip, string plasticObjectSpec)
{
if (string.IsNullOrWhiteSpace(rawObjectSpecPrefixesToSkip))
{
return(false);
}
string[] filters = StringSplitter.SplitList(rawObjectSpecPrefixesToSkip);
if (filters == null || filters.Length == 0)
{
return(false);
}
foreach (string filter in filters)
{
if (string.IsNullOrWhiteSpace(filter))
{
continue;
}
if (!Regex.IsMatch(plasticObjectSpec.Trim(), filter.Trim()))
{
continue;
}
return(true);
}
return(false);
}
public void SplitByStringSplitter()
{
StringSplitter splitter = new StringSplitter(Allocator.TempJob);
splitter.AddDelim("@@");
splitter.AddDelim("678");
splitter.AddDelim("8");
splitter.AddDelim("987");
ref_list.Clear();
ref_list.Add(" 12345");
ref_list.Add("90");
ref_list.Add("0");
ref_list.Add("654321^^ 1234567\t");
ref_list.Add("90 # ");
Debug.Log(" >> try StringSplitter.Split(NativeList<char>, result) >>");
NSL_result.Clear();
splitter.Split(NL_source, NSL_result);
Assert.IsTrue(this.CheckSplitterResult(NSL_result, ref_list));
Debug.Log(" >> try StringSplitter.Split(StringEntity, result) >>");
NSL_result.Clear();
splitter.Split(SE_source, NSL_result);
Assert.IsTrue(this.CheckSplitterResult(NSL_result, ref_list));
splitter.Dispose();
}
/// <summary>
/// Parses the specified message text.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="text">The message text.</param>
/// <returns>The triggers parsed from the text.</returns>
public static IEnumerable <TriggerBase> Parse(DependencyObject target, string text)
{
if (string.IsNullOrEmpty(text))
{
return(new TriggerBase[0]);
}
var triggers = new List <TriggerBase>();
var messageTexts = StringSplitter.Split(text, ';');
foreach (var messageText in messageTexts)
{
var triggerPlusMessage = LongFormatRegularExpression.IsMatch(messageText)
? StringSplitter.Split(messageText, '=')
: new[] { null, messageText };
var messageDetail = triggerPlusMessage.Last()
.Replace("[", string.Empty)
.Replace("]", string.Empty)
.Trim();
var trigger = CreateTrigger(target, triggerPlusMessage.Length == 1 ? null : triggerPlusMessage[0]);
var message = CreateMessage(target, messageDetail);
#if WINDOWS_UWP || XFORMS
AddActionToTrigger(target, message, trigger);
#else
trigger.Actions.Add(message);
#endif
triggers.Add(trigger);
}
return(triggers);
}
public S3DataReader2(string bucket, string folder, string awsAccessKeyId,
string awsSecretAccessKey, int chunkId, string fileName, Dictionary <string, int> fieldHeaders, string prefix, long initRow)
{
_chunkId = chunkId;
_bucket = bucket;
_folder = folder;
_fileName = fileName;
_fieldHeaders = fieldHeaders;
_prefix = prefix;
_spliter = new StringSplitter(this._fieldHeaders.Count);
_transferUtility = new TransferUtility(awsAccessKeyId, awsSecretAccessKey, Amazon.RegionEndpoint.USEast1);
_responseStream = _transferUtility.OpenStream(bucket, $"{folder}/{chunkId}/{fileName}/{fileName}{prefix}_part_00.gz");
_bufferedStream = new BufferedStream(_responseStream);
_gzipStream = new GZipStream(_bufferedStream, CompressionMode.Decompress);
_reader = new StreamReader(_gzipStream, Encoding.Default);
_rowIndex = initRow;
for (var i = 0; i < initRow; i++)
{
_reader.ReadLine();
}
if (initRow > 0)
{
Console.WriteLine($"{fileName}{prefix}_part_00.gz; Rows skipped={initRow}");
}
}
public Dictionary <TKey, TValue> Deserialize(string text)
{
if (text == null)
{
return(null);
}
var splitText = StringSplitter.Split(text);
if (splitText == null)
{
return(null);
}
var dict = new Dictionary <TKey, TValue>();
foreach (var textElement in splitText)
{
var pair = PairParser.Deserialize(textElement);
if (pair.Value != null && !dict.ContainsKey(pair.Key))
{
dict.Add(pair.Key, pair.Value);
}
}
return(dict);
}
static bool IsRepositoryMatch(string rawReposToWatch, string repository)
{
if (string.IsNullOrWhiteSpace(rawReposToWatch))
{
return(true);
}
string[] reposToWatch = StringSplitter.SplitList(rawReposToWatch);
if (reposToWatch == null || reposToWatch.Length == 0)
{
return(false);
}
foreach (string repoConfiguredToWatch in reposToWatch)
{
if (string.IsNullOrWhiteSpace(repoConfiguredToWatch))
{
continue;
}
if (!Regex.IsMatch(repository.Trim(), repoConfiguredToWatch.Trim()))
{
continue;
}
return(true);
}
return(false);
}
public List <T> Deserialize(string text)
{
if (text == null)
{
return(null);
}
var splitText = StringSplitter.Split(text);
if (splitText == null)
{
return(null);
}
var list = new List <T>();
foreach (var textElement in splitText)
{
var element = ElementParser.Deserialize(textElement);
if (element != null)
{
list.Add(element);
}
}
return(list);
}
private IEnumerator <string[]> GetEnumerator()
{
foreach (var file in GetFiles())
{
var getObjectRequest = new GetObjectRequest
{
BucketName = bucket,
Key = file
};
var lines = new BlockingCollection <string>();
var stage1 = Task.Run(() =>
{
try
{
using (var getObjectResponse = client.GetObject(getObjectRequest))
using (var responseStream = getObjectResponse.ResponseStream)
using (var bufferedStream = new BufferedStream(responseStream))
using (var gzipStream = new GZipStream(bufferedStream, CompressionMode.Decompress))
using (var reader = new StreamReader(gzipStream, Encoding.Default))
{
string line;
while ((line = reader.ReadLine()) != null)
{
lines.Add(line);
}
}
}
finally
{
lines.CompleteAdding();
}
});
var spliter = new StringSplitter(this.fieldHeaders.Count);
foreach (var line in lines.GetConsumingEnumerable())
{
if (!string.IsNullOrEmpty(line))
{
try
{
spliter.Split(line, '\t');
}
catch (Exception)
{
log("Split error, file name - " + file);
log("Split error, error line - " + line);
log("Split error, headers - " + string.Join(",", this.fieldHeaders));
throw;
}
yield return(spliter.Results);
}
}
Task.WaitAll(stage1);
}
}
void SplitTest(string input, int byteLength, string expectedFirst)
{
var ss = new StringSplitter();
ss.Split(input, byteLength, enc)
.First().Is(expectedFirst);
}
private static int?SplitStringLiteral(
Document document,
DocumentOptionSet options,
int position,
CancellationToken cancellationToken
)
{
var useTabs = options.GetOption(FormattingOptions.UseTabs);
var tabSize = options.GetOption(FormattingOptions.TabSize);
var indentStyle = options.GetOption(
FormattingOptions.SmartIndent,
LanguageNames.CSharp
);
var root = document.GetSyntaxRootSynchronously(cancellationToken);
var sourceText = root.SyntaxTree.GetText(cancellationToken);
var splitter = StringSplitter.Create(
document,
position,
root,
sourceText,
useTabs,
tabSize,
indentStyle,
cancellationToken
);
if (splitter == null)
{
return(null);
}
return(splitter.TrySplit());
}
public void ParseString(string args)
{
var s = new StringSplitter();
s.Split_test(args);
Parse(s.Lines);
}
public void Split_ContinusCapitalLetters_ShouldAsExpected()
{
var words = StringSplitter.Split("An AAA Game");
Assert.AreEqual("An", words[0]);
Assert.AreEqual("AAA", words[1]);
Assert.AreEqual("Game", words[2]);
}
public void ShouldNotSplitStringsInsideCurlyBraces()
{
var message = "message, {string, for}, testing";
var strings = StringSplitter.SplitParameters(message);
Assert.Equal(3, strings.Length);
}
public void SplitIntoWords_EmptyStringPassed_ReturnsZeroStrings()
{
var splitter = new StringSplitter();
var words = splitter.SplitIntoWords(string.Empty);
CollectionAssert.AreEquivalent(new string[]{}, words);
}
public void ShouldNotSplitStringsInsideParenthesis()
{
var message = "message, (string, for), testing";
var strings = StringSplitter.SplitParameters(message);
Assert.Equal(3, strings.Length);
}
public void ShouldNotSplitStringsInsideSquareBrackets()
{
var message = "message, [string, for], testing";
var strings = StringSplitter.SplitParameters(message);
Assert.Equal(3, strings.Length);
}
void SplitStringWithSelfEscape(string input, char splitChar, string output)
{
var quoteChar = splitChar == SingleQuote ? '"' : SingleQuote;
var strings = StringSplitter.SplitQuoted(input, splitChar, quoteChar, quoteChar).ToArray();
var result = string.Join(",", strings);
Assert.Equal(output, result);
}
public void ShouldSplitParametersOnComma()
{
var message = "message, string, for, testing";
var strings = StringSplitter.SplitParameters(message);
Assert.Equal(4, strings.Length);
}
public void Test_Two_Words()
{
var splitter = new StringSplitter();
var result = splitter.Split("hello world").ToList(); ;
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result[0], Is.EqualTo(new WordWithSpace("hello", " ")));
Assert.That(result[1], Is.EqualTo(new WordWithSpace("world", "")));
}
public void RemovesEmptySplitsSeparatedString()
{
var output = StringSplitter.Split("First;Second;", ';');
Assert.Collection(output,
o => Assert.Equal("First", o),
o => Assert.Equal("Second", o));
}
public void ShouldNotSplitValuesWithinBrackets()
{
var message = "[message string] for testing";
var separator = ' ';
var strings = StringSplitter.Split(message, separator);
Assert.Equal(3, strings.Length);
}
public void ShouldSplitAsNormalWhenStringContainsNoBrackets()
{
var message = "message string for testing";
var separator = ' ';
var strings = StringSplitter.Split(message, separator);
Assert.Equal(4, strings.Length);
}
void MultiSplitTest()
{
var ss = new StringSplitter();
ss.Split("あいうえお", 5, enc)
.Is("あい", "うえ", "お");
ss.Split("あいうえお", 4, enc)
.Is("あい", "うえ", "お");
}
public void Split_Combined_ShouldAsExpected()
{
var words = StringSplitter.Split("_20 AAA copiesSold.");
Assert.AreEqual("20", words[0]);
Assert.AreEqual("AAA", words[1]);
Assert.AreEqual("copies", words[2]);
Assert.AreEqual("Sold", words[3]);
}
public void Split_WithSortedAndLowercase_ShouldAsExpected()
{
var words = StringSplitter.SplitSortedLowercase("_20 copiesSold AAA.");
Assert.AreEqual("20", words[0]);
Assert.AreEqual("aaa", words[1]);
Assert.AreEqual("copies", words[2]);
Assert.AreEqual("sold", words[3]);
}
public void Split4()
{
var splitter = new StringSplitter(StringSplittingRules.SnakeCase);
var result = splitter.Split("xAxBxCxDx_ExFxGxe").ToList();
var isTrue = result.SequenceEqual(new[] { "xAxBxCxDx", "ExFxGxe" });
Assert.IsTrue(isTrue);
}
void SplitStringWithSelfEscape(string input, char splitCharAndEscapeChar, string output)
{
//also test SplitWithSelfEscape
var strings = StringSplitter.SplitWithSelfEscape(input, splitCharAndEscapeChar).ToArray();
var result = string.Join(",", strings);
Assert.Equal(output, result);
SplitStringWithEscape2(input, splitCharAndEscapeChar, splitCharAndEscapeChar, output);
}
public static List<OutputLine> Translate(string algorithm)
{
try
{
StringSplitter stringSplitter = new StringSplitter(algorithm);
Parcer p = new Parcer(stringSplitter);
Generator g = new Generator(p.Parse());
return g.Lines;
}
catch (IndexOutOfRangeException e)
{
throw new ArgumentException("Error in algorithm: \""+algorithm+"\"");
}
}
private static string[] conditionAlternativeOperators = { "else" }; //Condition "else" branch operator
public Parcer(StringSplitter lexicalAnalyzer)
{
_lexicalAnalyzer = lexicalAnalyzer;
}
public void Test_Empty()
{
var splitter = new StringSplitter();
var result = splitter.Split("").ToList();
Assert.That(result, Is.EqualTo(new List<WordWithSpace> { }));
}
public void SplitIntoWords_ArbitrarySentencePassed_ReturnsWords(Tuple<string, List<string>> testCase)
{
var splitter = new StringSplitter();
var words = splitter.SplitIntoWords(testCase.Item1);
CollectionAssert.AreEquivalent(testCase.Item2, words);
}
public void SplitIntoWords_NullPassed_ThrowsArgumentNullException()
{
var splitter = new StringSplitter();
Assert.Throws<ArgumentNullException>(() => splitter.SplitIntoWords(null));
}
