public static PageMeta Parse(IEnumerable<string> lines)
{
var meta = new PageMeta();
foreach (var line in lines.TakeWhile(line => line.StartsWith(MD_META_PREFIX)))
{
var metaType = new string(line.Skip(MD_META_PREFIX.Length).TakeWhile(c => c != ' ').ToArray());
var content = new string(line.Skip(metaType.Length + 3).ToArray());
switch (metaType)
{
case "title":
meta.Title = content;
break;
case "date":
DateTimeOffset articleDate;
if (DateTimeOffset.TryParse(content, out articleDate))
{
meta.Date = articleDate;
}
break;
}
}
return meta;
}
static List<DataSample> GetIncidentsReverse(IEnumerable<DataSample> samples, int sessionNumber, int maxTotalIncidents)
{
return IncidentsSupport.FindIncidents(
samples.TakeWhile(data => data.Telemetry.SessionNum == sessionNumber && data.Telemetry.RaceLaps > 0),
d => iRacing.Replay.MoveToPrevIncident(),
maxTotalIncidents);
}
static List<DataSample> GetIncidentsForward(IEnumerable<DataSample> samples, int maxTotalIncidents)
{
return IncidentsSupport.FindIncidents(
samples.TakeWhile(data => data.Telemetry.SessionState != SessionState.CoolDown),
d => iRacing.Replay.MoveToNextIncident(),
maxTotalIncidents);
}
public Arguments(IEnumerable<string> args, IEnumerable<Option> options)
{
if (args == null)
throw new ArgumentNullException("args");
Switches = new Dictionary<string, bool?>(StringComparer.CurrentCultureIgnoreCase);
Variables = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
Parameters = args;
Options = options;
foreach (var argument in Parameters.TakeWhile(item => item.StartsWith("-") &&
item.Length > 1)) {
var name = argument.TrimStart('-');
int colon = name.IndexOf(':');
if (colon > 0) {
var value = name.Substring(colon + 1);
name = name.Substring(0, colon - 1);
name = GetOptionName(name);
Variables[name] = value;
} else {
name = GetOptionName(name);
bool? value = null;
if (name.EndsWith("+")) {
name = argument.Substring(0, name.Length - 1);
value = true;
} else if (name.EndsWith("-")) {
name = name.Substring(0, name.Length - 1);
value = false;
}
Switches[name] = value;
}
}
Parameters = Parameters.Skip(Switches.Count + Variables.Count);
}
private ParserContext HandleAction(IEnumerable<string> parts)
{
var actionParts = parts.TakeWhile(s => !s.StartsWith("@")).TakeWhile(s => !s.Equals("@@"));
CurrentParserContext.ContextContent = String.Join(" ", actionParts);
return CurrentParserContext;
}
static List<DataSample> GetIncidentsForward(IEnumerable<DataSample> samples, int sampleScanSettle, int maxTotalIncidents)
{
TraceDebug.WriteLine("Scanning for incidents forwards from start");
return IncidentsSupport.FindIncidents(
samples.TakeWhile(data => data.Telemetry.SessionState != SessionState.CoolDown),
sampleScanSettle,
maxTotalIncidents);
}
public Result<IEnumerable<Token>, Error> Preprocess(
IEnumerable<string> arguments,
Func<IEnumerable<string>, Result<IEnumerable<Token>, Error>> tokenizer)
{
if (arguments.Any(arg => arg.EqualsOrdinal("--")))
{
var tokenizerResult = tokenizer(arguments.TakeWhile(arg => !arg.EqualsOrdinal("--")));
var values = arguments.SkipWhile(arg => !arg.EqualsOrdinal("--")).Skip(1).Select(Token.Value);
return tokenizerResult.Map(tokens => tokens.Concat(values));
}
if (arguments.Any(arg => arg.EqualsOrdinal("//")))
{
var tokenizerResult = tokenizer(arguments.TakeWhile(arg => !arg.EqualsOrdinal("--")));
var values = arguments.SkipWhile(arg => !arg.EqualsOrdinal("//")).Skip(1).Select(Token.Value);
return tokenizerResult.Map(tokens => tokens.Concat(values));
}
return tokenizer(arguments);
}
public static StatePair<IEnumerable<Token>> PreprocessDashDash(
IEnumerable<string> arguments,
Func<IEnumerable<string>, StatePair<IEnumerable<Token>>> tokenizer)
{
if (arguments.Any(arg => arg.EqualsOrdinal("--")))
{
var tokenizerResult = tokenizer(arguments.TakeWhile(arg => !arg.EqualsOrdinal("--")));
var values = arguments.SkipWhile(arg => !arg.EqualsOrdinal("--")).Skip(1).Select(Token.Value);
return tokenizerResult.MapValue(tokens => tokens.Concat(values));
}
return tokenizer(arguments);
}
public static DigitSequence Produce(IEnumerable<Symbol> symbols,
out IEnumerable<Symbol> symbolsToProcess)
{
// digit-sequence = 1*decimal-digit
IEnumerable<Symbol> digits = symbols.TakeWhile(s =>
s is DecimalDigit);
if (digits.Any())
{
symbolsToProcess = symbols.Skip(digits.Count());
return new DigitSequence(digits);
}
symbolsToProcess = null;
return null;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="parseContext">Parse context</param>
/// <param name="applicationCommand">Application command</param>
/// <param name="subConfigurations">Command configurations</param>
internal AggregatedRuntimeCommand(ParseContext parseContext,
IRuntimeCommand applicationCommand,
IEnumerable <ICommandLineConfiguration>?subConfigurations)
{
// Get the matched sub configuration
var command = subConfigurations?
.TakeWhile(_ => parseContext.Reset())
.Select(config => config.GetRuntimeCommand())
.FirstOrDefault(runtimeCommand => parseContext.TryTakeTemplate(runtimeCommand.Template !, 0));
if (command != null)
{
_runtimeCommands.Add(command);
}
_runtimeCommands.Add(applicationCommand);
}
public static Expression Produce(IEnumerable<Symbol> symbols)
{
// expression = *whitespace nospace-expression *whitespace
int numSpaceBefore = symbols.TakeWhile(s => s is WhiteSpace).Count();
int numSpaceAfter = symbols.Reverse()
.TakeWhile(s => s is WhiteSpace).Count();
IEnumerable<Symbol> noSpaceSymbolList = symbols
.Skip(numSpaceBefore)
.SkipLast(numSpaceAfter)
.ToList();
NoSpaceExpression n = NoSpaceExpression.Produce(noSpaceSymbolList);
if (null == n)
{
return null;
}
return new Expression(WhiteSpace.CreateWhiteSpace(numSpaceBefore),
n, WhiteSpace.CreateWhiteSpace(numSpaceAfter));
}
public static void ProcessCommits(this IBot bot, string repositoryName ,string lastCommit, IEnumerable<dynamic> commits)
{
// find new commits since
var groupedCommits = commits.TakeWhile(c => c.commit.tree.sha != lastCommit).GroupBy(c => c.committer.login);
// create string to send as message
var sb = new StringBuilder();
sb.AppendFormat("github: there are new commits in the {0} repository\r\n", repositoryName);
foreach (var committer in groupedCommits)
{
sb.AppendFormat("{0} had {1} commits\r\n", committer.Key, committer.Count());
}
// split into rows and send to rooms
var rows = sb.ToString().Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var row in rows)
bot.SayToAllRooms(row);
}
public static Expression Produce(IEnumerable<Symbol> symbols)
{
// expression = *whitespace nospace-expression *whitespace
var whiteSpaceBefore = symbols.TakeWhile(s => s is WhiteSpace)
.Count();
var whiteSpaceAfter = symbols.Reverse()
.TakeWhile(s => s is WhiteSpace)
.Count();
var noSpaceSymbolList = symbols.Skip(whiteSpaceBefore)
.SkipLast(whiteSpaceAfter)
.ToList(); // ToList is vital here!
var nospaceExpression = NospaceExpression.Produce(noSpaceSymbolList);
return nospaceExpression == null
? null
: new Expression(
Enumerable.Repeat(new WhiteSpace(), whiteSpaceBefore),
nospaceExpression,
Enumerable.Repeat(new WhiteSpace(), whiteSpaceAfter));
}
private static String ParseString(ref IEnumerable<byte> data)
{
byte[] sname = data
.TakeWhile<byte>(b => b != TK_VAR_SECTION)
.ToArray<byte>();
data = data.Skip<byte>(sname.Length + 1);
return Encoding.UTF8.GetString(sname);
}
private static bool CheckStraight(IEnumerable<Card> cards, List<Card> bestCards)
{
bool isStraight = CheckAceHighStraight(cards);
if (!isStraight)
{
int count = 1; //set to 1 to include the first card
var list = cards.OrderByDescending(c => c.NumberValue).DistinctBy(c => c.NumberValue).ToList();
for (int i = 0; i < list.Count; i++)
{
if (i + 1 >= list.Count)
{
break;
}
if (list[i].NumberValue - list[i + 1].NumberValue == 1)
{
count++;
}
else
{
count = 1;
}
if (count >= 5)
{
isStraight = true;
i++;
while (bestCards.Count < 5)
{
bestCards.Add(list[i]);
i--;
}
break;
}
}
if (isStraight && cards.ContainsProperty(c => c.Number == "A"))
{
cards.Where(c => c.Number == "A").ToList().ForEach(c => c.Points = 1);
}
}
else
{
bestCards.AddRange(cards.TakeWhile(c =>
c.Number == "A" || c.Number == "K" || c.Number == "Q" || c.Number == "J" ||
c.Number == "10"));
bestCards = bestCards.DistinctBy(c => c.Number).ToList();
}
return isStraight;
}
public static IEnumerable <T> TakeUntil <T>(this IEnumerable <T> enumerable, Func <T, bool> condition)
{
return(enumerable.TakeWhile(x => !condition(x)));
}
private static string Str(this IEnumerable <char> cs) => string.Concat(cs.TakeWhile(char.IsLetter));
private static IEnumerable<int> FindTheAnswer(IEnumerable<int> numbers)
{
return numbers.TakeWhile(x => x != 42);
}
public static IEnumerable <TItem> TakeUntilItemExclusive <TItem>(this IEnumerable <TItem> list, TItem item)
{
return(list.TakeWhile(it => !it.Equals(item)));
}
public static T GetPrevious <T>(this IEnumerable <T> list, T current, Func <T, T, bool> comparison)
{
return(list.TakeWhile(x => !comparison(x, current)).LastOrDefault());
}
private static IEnumerable <char> LeadingNulls(IEnumerable <byte> input)
{
return(Enumerable.Range(0, input.TakeWhile(b => b == 0x00).Count()).Select(_ => '0'));
}
private static IEnumerable <byte> LeadingZeros(IEnumerable <char> input)
{
return(Enumerable.Range(0, input.TakeWhile(b => b == '0').Count()).Select(_ => (byte)0x00));
}
public static int IndexOf <T>(this IEnumerable <T> enumerable, T item, EqualityComparer <T> comparer)
{
int index = enumerable.TakeWhile(x => comparer.Equals(x, item)).Count();
return(index == enumerable.Count() ? -1 : index);
}
/// <summary>
/// Continues processing items in a collection until the end condition is true.
/// </summary>
public static IEnumerable <T> TakeUntil <T>(this IEnumerable <T> source, Predicate <T> endCondition)
{
return(source.TakeWhile(item => !endCondition(item)));
}
private void LoadMenuFlyoutItem(IList <MenuFlyoutItemBase> MenuItemsList, IEnumerable <Win32ContextMenuItem> menuFlyoutItems, string menuHandle, bool showIcons = true, int itemsBeforeOverflow = int.MaxValue)
{
var items_count = 0; // Separators do not count for reaching the overflow threshold
var menu_items = menuFlyoutItems.TakeWhile(x => x.Type == MenuItemType.MFT_SEPARATOR || ++items_count <= itemsBeforeOverflow).ToList();
var overflow_items = menuFlyoutItems.Except(menu_items).ToList();
if (overflow_items.Where(x => x.Type != MenuItemType.MFT_SEPARATOR).Any())
{
var menuLayoutSubItem = new MenuFlyoutSubItem()
{
Text = "ContextMenuMoreItemsLabel".GetLocalized(),
Tag = ((Win32ContextMenuItem)null, menuHandle),
Icon = new FontIcon()
{
FontFamily = App.Current.Resources["FluentUIGlyphs"] as Windows.UI.Xaml.Media.FontFamily,
Glyph = "\xEAD0"
}
};
LoadMenuFlyoutItem(menuLayoutSubItem.Items, overflow_items, menuHandle, false);
MenuItemsList.Insert(0, menuLayoutSubItem);
}
foreach (var menuFlyoutItem in menu_items
.SkipWhile(x => x.Type == MenuItemType.MFT_SEPARATOR) // Remove leading seperators
.Reverse()
.SkipWhile(x => x.Type == MenuItemType.MFT_SEPARATOR)) // Remove trailing separators
{
if ((menuFlyoutItem.Type == MenuItemType.MFT_SEPARATOR) && (MenuItemsList.FirstOrDefault() is MenuFlyoutSeparator))
{
// Avoid duplicate separators
continue;
}
BitmapImage image = null;
if (showIcons)
{
image = new BitmapImage();
if (!string.IsNullOrEmpty(menuFlyoutItem.IconBase64))
{
byte[] bitmapData = Convert.FromBase64String(menuFlyoutItem.IconBase64);
using (var ms = new MemoryStream(bitmapData))
{
#pragma warning disable CS4014
image.SetSourceAsync(ms.AsRandomAccessStream());
#pragma warning restore CS4014
}
}
}
if (menuFlyoutItem.Type == MenuItemType.MFT_SEPARATOR)
{
var menuLayoutItem = new MenuFlyoutSeparator()
{
Tag = (menuFlyoutItem, menuHandle)
};
MenuItemsList.Insert(0, menuLayoutItem);
}
else if (menuFlyoutItem.SubItems.Where(x => x.Type != MenuItemType.MFT_SEPARATOR).Any() &&
!string.IsNullOrEmpty(menuFlyoutItem.Label))
{
var menuLayoutSubItem = new MenuFlyoutSubItem()
{
Text = menuFlyoutItem.Label.Replace("&", ""),
Tag = (menuFlyoutItem, menuHandle),
};
LoadMenuFlyoutItem(menuLayoutSubItem.Items, menuFlyoutItem.SubItems, menuHandle, false);
MenuItemsList.Insert(0, menuLayoutSubItem);
}
else if (!string.IsNullOrEmpty(menuFlyoutItem.Label))
{
var menuLayoutItem = new MenuFlyoutItemWithImage()
{
Text = menuFlyoutItem.Label.Replace("&", ""),
Tag = (menuFlyoutItem, menuHandle),
BitmapIcon = image
};
menuLayoutItem.Click += MenuLayoutItem_Click;
MenuItemsList.Insert(0, menuLayoutItem);
}
}
}
/// <summary>
/// Creates an asynchronous Task object that executes the given critical phase and optional phases in a background thread
/// and invokes all other callbacks on the UI thread.
/// </summary>
/// <param name="cancellationToken"></param>
/// <param name="beforeStart">Invoked on UI thread</param>
/// <param name="criticalPhase">First phase to run. Must succeed (by returning <c>true</c> and not throwing an exception) for the optional phases to run. Invoked on the background thread.</param>
/// <param name="optionalPhases">Collection of phases that can fail (by throwing an exception) without preventing subsequent phases from running. Invoked on the background thread.</param>
/// <param name="fail">Called if the operation is canceled or the critical phase throws an exception. Invoked on the UI thread.</param>
/// <param name="succeed">Called if the operation completes successfully without being canceled. Invoked on the UI thread.</param>
/// <returns>
/// Task object that returns <c>false</c> if the operation was canceled by the user or
/// the critical phase threw an exception; otherwise <c>true</c>.
/// </returns>
private Task<bool> CreateStageTask(CancellationToken cancellationToken, TaskStartedEventHandler beforeStart, CriticalPhase criticalPhase, IEnumerable<OptionalPhase> optionalPhases, ExceptionEventHandler fail, TaskSucceededEventHandler succeed)
{
var canContinue = CreateCanContinueFunc(cancellationToken);
return new TaskBuilder()
.OnThread(_callbackScheduler)
.CancelWith(cancellationToken)
.BeforeStart(beforeStart)
.Fail(fail)
.DoWork(delegate(IThreadInvoker invoker, CancellationToken token)
{
cancellationToken.Register(() => Logger.Warn("User canceled current operation"));
if (criticalPhase())
{
foreach (var phase in optionalPhases.TakeWhile(phase => canContinue()))
{
phase();
}
if (canContinue())
{
invoker.InvokeOnUIThreadAsync(_ => succeed());
return;
}
}
// TODO: How should we handle exceptions here?
// The rest of the code assumes exceptions are being handled by the plugin runner.
invoker.InvokeOnUIThreadAsync(_ => fail(new ExceptionEventArgs()));
})
.Build()
;
}
public static IEnumerable <T> RemoveWhile <T>(this IEnumerable <T> enumerable, Func <T, bool> predicate) => enumerable.Skip(enumerable.TakeWhile(predicate).Count());
private IEnumerable<IFormulaToken> CompleteOperatorBackwards(IEnumerable<IFormulaToken> tokens, IFormulaOperator operatorToken)
{
var operatorOrder = operatorToken.Order;
return tokens
.TakeWhile(token => !(token is FormulaTokenParameterSeparator))
.WithContext()
.TakeWhile(context =>
{
var nextToken = context[0];
var token = context[1];
if (token == null) return false;
var operatorToken2 = token as IFormulaOperator;
var expectValue = nextToken == null || nextToken is FormulaNodeInfixOperator;
if (expectValue)
{
// missing value of operator
return operatorToken2 == null;
}
// operator fully completed
return operatorToken2 != null && operatorOrder < operatorToken2.Order;
}).Select(context => context[1]);
}
public static T GetPrevious <T>(this IEnumerable <T> list, T current)
{
return(list.TakeWhile(x => !x.Equals(current)).LastOrDefault());
}
public static IEnumerable <TItem> TakeUntilItemInclusive <TItem>(this IEnumerable <TItem> list, TItem item) where TItem : class
{
return(list.TakeWhile(it => !it.Equals(item)).Append(item));
}
private IEnumerable<IFormulaToken> CompleteOperatorForward(IEnumerable<IFormulaToken> tokens, IFormulaOperator operatorToken)
{
var operatorOrder = operatorToken.Order;
return tokens
.TakeWhile(token => !(token is FormulaTokenParameterSeparator))
.WithContext()
.TakeWhile(context =>
{
var previousToken = context[0];
var token = context[1];
if (token == null) return false;
var infixOperatorToken = token as FormulaNodeInfixOperator;
var expectValue = previousToken == null || previousToken is IFormulaOperator;
if (expectValue)
{
// missing value of operator
return infixOperatorToken == null;
}
// operator fully completed
return infixOperatorToken != null && infixOperatorToken.Order > operatorOrder;
}).Select(context => context[1]);
}
public static void PopulateWithRatings(this List<IUser> users, IEnumerable<IRating> ratings, bool combineDuplicateArtists = false)
{
foreach (var rating in ratings.TakeWhile(rating => rating.UserIndex < users.Count))
users[rating.UserIndex].Ratings.Add(rating);
if (combineDuplicateArtists)
users.CombineDuplicateArtists();
}
protected Element(IEnumerable<char> tag)
{
IndentLevel = tag.TakeWhile(x => x == ' ').Count();
}
private static IEnumerable<string> CreateSegment(IEnumerable<string> current, IEnumerable<string> previous)
{
return current.TakeWhile((step, index) => step == previous.ElementAtOrDefault(index)).ToArray();
}
private static int GetIndexOfTab(TabInfo objTab, IEnumerable<TabInfo> tabs)
{
return Null.NullInteger + tabs.TakeWhile(tab => tab.TabID != objTab.TabID).Count();
}
/// <summary>
/// sToPop is a member of block, and can be or is the first statement. We see if we can pop it up
/// a level, and then start a scan for an equivalent statement, marching up the list. If we
/// find an equivalent statement, we will perform the combination and removal.
/// </summary>
/// <param name="block">The block of statements that holds sToPop</param>
/// <param name="sToPop">The statement to try to up level.</param>
/// <param name="previousStatements">Statements before this one in this block. This block might not actually contain this statement, in which case we must have this!</param>
/// <param name="followingStatements">Statements after this one in this block. This block might not actually contain this statement, in which case we must have this!</param>
/// <returns>True if something was done to the statement, false if we aborted for whatever reason.</returns>
private static bool FindEquivalentAboveAndCombine(IStatementCompound block, IStatement sToPop,
IEnumerable<IStatement> previousStatements = null,
IEnumerable<IStatement> followingStatements = null,
IStatement betweenStatement = null
)
{
// Can we combine these guys? This is when one sits in the other.
if (!(block is IStatementLoop) && block.TryCombineStatement(sToPop, new BlockRenamer(sToPop.Parent.FindBookingParent(), block.FindBookingParent())))
{
sToPop.FindCompoundParent().Remove(sToPop);
return false;
}
// If we can't get data flow information about a statement, then we can't do anything.
var sInfo = sToPop as ICMStatementInfo;
if (sInfo == null)
{
return false;
}
// For this next step we need to fetch the list of statements above us. Either it has
// been supplied to us, or we will have to generate it.
if (previousStatements == null)
{
previousStatements = block.Statements.TakeWhile(s => s != sInfo).Reverse();
followingStatements = block.Statements.SkipWhile(s => s != sInfo).Skip(1);
betweenStatement = sToPop;
}
// Make sure we can get the statement to the top of the block. As we move it
// forward, we want to also see if we can combine it in a straight-up way
// with each statement as we go by it.
bool madeItToTheFront = true;
foreach (var prevStatement in previousStatements)
{
if (MakeStatmentsEquivalent(prevStatement, sToPop))
{
return true;
}
if (!StatementCommutes(prevStatement, sToPop))
{
madeItToTheFront = false;
}
}
// Next, lets see if there isn't a statement *after* this one that we can combine it with. However,
// to do this, we have to move the statements *after* forward previous to this one. So a little painful.
// No need to do this if we working at the level of the statement: this ground will automatically be covered
// later in the loop.
if (betweenStatement != sToPop && betweenStatement is ICMCompoundStatementInfo)
{
foreach (var followStatement in followingStatements)
{
if (followStatement is ICMStatementInfo)
{
// Can we commute this statement from where it is to before the statement we are working on?
if (StatementCommutes(followStatement, followingStatements.TakeWhile(f => f != followStatement).Reverse()))
{
// Next is the tricky part. We are now sitting one down from the block that contains
// the sToPop statement. Can we move it up above the block? If the statements are the same,
// then we know it is ok to move it pass all the contents of the block (otherwise we would not be here).
// But what if it is an if statement, and the if statement depends on something in sToPop? Then
// we can't move it.
var betweenAsBlock = betweenStatement as ICMCompoundStatementInfo;
if (betweenAsBlock.CommutesWithGatingExpressions(followStatement as ICMStatementInfo))
{
if (MakeStatmentsEquivalent(followStatement, sToPop))
{
// To keep continuity and unitarity, this follow statement now has to be moved before the betweenStatement!
var parent = followStatement.Parent as IStatementCompound;
parent.Remove(followStatement);
parent.AddBefore(followStatement, betweenStatement);
return true;
}
}
}
}
}
}
// Now the only option left is to pop it up one level. We can do that only if we were able to
// shift the statement all the way to the front.
if (!madeItToTheFront)
{
return false;
}
// The statement can be moved to the top of the block, and isn't the same as
// anything else we passed. Can we pull it out one level?
// The key to answering this is: are all the variables it needs defined at the next
// level up? And if not, are the missing ones simply declared down here and need to be moved up?
var nParent = block.Parent.FindBookingParent();
if (nParent == null)
{
return false;
}
var sDependent = sInfo.DependentVariables;
var availAtParent = nParent.AllDeclaredVariables.Select(n => n.RawValue).Intersect(sDependent);
IEnumerable<string> declaredInBlock = Enumerable.Empty<string>();
if (block is IBookingStatementBlock)
{
declaredInBlock = (block as IBookingStatementBlock).DeclaredVariables.Select(np => np.RawValue).Intersect(sDependent);
}
if ((availAtParent.Count() + declaredInBlock.Count()) != sDependent.Count())
{
return false;
}
// If this there is a variable declared in the block internally, then we can't lift it up and out.
// Also make sure that we can lift it past if there is a gating expression.
if (block is ICMCompoundStatementInfo)
{
var compoundInfo = block as ICMCompoundStatementInfo;
if (compoundInfo.InternalResultVarialbes.Select(p => p.RawValue).Intersect(sDependent).Any())
{
return false;
}
if (!compoundInfo.CommutesWithGatingExpressions(sInfo))
{
return false;
}
}
// If we are going to try to lift past a loop, we have to make sure the statement is idempotent.
if (block is IStatementLoop && !StatementIdempotent(sToPop))
{
return false;
}
// And the next figure out where we are in the list of statements.
var nPrevStatements = nParent.Statements.TakeWhile(ps => ps != block).Reverse();
var nFollowStatements = nParent.Statements.SkipWhile(ps => ps != block).Skip(1);
// And repeat one level up with some tail recursion!
var statementMoved = FindEquivalentAboveAndCombine(nParent, sToPop, nPrevStatements, nFollowStatements, block);
// There is one other thing to try. If we couldn't move it above us (e.g. statementMoved is false), it could be
// we can leave the statement here, rather than in its original location.
if (!statementMoved)
{
var parentsToBlock = sToPop
.WalkParents(false)
.TakeWhile(s => s != block)
.Concat(new IStatementCompound[] { block }).ToArray();
// If no lifting out of some statement between us and the statement, then don't do it.
var parentsNotOK = parentsToBlock
.Where(s => s is ICMCompoundStatementInfo)
.Cast<ICMCompoundStatementInfo>()
.Where(s => !s.AllowNormalBubbleUp);
if (parentsNotOK.Any())
{
return false;
}
// The next thing we have to double check is that we can do the lifting, and nothing we are going to
// lift is going to impact some variable.
var dependents = sInfo.DependentVariables;
var dependentAffected = parentsToBlock
.Select(p => p.CheckForVariableAsInternalResult(dependents))
.Where(t => t);
if (dependentAffected.Any())
{
return false;
}
return MoveStatement(sToPop, block);
}
return statementMoved;
}
private static void WriteParts(IEnumerable<string> parts, IDataWriter dataWriter)
{
foreach (var part in parts.TakeWhile(part => part.Length != 0))
{
dataWriter.WriteByte((byte)part.Length);
dataWriter.WriteString(part);
}
dataWriter.WriteByte(0);
}
private static string GetVzzualResponseWithMultipartRequest(HttpClient client, string relativeUrl, IEnumerable<KeyValuePair<string, string>> headers, IEnumerable<KeyValuePair<string, string>> files, out HttpStatusCode statusCode)
{
if (client == null) throw new ArgumentNullException("client");
if (string.IsNullOrEmpty(relativeUrl)) throw new ArgumentNullException("relativeUrl");
using (var requestContent = new MultipartFormDataContent())
{
if (files != null)
{
foreach (var keyValuePair in files.TakeWhile(keyValuePair => keyValuePair.Value.Any()))
{
//Read file
var fileBytes = File.ReadAllBytes(keyValuePair.Value);
//Add file to request
var fileContent = new ByteArrayContent(fileBytes);
fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
Name = keyValuePair.Key,
FileName = Path.GetFileName(keyValuePair.Value)
};
requestContent.Add(fileContent);
}
}
//Add headers
if (headers != null)
{
foreach (var keyValuePair in headers.TakeWhile(keyValuePair => keyValuePair.Value.Any()))
{
requestContent.Add(new StringContent(keyValuePair.Value), keyValuePair.Key);
}
}
using (var responseMessage = client.PostAsync(relativeUrl, requestContent).Result)
{
statusCode = responseMessage.StatusCode;
return responseMessage.Content.ReadAsStringAsync().Result;
}
}
}
/// <summary>
/// Returns elements from a sequence until a specified condition is true.
/// </summary>
/// <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
/// <param name="source">A sequence to return elements from.</param>
/// <param name="predicate">A function to test each element for a condition.</param>
/// <returns>An <see cref="IEnumerable{T}"/> that contains the elements from the input sequence that occur before the first element at which the test passes.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
public static IEnumerable <T> TakeUntil <T>(this IEnumerable <T> source, Func <T, bool> predicate)
{
return(source.TakeWhile(x => !predicate(x)));
}
//takewhile public static IEnumerable <TSource> q <TSource>(this IEnumerable <TSource> input, Func <TSource, Boolean> predicate) => input.TakeWhile(predicate);
/// <summary>
/// See if we can move the statement to the front of the line.
/// </summary>
/// <param name="statementToMove"></param>
/// <param name="statements"></param>
/// <returns></returns>
private static bool MoveFirst(IStatement statementToMove, IEnumerable<IStatement> statements)
{
// Walk backwards through previous statements
var prevStatements = statements.TakeWhile(s => s != statementToMove).Reverse();
// See if we can move.
foreach (var s in prevStatements)
{
if (!StatementCommutes(s, statementToMove))
{
return false;
}
}
// If we can commute everywhere, then we are done!
return true;
}
/// <summary>
/// Calculates the prime factors of the current instance.
/// </summary>
/// <param name="i">The current instance.</param>
/// <param name="primes">An array of primes.</param>
/// <returns>The prime factors of the current instance.</returns>
public static IEnumerable<int> PrimeFactors(this int i, IEnumerable<int> primes)
{
Contract.Requires(i >= 0);
if (i <= 1) yield break;
foreach (int prime in primes.TakeWhile(p => p <= i))
{
while (i % prime == 0)
{
yield return prime;
i /= prime;
}
if (i == 1) yield break;
}
}
public static NoSpaceExpression Produce(IEnumerable<Symbol> symbols)
{
// nospace-expression = open-parenthesis expression close-parenthesis
// / numerical-constant
// / prefix-operator expression
// / expression infix-operator expression
if (!symbols.Any())
{
return null;
}
// expression, infix-operator, expression
var z = symbols.Rollup(0,
(t, d) => {
if (t is OpenParenthesis)
{
return d + 1;
}
if (t is ClosedParenthesis)
{
return d - 1;
}
return d;
}
);
var symbolsWithIndex = symbols.Select((s, i) => new
{
Symbol = s,
Index = i,
});
var z2 = symbolsWithIndex.Zip(z, (v1, v2) => new
{
SymbolWithIndex = v1,
Depth = v2,
});
var operatorList = z2.Where(x =>
x.Depth == 0 &&
x.SymbolWithIndex.Index != 0 &&
InfixOperator.Produce(x.SymbolWithIndex.Symbol) != null
).ToList();
if (operatorList.Any())
{
int minPrecedence = operatorList.Select(o2 =>
OperatorPrecedence[o2.SymbolWithIndex.Symbol.ToString()]
).Min();
var op = operatorList.Last(o2 =>
OperatorPrecedence[o2.SymbolWithIndex.Symbol.ToString()] ==
minPrecedence
);
if (op != null)
{
var expressionTokenList1 = symbols.TakeWhile(t =>
t != op.SymbolWithIndex.Symbol);
Expression e1 = Expression.Produce(expressionTokenList1);
if (e1 == null)
{
throw new ParserException("Invalid expression");
}
var expressionTokenList2 = symbols.SkipWhile(t =>
t != op.SymbolWithIndex.Symbol).Skip(1);
Expression e2 = Expression.Produce(expressionTokenList2);
if (e2 == null)
{
throw new ParserException("Invalid expression");
}
InfixOperator io = new InfixOperator(op.SymbolWithIndex.Symbol);
return new NoSpaceExpression(e1, io, e2);
}
}
if (symbols.First() is OpenParenthesis &&
symbols.Last() is ClosedParenthesis)
{
Expression e = Expression.Produce(symbols.Skip(1).SkipLast(1));
if (e != null)
{
return new NoSpaceExpression(new OpenParenthesis(), e,
new ClosedParenthesis());
}
}
NumericalConstant n = NumericalConstant.Produce(symbols);
if (n != null)
{
return new NoSpaceExpression(n);
}
PrefixOperator p = PrefixOperator.Produce(symbols.FirstOrDefault());
if (p != null)
{
Expression e = Expression.Produce(symbols.Skip(1));
if (e != null)
{
return new NoSpaceExpression(p, e);
}
}
return null;
}
private static List<short> UploadBinaryFiles(IEnumerable<Tuple<FileFormat, byte[]>> files, int fileCountLimit)
{
var uploadImages = new List<short>();
foreach (var file in files.TakeWhile(file => uploadImages.Count < fileCountLimit)) {
uploadImages.Add(UploadImage(default(int), file.Item1, file.Item2));
}
return uploadImages;
}
protected IEnumerable<string[]> SplitByBoundary(IEnumerable<string> texts, params string[] separators)
{
Func<string, bool> predicate = t => separators.Contains(t) == false;
while (texts.Any())
{
var bound = texts.TakeWhile(predicate).ToArray();
yield return bound;
texts = texts.SkipWhile(predicate).Skip(1);
}
}
public Solver(IEnumerable <string> input)
{
rulesInput = input.TakeWhile(s => !string.IsNullOrEmpty(s)).ToList();
wordsInput = input.SkipWhile(s => !string.IsNullOrEmpty(s)).Skip(1).ToList();
}
