public void AddPolygon(int count, IEnumerable<int> indices, int? tag)
{
PrevalidateGeometry();
//Error out on polygons not matching, for the sake of being consistent with AW and other RWX loaders.
if(indices.Count() != count)
{
throw new InvalidOperationException("Polygon vertex count mismatch.");
}
_currentMeshGeometry.Faces.Add(new Face
{
Indices = indices.ToList(),
MaterialId = _model.AddMaterial(_currentMaterial),
Tag = tag,
Triangles = TessellatePolygon(indices).ToList()
});
if(_currentMaterial.MaterialMode == MaterialMode.Double)
{
_currentMeshGeometry.Faces.Add(new Face
{
Indices = indices.Reverse().ToList(),
MaterialId = _model.AddMaterial(_currentMaterial),
Tag = tag,
Triangles = TessellatePolygon(indices.Reverse()).ToList()
});
}
}
public IActionResult NotificationsPartial(string sort, int page)
{
int entitiesPerPage = 10;
User owner = userRepo.GetByEmail(User.Identity.Name);
IEnumerable <Notification> notifications = notificationRepo.GetAllByUserId(owner.Id);
if (sort == "track")
{
notifications = notifications.Where(n => n.Type == NotificationType.PriceTrack);
}
else if (sort == "purchase")
{
notifications = notifications.Where(n => n.Type == NotificationType.Purchase);
}
else if (sort == "order")
{
notifications = notifications.Where(n => n.Type == NotificationType.Sale);
}
else if (sort == "report")
{
notifications = notifications.Where(n => n.Type == NotificationType.Report);
}
List <Notification> list = notifications?.Reverse().Skip((page - 1) * entitiesPerPage).Take(entitiesPerPage).ToList();
int pageAmount = (int)Math.Ceiling(list.Count() / (double)entitiesPerPage);
Console.WriteLine(pageAmount);
NotificationsVM vm = new NotificationsVM(list, page, pageAmount);
return(PartialView(vm));
}
/// <summary>
/// Implementation using kill
/// </summary>
/// <param name="pids"></param>
internal static void KillImpl (IEnumerable<int> pids)
{
using (Process quit = new Process ()) {
quit.StartInfo.FileName = "kill";
quit.StartInfo.Arguments = "-QUIT ";
foreach (int pid in pids.Reverse()) {
quit.StartInfo.Arguments += pid.ToString () + " ";
}
quit.StartInfo.UseShellExecute = false;
quit.Start ();
if (!quit.WaitForExit (1000 * 15 /* 15 seconds */))
throw new ApplicationException (string.Format ("The 'kill -QUIT' process didn't exit in 15 seconds."));
}
using (Process kill = new Process ()) {
kill.StartInfo.FileName = "kill";
kill.StartInfo.Arguments = "-9 ";
foreach (int pid in pids) {
kill.StartInfo.Arguments += pid.ToString () + " ";
}
kill.StartInfo.UseShellExecute = false;
kill.Start ();
if (!kill.WaitForExit (1000 * 15 /* 15 seconds */))
throw new ApplicationException (string.Format ("The 'kill' process didn't exit in 15 seconds."));
}
}
static public MotionParam KeyboardPressCombined(
this IEnumerable <VirtualKeyCode> setKey) =>
new MotionParam
{
KeyDown = setKey?.ToArray(),
KeyUp = setKey?.Reverse()?.ToArray(),
};
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="indexPath">The path of indexes from the root <c>content.json</c> to this patch; see <see cref="IPatch.IndexPath"/>.</param>
/// <param name="path">The path to the patch from the root content file.</param>
/// <param name="assetName">The normalized asset name to intercept.</param>
/// <param name="conditions">The conditions which determine whether this patch should be applied.</param>
/// <param name="fromAsset">The asset key to load from the content pack instead.</param>
/// <param name="fromArea">The map area from which to read tiles.</param>
/// <param name="patchMode">Indicates how the map should be patched.</param>
/// <param name="toArea">The map area to overwrite.</param>
/// <param name="mapProperties">The map properties to change when editing a map, if any.</param>
/// <param name="mapTiles">The map tiles to change when editing a map.</param>
/// <param name="addWarps">The warps to add to the location.</param>
/// <param name="textOperations">The text operations to apply to existing values.</param>
/// <param name="updateRate">When the patch should be updated.</param>
/// <param name="contentPack">The content pack which requested the patch.</param>
/// <param name="parentPatch">The parent patch for which this patch was loaded, if any.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="reflection">Simplifies access to private code.</param>
/// <param name="normalizeAssetName">Normalize an asset name.</param>
public EditMapPatch(int[] indexPath, LogPathBuilder path, IManagedTokenString assetName, IEnumerable <Condition> conditions, IManagedTokenString fromAsset, TokenRectangle fromArea, TokenRectangle toArea, PatchMapMode patchMode, IEnumerable <EditMapPatchProperty> mapProperties, IEnumerable <EditMapPatchTile> mapTiles, IEnumerable <IManagedTokenString> addWarps, IEnumerable <TextOperation> textOperations, UpdateRate updateRate, IContentPack contentPack, IPatch parentPatch, IMonitor monitor, IReflectionHelper reflection, Func <string, string> normalizeAssetName)
: base(
indexPath: indexPath,
path: path,
type: PatchType.EditMap,
assetName: assetName,
fromAsset: fromAsset,
conditions: conditions,
updateRate: updateRate,
contentPack: contentPack,
parentPatch: parentPatch,
normalizeAssetName: normalizeAssetName
)
{
this.FromArea = fromArea;
this.ToArea = toArea;
this.PatchMode = patchMode;
this.MapProperties = mapProperties?.ToArray() ?? new EditMapPatchProperty[0];
this.MapTiles = mapTiles?.ToArray() ?? new EditMapPatchTile[0];
this.AddWarps = addWarps?.Reverse().ToArray() ?? new IManagedTokenString[0]; // reversing the warps allows later ones to 'overwrite' earlier ones, since the game checks them in the listed order
this.TextOperations = textOperations?.ToArray() ?? new TextOperation[0];
this.Monitor = monitor;
this.Reflection = reflection;
this.Contextuals
.Add(this.FromArea)
.Add(this.ToArea)
.Add(this.MapProperties)
.Add(this.MapTiles)
.Add(this.AddWarps)
.Add(this.TextOperations);
}
public void VisitNodes( IEnumerable<DependencyObject> nodes )
{
if( nodes == null )
return;
m_collection.AddRange( nodes.Reverse() );
}
/// <summary>Creates a new instance of the <see cref="T:System.Net.Http.HttpClient" /> which should be pipelined.</summary>
/// <returns>A new instance of the <see cref="T:System.Net.Http.HttpClient" /> which should be pipelined.</returns>
/// <param name="innerHandler">The inner handler which is responsible for processing the HTTP response messages.</param>
/// <param name="handlers">The list of HTTP handler that delegates the processing of HTTP response messages to another handler.</param>
public static HttpMessageHandler CreatePipeline(HttpMessageHandler innerHandler, IEnumerable<DelegatingHandler> handlers)
{
if (innerHandler == null)
{
throw Error.ArgumentNull("innerHandler");
}
if (handlers == null)
{
return innerHandler;
}
HttpMessageHandler handler = innerHandler;
foreach (DelegatingHandler handler2 in handlers.Reverse<DelegatingHandler>())
{
if (handler2 == null)
{
// todo: reenable error throw
throw Error.Argument("handlers", FSR.DelegatingHandlerArrayContainsNullItem, new object[] { typeof(DelegatingHandler).Name });
}
if (handler2.InnerHandler != null)
{
// todo: reenable error throw
throw Error.Argument("handlers", FSR.DelegatingHandlerArrayHasNonNullInnerHandler, new object[] { typeof(DelegatingHandler).Name, "InnerHandler", handler2.GetType().Name });
}
handler2.InnerHandler = handler;
handler = handler2;
}
return handler;
}
/// <summary>
/// Creates an instance of an <see cref="HttpMessageHandler"/> using the <see cref="DelegatingHandler"/> instances
/// provided by <paramref name="handlers"/>. The resulting pipeline can be used to manually create <see cref="HttpClient"/>
/// or <see cref="HttpMessageInvoker"/> instances with customized message handlers.
/// </summary>
/// <param name="innerHandler">The inner handler represents the destination of the HTTP message channel.</param>
/// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as part
/// of sending an <see cref="HttpRequestMessage"/> and receiving an <see cref="HttpResponseMessage"/>.
/// The handlers are invoked in a top-down fashion. That is, the first entry is invoked first for
/// an outbound request message but last for an inbound response message.</param>
/// <returns>The HTTP message channel.</returns>
public static HttpMessageHandler CreatePipeline(HttpMessageHandler innerHandler, IEnumerable<DelegatingHandler> handlers)
{
if (innerHandler == null)
{
throw Error.ArgumentNull("innerHandler");
}
if (handlers == null)
{
return innerHandler;
}
// Wire handlers up in reverse order starting with the inner handler
HttpMessageHandler pipeline = innerHandler;
IEnumerable<DelegatingHandler> reversedHandlers = handlers.Reverse();
foreach (DelegatingHandler handler in reversedHandlers)
{
if (handler == null)
{
throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayContainsNullItem, typeof(DelegatingHandler).Name);
}
if (handler.InnerHandler != null)
{
throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayHasNonNullInnerHandler, typeof(DelegatingHandler).Name, "InnerHandler", handler.GetType().Name);
}
handler.InnerHandler = pipeline;
pipeline = handler;
}
return pipeline;
}
public static SchedulerStats GatherOveralStatistics(IEnumerable<WorkItem> _work)
{
var stats = new SchedulerStats();
stats.CurrentJobs = _work
.Reverse()
.Select(x => new SchedulerJobStats
{
WorkKey = x.WorkKey,
Description = x.Description,
CurrentStatus = (SchedulerJobStatus)x.Status,
LastRunStarted = x.LastStart,
LastRunCompleted = x.LastComplete,
PreviousRuns = x.PreviousRuns.Select(xx => new SchedulerJobRunStats
{
Started = xx.Started,
Completed = xx.Completed,
Result = (SchedulerJobRunResult)xx.Result,
ResultMessage = xx.ResultMessage
}).ToList()
}).ToList();
stats.PendingJobs = stats.CurrentJobs.Count(x => x.CurrentStatus == SchedulerJobStatus.Pending);
stats.RunningJobs = stats.CurrentJobs.Count(x => x.CurrentStatus == SchedulerJobStatus.Running);
stats.ScheduledJobs = stats.CurrentJobs.Count(x => x.CurrentStatus == SchedulerJobStatus.Scheduled);
return stats;
}
static void run(IEnumerable<String> filePaths)
{
var p = new Parser();
var modules = new Dictionary<String, IReadOnlyList<IClassItem>>();
foreach (var path in filePaths.Reverse())
{
Contract.Assume(path != null);
var txt = File.ReadAllText(path);
var items = p.Parse(txt, ValidationList);
modules.Add(Path.GetFileNameWithoutExtension(path), items.Cast<IClassItem>().ToList());
}
var preludeTxt = File.ReadAllText(libPath + "prelude.ef");
var preludeTxtItems = p.Parse(preludeTxt, ValidationList);
var rw = new Rewriter();
var prog = rw.MakeProgram(preludeTxtItems.Cast<Declr>().ToList(), modules);
var n = new Namer();
n.Name(prog, ValidationList);
var ti = new TypeInferer();
ti.VisitDeclr(prog.GlobalModule);
var i = new Interpreter();
var res = i.Run(prog, ValidationList);
Console.Write("Result: ");
Console.WriteLine(res.Accept(DefaultPrinter));
}
/// <summary>
/// Convert a list of digits into a number.
/// </summary>
/// <param name="DigitsToConvertToANumber">Digits to convert to a number</param>
/// <returns>The combined number</returns>
private static int ArrayOfSingleDigitsToNumber(IEnumerable<int> DigitsToConvertToANumber)
{
//ie:
//[0] = 3
//[1] = 5
//[2] = 7
// ==> 357
//tally
var RunningTally = 0;
//what we multiple with
var MultiplyValue = 1;
//loop through all of them and multiple everything
foreach (var Digit in DigitsToConvertToANumber.Reverse())
{
//multiply and add it
RunningTally += Digit * MultiplyValue;
//now multiple by 10
MultiplyValue *= 10;
}
//return the result
return RunningTally;
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="indexPath">The path of indexes from the root <c>content.json</c> to this patch; see <see cref="IPatch.IndexPath"/>.</param>
/// <param name="path">The path to the patch from the root content file.</param>
/// <param name="assetName">The normalized asset name to intercept.</param>
/// <param name="conditions">The conditions which determine whether this patch should be applied.</param>
/// <param name="fromAsset">The asset key to load from the content pack instead.</param>
/// <param name="fromArea">The map area from which to read tiles.</param>
/// <param name="patchMode">Indicates how the map should be patched.</param>
/// <param name="toArea">The map area to overwrite.</param>
/// <param name="mapProperties">The map properties to change when editing a map, if any.</param>
/// <param name="mapTiles">The map tiles to change when editing a map.</param>
/// <param name="addWarps">The warps to add to the location.</param>
/// <param name="textOperations">The text operations to apply to existing values.</param>
/// <param name="updateRate">When the patch should be updated.</param>
/// <param name="contentPack">The content pack which requested the patch.</param>
/// <param name="parentPatch">The parent patch for which this patch was loaded, if any.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
/// <param name="parseAssetName">Parse an asset name.</param>
public EditMapPatch(int[] indexPath, LogPathBuilder path, IManagedTokenString assetName, IEnumerable <Condition> conditions, IManagedTokenString?fromAsset, TokenRectangle?fromArea, TokenRectangle?toArea, PatchMapMode patchMode, IEnumerable <EditMapPatchProperty>?mapProperties, IEnumerable <EditMapPatchTile>?mapTiles, IEnumerable <IManagedTokenString>?addWarps, IEnumerable <ITextOperation>?textOperations, UpdateRate updateRate, IContentPack contentPack, IPatch?parentPatch, IMonitor monitor, Func <string, IAssetName> parseAssetName)
: base(
indexPath: indexPath,
path: path,
type: PatchType.EditMap,
assetName: assetName,
fromAsset: fromAsset,
conditions: conditions,
updateRate: updateRate,
contentPack: contentPack,
parentPatch: parentPatch,
parseAssetName: parseAssetName
)
{
this.FromArea = fromArea;
this.ToArea = toArea;
this.PatchMode = patchMode;
this.MapProperties = mapProperties?.ToArray() ?? Array.Empty <EditMapPatchProperty>();
this.MapTiles = mapTiles?.ToArray() ?? Array.Empty <EditMapPatchTile>();
this.AddWarps = addWarps?.Reverse().ToArray() ?? Array.Empty <IManagedTokenString>(); // reversing the warps allows later ones to 'overwrite' earlier ones, since the game checks them in the listed order
this.TextOperations = textOperations?.ToArray() ?? Array.Empty <ITextOperation>();
this.Monitor = monitor;
this.Contextuals
.Add(this.FromArea)
.Add(this.ToArea)
.Add(this.MapProperties)
.Add(this.MapTiles)
.Add(this.AddWarps)
.Add(this.TextOperations);
}
public static void BreathFirstStep <T>(this IEnumerable <ITree <T> > ext, Action <ITree <T> > reduce, bool rootToLeaf = true, bool leftToRight = true)
{
if (ext == null || ext.Count() == 0)
{
return;
}
IEnumerable <ITree <T> > items = (leftToRight ?
ext : ext?.Reverse()) ?? new List <ITree <T> >();
if (rootToLeaf)
{
foreach (ITree <T> item in items)
{
reduce(item);
}
}
(ext?.SelectMany(p => p.Branches) ?? new List <ITree <T> >()).BreathFirstStep(reduce, rootToLeaf, leftToRight);
if (!rootToLeaf)
{
foreach (ITree <T> item in items)
{
reduce(item);
}
}
}
internal string ExpandString(IEnumerable<object> expandedValues)
{
expandedValues = expandedValues.Reverse();
var exValEnumerator = expandedValues.GetEnumerator();
var resultStr = new StringBuilder();
string rest = Value;
// we expand this string in reversed order so we don't need to adjust start indexes
foreach (var item in NestedExpressions.Reverse())
{
if (!exValEnumerator.MoveNext())
{
break;
}
// first find the relative position of the expandable part inside our string
string value = LanguagePrimitives.ConvertTo<string>(exValEnumerator.Current);
var relStart = item.Extent.StartOffset - Extent.StartOffset - 1;
var relEnd = item.Extent.EndOffset - Extent.StartOffset - 1;
// the end are constant words between this expression and the last resolved expression
// we need to resolve escape constants before adding it
var resolvedEnd = StringExpressionHelper.ResolveEscapeCharacters(rest.Substring(relEnd), StringConstantType);
// as we do it in reverse order: insert at the beginning, in reverse order
resultStr.Insert(0, resolvedEnd).Insert(0, value);
// finally strip the rest which needs to be expanded
rest = rest.Substring(0, relStart);
}
// now insert the rest at the beginning (other constant string)
resultStr.Insert(0, StringExpressionHelper.ResolveEscapeCharacters(rest, StringConstantType));
return resultStr.ToString();
}
/// <summary>
/// Creates a set of new Sound Resources based on the specified AudioData, saves it and returns references to it.
/// The incoming AudioData is automatically grouped to the least number of Sounds, according to naming and path conventions.
/// </summary>
/// <param name="baseRes"></param>
/// <returns></returns>
public static List<ContentRef<Sound>> CreateMultipleFromAudioData(IEnumerable<ContentRef<AudioData>> baseRes)
{
char[] trimEndChars = new []{'0','1','2','3','4','5','6','7','8','9','_','-','.','#','~'};
List<ContentRef<AudioData>> sourceData = baseRes.Reverse().ToList();
List<ContentRef<Sound>> result = new List<ContentRef<Sound>>();
// Split data into singular data and grouped data
while (sourceData.Count > 0)
{
ContentRef<AudioData> data = sourceData[sourceData.Count - 1];
string mutualName = data.Name.TrimEnd(trimEndChars);
string mutualDir = System.IO.Path.GetDirectoryName(data.Path);
// Group similar AudioData
List<ContentRef<AudioData>> localGroup = new List<ContentRef<AudioData>>();
for (int i = sourceData.Count - 1; i >= 0; i--)
{
if (System.IO.Path.GetDirectoryName(sourceData[i].Path) != mutualDir) continue;
if (!sourceData[i].Name.StartsWith(mutualName)) continue;
localGroup.Add(sourceData[i]);
sourceData.RemoveAt(i);
}
result.Add(Sound.CreateFromAudioData(localGroup, localGroup.Count > 1 ? mutualName : null));
}
return result;
}
public static List<MinimalJobStats> GatherCurrentJobs(IEnumerable<JobItem> work, string filter)
{
return work
.Reverse()
.Where(x =>
{
if (String.IsNullOrWhiteSpace(filter) || filter == "all")
{
return true;
}
if (filter == "running" && x.Status == JobStatus.Running)
{
return true;
}
if (filter == "failing" && GatherJobHealth(x) == JobHealth.Bad)
{
return true;
}
return false;
})
.Select(x => new MinimalJobStats
{
JobKey = x.JobKey,
Description = x.Description,
CurrentStatus = (InlineScheduler.JobStatus)x.Status,
Health = GatherJobHealth(x),
Report = GatherJobReport(x)
}).ToList();
}
public virtual void InsertToCheckUpdateQueue(IEnumerable <string> productIds, bool forceCheckUpdate = false)
{
foreach (var productId in productIds?.Reverse() ?? Enumerable.Empty <string>())
{
InsertToCheckUpdateQueue(productId, forceCheckUpdate);
}
}
public ForecastEntry Forecast(IEnumerable<DataEntry> dataEntries, int period, dynamic strategyParameters)
{
if (period - 1 < 0)
return null;
int numberOfPeriods = strategyParameters.PeriodCount;
if (numberOfPeriods > dataEntries.Count())
throw new ArgumentException("The number of periods can not be greater than the number of entries.");
double value;
if (dataEntries.Count() == 1 || period == 1)
value = dataEntries.ElementAt(0).Value;
else if (period < numberOfPeriods)
value = dataEntries.ElementAt(period - 1).Value;
else if (dataEntries.Count() > 1 && period <= dataEntries.Count() + 1)
value =
dataEntries.Take(period - 1).Reverse().Take(numberOfPeriods).Reverse().Sum(entry => (entry.Value))/
numberOfPeriods;
else
value = dataEntries.Reverse().Take(numberOfPeriods).Reverse().Sum(entry => (entry.Value))/
numberOfPeriods;
return new ForecastEntry
{
Period = period,
DataEntry = period > dataEntries.Count() ? dataEntries.Last() : dataEntries.ElementAt(period - 1),
ForecastValue = value,
ConfidenceIntervalLow = value,
ConfidenceIntervalHigh = value,
IsHoldout = period > dataEntries.Count()*0.7 //holdout data is always 70 percent
};
}
/// <summary>
/// Inserts a group of instructions after the target instruction
/// </summary>
public static void InsertAfter(this Mono.Cecil.Cil.ILProcessor processor, Instruction target, IEnumerable<Instruction> instructions)
{
foreach (var instruction in instructions.Reverse())
{
processor.InsertAfter(target, instruction);
}
}
public void AddRange(Player player, IEnumerable<Card> cardCollection, DeckPosition deckPosition)
{
switch (deckPosition)
{
case DeckPosition.Top:
_Cards.InsertRange(0, cardCollection.Reverse());
break;
case DeckPosition.Bottom:
_Cards.AddRange(cardCollection);
break;
}
this.Sort();
if (cardCollection.Count() > 0)
{
if (_AsynchronousChanging)
{
if (_AsynchronousPileChangedEventArgs == null)
_AsynchronousPileChangedEventArgs = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
else
_AsynchronousPileChangedEventArgs.AddedCards.AddRange(cardCollection);
}
else if (PileChanged != null)
{
lock (PileChanged)
{
PileChangedEventArgs pcea = new PileChangedEventArgs(player, PileChangedEventArgs.Operation.Added, cardCollection);
PileChanged(this, pcea);
}
}
}
}
public EsiFragmentParser(
IReadOnlyDictionary <string, IEsiFragmentParser> parsers,
IEnumerable <IFragmentParsePipeline> pipelines)
{
_parsers = parsers ?? throw new ArgumentNullException(nameof(parsers));
_pipelines = pipelines?.Reverse().ToArray() ?? throw new ArgumentNullException(nameof(pipelines));
}
/// <summary>
/// Standard constructor
/// </summary>
public RationalPolynom(IEnumerable <BigRational> items)
{
m_Items = items
?.Reverse()
?.SkipWhile(x => x == 0)
?.Reverse()
?.ToList() ?? throw new ArgumentNullException(nameof(items));
}
static public MotionResult KeyboardPressCombined(
this IHostToScript sanderling,
IEnumerable <VirtualKeyCode> setKey) =>
sanderling?.MotionExecute(new Motor.MotionParam()
{
KeyDown = setKey?.ToArray(),
KeyUp = setKey?.Reverse()?.ToArray(),
});
/// <summary>
/// Initializes a new instance of the <see cref="ScriptReader"/> class.
/// </summary>
/// <param name="tokens">The tokens.</param>
public ScriptReader(IEnumerable<string> tokens)
{
#region Contract
// Contract.Requires<ArgumentNullException>(tokens != null);
#endregion
this.tokens = new Stack<string>(tokens.Reverse());
}
public static IArrayFunctionInstance ToInstance(IEnumerable<IFunctionInstance> enumerable)
{
IArrayFunctionInstance tail = ArrayTailFunction.Instance;
foreach (IFunctionInstance t in enumerable.Reverse()) {
tail = new ArrayHeadTailFunctionInstance (t, tail);
}
return tail;
}
public static int Insert(this Collection<Instruction> collection, int index, IEnumerable<Instruction> instructions)
{
foreach (var instruction in instructions.Reverse())
{
collection.Insert(index, instruction);
}
return index + instructions.Count();
}
private static IDictionary<string, object> NamedArgumentsToDictionary(IEnumerable<string> argumentNames, IEnumerable<object> args)
{
return argumentNames
.Reverse()
.Zip(args.Reverse(), (k, v) => new KeyValuePair<string, object>(k, v))
.Reverse()
.ToDictionary(StringComparer.InvariantCultureIgnoreCase);
}
public TMSimulation(TM machine, IEnumerable<Character> chars)
{
this.CurrentState = machine.BeginState;
foreach (Character c in chars.Reverse()) {
RStack.Push (c);
}
this.Fix ();
}
public static void Insert(this MethodBody body, int index, IEnumerable<Instruction> instructions)
{
instructions = instructions.Reverse();
foreach (var instruction in instructions)
{
body.Instructions.Insert(index, instruction);
}
}
public static IDictionary<string, object> ArgumentsToDictionary(this InvokeMemberBinder binder, IEnumerable<object> args)
{
return args.Reverse()
.Zip(binder.CallInfo.ArgumentNames.Reverse().ExtendInfinite(), (v, k) => new KeyValuePair<string, object>(k, v))
.Reverse()
.Select((kvp, i) => kvp.Key == null ? new KeyValuePair<string, object>("_" + i.ToString(), kvp.Value) : kvp)
.ToDictionary();
}
public static Expression AggregateExpressionsIntoTuple (IEnumerable<Expression> expressions)
{
ArgumentUtility.CheckNotNull ("expressions", expressions);
return expressions
.Reverse ()
.Aggregate ((current, expression) => CreateTupleExpression (expression, current));
}
private static IDictionary<string, object> NamedArgumentsToDictionary(IEnumerable<string> argumentNames, IEnumerable<object> args)
{
return argumentNames
.Reverse()
.Zip(args.Reverse(), (k, v) => new KeyValuePair<string, object>(k, v))
.Reverse()
.ToDictionary();
}
public void Beweeg(IEnumerable<Point> stack)
{
foreach (var point in stack.Reverse())
{
_queue.Enqueue(point);
}
Start();
}
internal static IDictionary<string, object> NamedArgumentsToDictionary(this InvokeMemberBinder binder, IEnumerable<object> args)
{
return binder.CallInfo.ArgumentNames
.Reverse()
.Zip(args.Reverse(), (k, v) => new KeyValuePair<string, object>(k, v))
.Reverse()
.ToDictionary();
}
public static int CalculateSuccessInARow(PersonSetting personSetting, IEnumerable<BuildStatus> allActiveBuildDefinitionsOrderedChronoligically)
{
return allActiveBuildDefinitionsOrderedChronoligically
.Reverse()
.Where(i => i.RequestedBy == personSetting.RawName)
.TakeWhile(i => i.BuildStatusEnum != BuildStatusEnum.Broken)
.Count();
}
public void AddSupPops(IEnumerable<SubPop> pops)
{
this._speciesContainer.SuspendLayout();
foreach (SubPop sp in pops.Reverse())
{
this.AddSubPop(sp);
}
this._speciesContainer.ResumeLayout(false);
}
public ISymbolicDataAnalysisModel Backtransform(ISymbolicDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable) {
var symbolicModel = (ISymbolicDataAnalysisModel)model.Clone();
foreach (var transformation in transformations.Reverse()) {
ApplyBacktransformation(transformation, symbolicModel.SymbolicExpressionTree, targetVariable);
}
return symbolicModel;
}
/// <summary>
/// Restores every window in the list that is minimized
/// </summary>
/// <param name="windows">
/// A <see cref="IEnumerable"/>
/// </param>
public static void RestoreWindows (IEnumerable<Window> windows)
{
foreach (Window window in windows.Reverse ()) {
if (window.IsInViewport (window.Screen.ActiveWorkspace) && window.IsMinimized) {
window.Unminimize (Gtk.Global.CurrentEventTime);
System.Threading.Thread.Sleep (SleepTime);
}
}
}
public static string Fill(
this string src,
IEnumerable <QueryParams>?queryParams
)
{
if (queryParams?.Any() == false || string.IsNullOrEmpty(src))
{
return(src);
}
Dictionary <string, int> varNameCount = new();
var paramList = queryParams?.Reverse()
.SelectMany(x =>
{
var dicParams = x.DataModel?.GetDataModelParameters();
return(Regex.Matches(src, x.OpenMarker + QueryParams.RegexPattern + x.CloseMarker)
.Cast <Match>()
.Select(x => x.Groups["param"].Value)
.Where(x => !string.IsNullOrWhiteSpace(x))
.Distinct()
.Select(varName => new
{
VarName = varName,
NestedParamName =
$"@vxv_{(varNameCount.ContainsKey(varName) ? ++varNameCount[varName] : varNameCount[varName] = 1) }_{varName}"
,
x.OpenMarker,
x.CloseMarker,
x.NullReplacement,
Value = dicParams?.ContainsKey(varName) == true ? dicParams[varName] : null
}));
}).ToList();
if (paramList?.Count > 0)
{
foreach (var item in paramList)
{
if (item.Value == null)
{
src = src
.Replace(item.OpenMarker + item.VarName + item.CloseMarker,
item.NullReplacement, true,
CultureInfo.InstalledUICulture);
}
else
{
src = src
.Replace(item.OpenMarker + item.VarName + item.CloseMarker,
item.Value.ToString(), true,
CultureInfo.InvariantCulture);
}
}
}
return(src);
}
public HttpLoader(
HttpClientFactory httpClientFactory,
HttpRequestMessageFactory httpRequestMessageFactory,
IEnumerable <IHttpLoaderPipeline> pipelines,
Log log)
{
_httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
_httpRequestMessageFactory = httpRequestMessageFactory ?? throw new ArgumentNullException(nameof(httpRequestMessageFactory));
_log = log ?? throw new ArgumentNullException(nameof(log));
_pipelines = pipelines?.Reverse().ToArray() ?? throw new ArgumentNullException(nameof(pipelines));
}
public IActionResult Notifications()
{
int entitiesPerPage = 10;
User owner = userRepo.GetByEmail(User.Identity.Name);
IEnumerable <Notification> notifications = notificationRepo.GetAllByUserId(owner.Id);
List <Notification> list = notifications?.Reverse().Take(entitiesPerPage).ToList();
int pageAmount = (int)Math.Ceiling(list.Count() / (double)entitiesPerPage);
NotificationsVM vm = new NotificationsVM(list, 1, pageAmount);
return(View(vm));
}
public static int GetSequenceHashDirected <T>(this IEnumerable <T> items)
{
var hash = items.GetSequenceHash();
var reverseHash = items?
.Reverse()
.GetSequenceHash() ?? 0;
var result = hash < reverseHash
? hash
: reverseHash;
return(result);
}
public void OrderShapesBy(Type type = Type.Area, OrderBy orderBy = OrderBy.Asc)
{
IEnumerable <Shape> result = type switch
{
Type.Area => _shapes.OrderBy(x => x.Area),
Type.Perimeter => _shapes.OrderBy(x => x.Perimeter),
_ => null
};
if (orderBy == OrderBy.Desc)
{
_shapes = result?.Reverse().ToList();
}
_shapes = result?.ToList();
}
static IEnumerable <T> MirrorAndFuse <T>(IEnumerable <T> l) => l.Concat(l.Reverse <T>().Skip <T>(1));
private static IEnumerable <char> LastEndtWith(this IEnumerable <char> source, Predicate <char> select)
{
return(source.Reverse()
.FirstStartWith(select)
.Reverse());
}
/// <summary>
/// Processes stop will call the hosted process's Stop method and waiting for the result.
/// </summary>
internal void ProcessingStop()
{
lock (_lock)
{
if (_stopped)
{
return;
}
_stopped = true;
if (Status != HostStatus.Faulted)
{
Status = HostStatus.Stopping;
}
try
{
_cancellation.Cancel(true);
if (!_usingServiceEndpoints &&
_hostedProcessTypes != null && _hostedProcessTypes.Any())
{
foreach (Type processType in _hostedProcessTypes.Reverse())
{
var hostedProcess = _serviceProvider.GetService(processType);
try
{
_logger?.LogWarning($"Stopping {processType.Name}");
Task t = null;
if (hostedProcess is IHostedProcess process)
{
t = process.Stop();
}
else if (hostedProcess is IHostedService service)
{
t = service.StopAsync(_cancellation.Token);
}
t?.GetAwaiter().GetResult();
}
catch (Exception e)
{
_logger?.LogError(e, $"Error during \"Stop\" execution for {processType.Name}: {e.Message}");
}
}
}
}
catch (Exception e)
{
_logger?.LogError(e, $"Error stopping process host: {e.Message}");
}
finally
{
_logger?.LogWarning("Releasing KeepAliveEvent main app thread will exit");
_keepAliveEvent.Set();
_webHost?.Dispose();
_context.StopMonitor();
if (Status != HostStatus.Faulted)
{
Status = HostStatus.Stopped;
}
_logger?.LogInformation("Exiting app host");
}
}
}
public IEnumerable <T> TakeRight <T>(IEnumerable <T> collection, int count)
{
return(collection.Reverse().Take(count));
}
public IEnumerable <T> TakeRightWhile <T>(IEnumerable <T> collection, Func <T, bool> predicate)
{
return(collection.Reverse().TakeWhile(predicate));
}
private static string FormatPropertyChainDescription(IEnumerable <string> propertyChainDescription)
{
return(string.Join(".", propertyChainDescription.Reverse()));
}
public static TSource Pernultimate <TSource>(this IEnumerable <TSource> source)
{
//from http://stackoverflow.com/questions/8724179/linq-how-to-get-second-last
return(source.Reverse().Skip(1).Take(1).FirstOrDefault());
}
public static IEnumerable <TSource> TakeLast <TSource>(this IEnumerable <TSource> source, int count)
{
return(source.Reverse().Take(count).Reverse());
}
static void Main(string[] args)
{
if (args.Length < 1)
{
PrintHelp();
Environment.Exit(0);
}
int max_result = 35;
if (args.Length == 1)
{
PrintLogo();
}
if (args.Length == 2)
{
if (Int32.TryParse(args[1], out int max) && max <= 70)
{
max_result = max;
PrintLogo();
}
else
{
Console.WriteLine("The second argument has to be an integer and have a value lesser than 70."); Environment.Exit(0);
}
}
Auth.SetUserCredentials(
"qpHCXcV4IEap3T02zJHi234Ev",
"zjSizlzsC9YmN9qm1BTheXF4delq1CwALA7fBnykBtLCaMb946",
"316723929-0zRG0RzpDYRwMTw3UvgUu37wni0PHKJBU9IL5BKQ",
"cCJN2wIPubXBsNCBbVTRXzelIp9vHRXh9Jur5bF9SG52i"
);
void PrintLogo()
{
Console.WriteLine(" _____ _ _ _ _ ");
Console.WriteLine(" / ____| | | | | | | (_) ");
Console.WriteLine(" | | __ ___| |_| | ___ ___ __ _| |_ _ ___ _ __ ");
Console.WriteLine(@" | | |_ |/ _ \ __| | / _ \ / __/ _` | __| |/ _ \| '_ \ ");
Console.WriteLine(" | |__| | __/ |_| |___| (_) | (_| (_| | |_| | (_) | | | |");
Console.WriteLine(@" \_____|\___|\__|______\___/_\___\__,_|\__|_|\___/|_| |_|");
Console.WriteLine(" |__ __| (_) | | | ");
Console.WriteLine(" | |_ ___| |_| |_ ___ _ __ ");
Console.WriteLine(@" | \ \ /\ / / | __| __/ _ \ '__| ");
Console.WriteLine(@" | |\ V V /| | |_| || __/ | ");
Console.WriteLine(@" |_| \_/\_/ |_|\__|\__\___|_| ");
Console.WriteLine(@" ");
Console.WriteLine(@" [+] [email protected] ");
Console.WriteLine(@" [+] Created by Sharki. ");
}
void PrintHelp() => Console.WriteLine("Invalid username. Usage: [ProgramName.exe] + Target's username (@Example/example) to track. [Optional: (Integer) Maximum number of searches allowed < 70]");
string findLocation(List <string> locations)
{
IEnumerable <dynamic> query = locations.GroupBy(r => r)
.Select(grp => new
{
Location = grp.Key,
Count = grp.Count()
});
int n = 0;
foreach (var Q in query)
{
if (Q.Count > n)
{
n = Q.Count;
}
}
return(query.Where(x => x.Count == n).First().Location);
}
Tweetinvi.Models.IUser User = Tweetinvi.User.GetUserFromScreenName(args[0]);
if (User == null)
{
Console.WriteLine("This twitter's account doesn't exist or the rate limit has been reached");
Environment.Exit(0);
}
IEnumerable <long> People = User.FollowersCount < User.FriendsCount ? User.GetFollowerIds() : User.GetFriendIds();
List <string> Location_firstlist = new List <string>();
List <string> Location_secondlist = new List <string>();
int count = 0;
foreach (long person in People.Reverse())
{
var Relation = Friendship.GetRelationshipDetailsBetween(person, User.UserIdentifier);
if (Relation == null)
{
Console.WriteLine("Exception"); break;
}
if (Relation.Following && Relation.FollowedBy)
{
var person_ = Tweetinvi.User.GetUserFromId(person);
string[] Location = person_.Location.Split(',', '-');
if (Location[0] != "" && Location[0] != "??")
{
Location_firstlist.Add(Location[0]);
try { Location_secondlist.Add(Location[1]); } catch { };
count++;
Console.WriteLine("[+] ---> " + person_.ScreenName);
}
else
{
Console.WriteLine("[-] ---> " + person_.ScreenName);
}
}
if (count > max_result)
{
break;
}
}
Console.WriteLine("\nProbable location based on target's followers/follows {0}", findLocation(Location_firstlist));
Console.WriteLine("Probable zone/country based on target's followers/follows{0}", findLocation(Location_secondlist));
if (!String.IsNullOrEmpty(User.Location))
{
Console.WriteLine("User's set location: {0}", User.Location);
}
}
public static T Last <T>(this IEnumerable <T> items, int offset) => items.Reverse().Skip(offset).Take(1).First();
public static T LastOrDefault <T>(this IEnumerable <T> items, int offset)
{
return(items.Reverse().Skip(offset).Take(1).FirstOrDefault());
}
public static IEnumerable <T> Last <T>(this IEnumerable <T> source, int count)
{
return(source?.Reverse().Take(count).Reverse());
}
// Another name for IEnumerable.Reverse()
// This is useful to distinguish betweeh List.Reverse() when dealing with a list
public static IEnumerable <T> Reversed <T>(this IEnumerable <T> list)
{
return(list.Reverse());
}
public void Enqueue(IEnumerable <Tile> tiles)
{
PushRange(tiles.Reverse().ToArray());
}
/// <summary>
/// Combines several <see cref="IGlobalizationService"/>-instances to a single <see cref="CompoundGlobalizationService"/>.
/// </summary>
/// <param name="globalizationServices"> The <see cref="IGlobalizationService"/>s, starting with the least specific.</param>
public CompoundGlobalizationService(IEnumerable <IGlobalizationService> globalizationServices)
{
ArgumentUtility.CheckNotNull("globalizationServices", globalizationServices);
_globalizationServices = globalizationServices.Reverse().ToList().AsReadOnly();
}
/// <summary>
/// Insert a new search element under the category.
/// </summary>
/// <param name="entry">This could represent a function of a given
/// class. For example, 'MyAssembly.MyNamespace.MyClass.Foo'.</param>
/// <param name="categoryNames">A list of entries that make up the fully qualified
/// class name that contains function 'Foo', e.g. 'MyAssembly.MyNamespace.MyClass'.
/// </param>
internal void InsertEntry(NodeSearchElementViewModel entry, IEnumerable <string> categoryNames)
{
var nameStack = new Stack <string>(categoryNames.Reverse());
var target = libraryRoot;
string fullyQualifiedCategoryName = "";
ClassesNodeCategoryViewModel targetClass = null;
while (nameStack.Any())
{
var next = nameStack.Pop();
fullyQualifiedCategoryName = MakeFullyQualifiedName(fullyQualifiedCategoryName, next);
var categories = target.SubCategories;
NodeCategoryViewModel targetClassSuccessor = null;
var newTarget = categories.FirstOrDefault(c =>
{
// Each path has one class. We should find and save it.
if (c is ClassesNodeCategoryViewModel)
{
targetClass = c as ClassesNodeCategoryViewModel;
// As soon as ClassesNodeCategoryViewModel is found we should search
// through all it classes and save result.
targetClassSuccessor = c.SubCategories.FirstOrDefault(c2 => c2.Name == next);
return(targetClassSuccessor != null);
}
return(c.Name == next);
});
if (newTarget == null)
{
// For the first iteration, this would be 'MyAssembly', and the second iteration 'MyNamespace'.
var targetIsRoot = target == libraryRoot;
newTarget = targetIsRoot ? new RootNodeCategoryViewModel(next) : new NodeCategoryViewModel(next);
newTarget.FullCategoryName = fullyQualifiedCategoryName;
newTarget.Assembly = entry.Assembly;
// Situation when we to add only one new category and item as it child.
// New category should be added to existing ClassesNodeCategoryViewModel.
// Make notice: ClassesNodeCategoryViewModel is always first item in
// all subcategories.
if (nameStack.Count == 0 && !target.IsClassButton &&
target.SubCategories[0] is ClassesNodeCategoryViewModel)
{
target.SubCategories[0].SubCategories.Add(newTarget);
AddEntryToExistingCategory(newTarget, entry);
return;
}
// We are here when target is the class. New category should be added
// as child of it. So class will turn into usual category.
// Here we are take class, remove it from ClassesNodeCategoryViewModel
// and attach to it parrent.
if (targetClass != null)
{
if (targetClass.SubCategories.Remove(target))
{
targetClass.Parent.SubCategories.Add(target);
}
// Delete empty classes container.
if (targetClass.IsClassButton)
{
targetClass.Parent.SubCategories.RemoveAt(0);
}
targetClass.Dispose();
}
// Situation when we need to add only one new category and item.
// Before adding of it we need create new ClassesNodeCategoryViewModel
// as soon as new category will be a class.
if (nameStack.Count == 0 && !targetIsRoot)
{
targetClass = new ClassesNodeCategoryViewModel(target);
target.SubCategories.Insert(0, targetClass);
target.SubCategories[0].SubCategories.Add(newTarget);
AddEntryToExistingCategory(newTarget, entry);
return;
}
target.InsertSubCategory(newTarget);
// Proceed to insert the new entry under 'newTarget' category with the remaining
// name stack. In the first iteration this would have been 'MyNamespace.MyClass'.
InsertEntryIntoNewCategory(newTarget, entry, nameStack);
return;
}
// If we meet ClassesNodecategoryViewModel during the search of newTarget,
// next newTarget is specified in targetClassSuccessor.
if (targetClassSuccessor != null)
{
target = targetClassSuccessor;
}
else
{
target = newTarget;
}
}
AddEntryToExistingCategory(target, entry);
}
private void LoadButtons(IEnumerable<CustomDialogButtonInfo> buttons)
{
const int buttonMargin = 20;
var leftPosition = pnButtons.Width;
var buttonHeight = pnButtons.Height - buttonMargin;
var topPosition = (pnButtons.Height - buttonHeight) / 2;
foreach (var buttonInfo in buttons.Reverse().ToList())
{
var button = new ButtonX();
button.ColorTable = eButtonColor.OrangeWithBackground;
button.Text = buttonInfo.Title;
button.DialogResult = buttonInfo.DialogResult;
button.TextColor = Color.Black;
button.Height = buttonHeight;
button.Width = buttonInfo.Width;
button.Style = eDotNetBarStyle.StyleManagerControlled;
button.Top = topPosition;
button.Anchor = AnchorStyles.Top | AnchorStyles.Right;
leftPosition -= button.Width;
button.Left = leftPosition;
leftPosition -= buttonMargin;
pnButtons.Controls.Add(button);
}
}
