public static IEnumerable<ICommandOutput> CopyPackagesToRepositories(this IPackageManager manager,
DependencyResolutionResult dependencies,
IEnumerable<IPackageRepository> repositoriesToWriteTo)
{
if (manager == null) throw new ArgumentNullException("manager");
if (dependencies == null) throw new ArgumentNullException("dependencies");
if (repositoriesToWriteTo == null) throw new ArgumentNullException("repositoriesToWriteTo");
if (!dependencies.IsSuccess)
{
yield return DependencyResolutionFailed(dependencies);
yield break;
}
foreach (var dependency in dependencies.Dependencies)
{
// fast forward to the source repository
var repositoriesForDependency = repositoriesToWriteTo
.SkipWhile(x => x != dependency.Package.Source)
.Skip(1)
.ToList();
if (repositoriesForDependency.Count == 0)
repositoriesForDependency = repositoriesToWriteTo.ToList();
foreach (var repository in repositoriesForDependency.Where(x => x != null && x.CanPublish))
{
yield return new Result("Copying '{0}' to '{1}'", dependency.Package.FullName, repository.Name);
manager.UpdateDependency(dependency, repository);
}
}
}
static IEnumerable<string> GetConfig(IEnumerable<string> configLines, string configName)
{
// Read everything from [configName] up to the next [section].
return configLines
.SkipWhile(l => !l.StartsWith(string.Format("[{0}]", configName), StringComparison.OrdinalIgnoreCase))
.Skip(1)
.TakeWhile(l => !l.StartsWith("[", StringComparison.OrdinalIgnoreCase))
.Where(l => l.Contains('='));
}
private static TimeSpan GetInterval(IEnumerable<string> args)
{
return TimeSpan.FromMilliseconds(args
.SkipWhile(a => a != "-interval")
.Skip(1)
.Select(int.Parse)
.DefaultIfEmpty(100)
.First());
}
private static int GetInterval(IEnumerable<string> args)
{
return args
.SkipWhile(a => a != "-interval")
.Skip(1)
.Select(int.Parse)
.DefaultIfEmpty(100)
.First();
}
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);
}
private static IEnumerable<Station> GetNeighbors(Station source, IEnumerable<Station> sortedStations, int maxDeltaZ)
{
var maxZ = source.CartesianLocation.Z;
var minZ = maxZ - maxDeltaZ;
var stations = sortedStations.SkipWhile(station => station.CartesianLocation.Z >= maxZ)
.TakeWhile(station => station.CartesianLocation.Z >= minZ).ToList();
return stations;
}
public static IEnumerable<KeyValuePair<string, IEnumerable<string>>> ForSequence(
IEnumerable<Token> tokens)
{
return from t in tokens.Pairwise(
(f, s) =>
f.IsName()
? f.Text.ToKeyValuePair(tokens.SkipWhile(t => !t.Equals(f)).SkipWhile(t => t.Equals(f)).TakeWhile(v => v.IsValue()).Select(x => x.Text).ToArray())
: string.Empty.ToKeyValuePair())
where t.Key.Length > 0 && t.Value.Any()
select t;
}
private static IEnumerable<KeyValuePair<string, IEnumerable<string>>> SequenceTokensToKeyValuePairEnumerable(
IEnumerable<Token> tokens)
{
return from t in tokens.Pairwise(
(f, s) =>
f.IsName()
? CreateValue(f.Text, tokens.SkipWhile(t => t.Equals(f)).TakeWhile(v => v.IsValue()).Select(x => x.Text).ToArray())
: CreateValue(string.Empty))
where t.Key.Length > 0 && t.Value.Any()
select t;
}
public bool TryPatrol(IEnumerable<CityBlock> blocks)
{
var eligible = blocks.SkipWhile(x => x.IsPatrolled).ToArray();
if (eligible.Count() < DummyRange)
return false;
foreach (var block in eligible.Take(DummyRange))
block.Force = this;
return true;
}
public static List <string> ParseHtml(IEnumerable <string> lines)
{
return(lines
.SkipWhile(l => !l.Trim().Equals("*@"))
.Skip(1)
.SkipWhile(l => string.IsNullOrWhiteSpace(l))
.TakeWhile(l => !l.Trim().Equals("@code {"))
.Reverse()
.SkipWhile(l => string.IsNullOrWhiteSpace(l))
.Reverse()
.ToList());
}
private string GenerateName()
{
// a framework name is a random markov chain that terminates in a space.
IEnumerable <string> generatedName = nameGenerator.Generate();
var name = string.Join("",
generatedName.SkipWhile(c => !char.IsLetterOrDigit(c[0])).TakeWhile(c => c != " ")
);
return(name.IndexOf("js", StringComparison.OrdinalIgnoreCase) == -1
? name + ".js"
: name);
}
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 Result <IEnumerable <Token>, Error> PreprocessDashDash(
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.ValueForced);
return(tokenizerResult.Map(tokens => tokens.Concat(values)));
}
return(tokenizer(arguments));
}
private Month createMonthWithContainDaysOfDifferentMonth(IEnumerable <RelationalDay> days, DateTime monthFirstDay, DayOfWeek dayOfOrderStart)
{
RelationalDay firstDay = days.Reverse()
.SkipWhile(x => monthFirstDay < x.Day)
.FirstOrDefault(x => x.Day.DayOfWeek == dayOfOrderStart)
?? days.SkipWhile(x => x.Day < monthFirstDay).First();
Day previousWeekEndDay = new DateTime(firstDay.Day.Year, firstDay.Day.Month, firstDay.Day.DayOfMonth).AddDays(-1).ToDay();
var weeks = new List <Week>();
bool hasNextWeek = true;
while (hasNextWeek)
{
int count = 0;
List <RelationalDay> daysOfWeek = days.SkipWhile(x => x.Day < firstDay.Day)
.SkipWhile(x => x.Day <= previousWeekEndDay)
.Do(_ => count++)
.TakeWhile(x => count == 1 || x.Day.DayOfWeek != dayOfOrderStart)
.ToList();
if (daysOfWeek.Count != 0 && (weeks.Count != 0 && daysOfWeek.FirstOrDefault()?.Day?.Month == monthFirstDay.Month || weeks.Count == 0))
{
weeks.Add(new Week {
Days = daysOfWeek
});
previousWeekEndDay = daysOfWeek.Last().Day;
}
else
{
hasNextWeek = false;
}
}
return(new Month
{
Year = monthFirstDay.Year,
MonthOfYear = monthFirstDay.Month,
Weeks = weeks
});
}
private List <TaskDevice> getDevice()
{
IEnumerable <TaskDevice> filter = (IEnumerable <TaskDevice>)Common.getDeviecSorByDevice(CurTask.Type);
IEnumerable <TaskDevice> added = (IEnumerable <TaskDevice>)Common.getDeviecSorByTask(CurTask.Name);
string lastname = Common.GetLastTaskName(CurTask.Name);
string last2name = Common.GetLastTaskName(lastname);
IEnumerable <TaskDevice> lastadded = (IEnumerable <TaskDevice>)Common.getDeviecSorByTask(lastname, CurTask.Type);
IEnumerable <TaskDevice> last2added = (IEnumerable <TaskDevice>)Common.getDeviecSorByTask(last2name, CurTask.Type);
List <TaskDevice> temp = new List <TaskDevice>();
if (filter.Count() != 0)
{
temp = filter.ToList();
var remain = temp.RemoveAll(t => added.Any(a => a.ID == t.ID) || lastadded.Any(a => a.ID == t.ID) || last2added.Any(a => a.ID == t.ID));
foreach (TaskDevice item in temp)
{
item.GroupBy = GROUP_BY_Remain;
}
}
added = added.SkipWhile(t => string.IsNullOrEmpty(t.ID));
lastadded = lastadded.SkipWhile(t => string.IsNullOrEmpty(t.ID));
last2added = last2added.SkipWhile(t => string.IsNullOrEmpty(t.ID));
foreach (TaskDevice item in added)
{
item.GroupBy = GROUP_BY_Added;
}
temp.AddRange(added);
foreach (TaskDevice item in lastadded)
{
item.IsChecked = false;
item.GroupBy = GROUP_BY_PreTask + " " + lastname;
}
temp.AddRange(lastadded);
foreach (TaskDevice item in last2added)
{
item.IsChecked = false;
item.GroupBy = GROUP_BY_Earlier + " " + last2name;
}
temp.AddRange(last2added);
if (temp.Count() == 0)
{
TaskDevice d = new TaskDevice();
d.Photo = Common.getImageByLocal("Err.png");
d.Company = "清单中没有符合条件的设备";
d.DeviceType = "错误";
d.IsChecked = false;
temp.Add(d);
}
return(temp);
}
private static Hd44780Configuration LoadMcp23008Configuration(IEnumerable <string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "mcp23008", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Mcp23008Pin registerSelectPin = Mcp23008Pin.Pin1;
const Mcp23008Pin clockPin = Mcp23008Pin.Pin2;
const Mcp23008Pin backlightPin = Mcp23008Pin.Pin7;
var dataPins = new[]
{
Mcp23008Pin.Pin3,
Mcp23008Pin.Pin4,
Mcp23008Pin.Pin5,
Mcp23008Pin.Pin6
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over MCP23008 Expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: GND");
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor())
{
ClockDivider = 512
};
var connection = new Mcp23008I2cConnection(driver.Connect(address));
var retVal = new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(pin => (IOutputBinaryPin)connection.Out(pin)))
};
retVal.Pins.Backlight = connection.Out(backlightPin);
return(retVal);
}
private static Hd44780Configuration LoadPcf8574Configuration(IEnumerable <string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "pcf8574", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Pcf8574Pin clockPin = Pcf8574Pin.P2;
const Pcf8574Pin readWritePin = Pcf8574Pin.P1;
const Pcf8574Pin registerSelectPin = Pcf8574Pin.P0;
const Pcf8574Pin backlightPin = Pcf8574Pin.P3;
var dataPins = new[]
{
Pcf8574Pin.P4,
Pcf8574Pin.P5,
Pcf8574Pin.P6,
Pcf8574Pin.P7
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over PCF8574 expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: {0}", readWritePin);
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor())
{
ClockDivider = 512
};
var connection = new Pcf8574I2cConnection(driver.Connect(address));
return(new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(p => (IOutputBinaryPin)connection.Out(p)))
{
Backlight = connection.Out(backlightPin),
ReadWrite = connection.Out(readWritePin),
}
});
}
private Month createMonth(IEnumerable <RelationalDay> days, DateTime monthFirstDay, DayOfWeek dayOfOrderStart)
{
RelationalDay firstDay = days.SkipWhile(x => x.Day < monthFirstDay)
.First();
DayOfWeek dayOfOrderEnd = calculateDayOfOrderEnd(dayOfOrderStart);
Day previousWeekEndDay = new DateTime(firstDay.Day.Year, firstDay.Day.Month, firstDay.Day.DayOfMonth).AddDays(-1).ToDay();
var weeks = new List <Week>();
bool hasNextWeek = true;
while (hasNextWeek)
{
bool isEndWeek = false;
List <RelationalDay> daysOfWeek = days.SkipWhile(x => x.Day < firstDay.Day)
.SkipWhile(x => x.Day <= previousWeekEndDay)
.TakeWhile(x => x.Day.Month == monthFirstDay.Month && isEndWeek == false)
.Do(x => isEndWeek = x.Day.DayOfWeek == dayOfOrderEnd)
.ToList();
if (daysOfWeek.Count != 0)
{
weeks.Add(new Week {
Days = daysOfWeek
});
previousWeekEndDay = daysOfWeek.Last().Day;
}
else
{
hasNextWeek = false;
}
}
return(new Month
{
Year = monthFirstDay.Year,
MonthOfYear = monthFirstDay.Month,
Weeks = weeks
});
}
static void TestFiltering()
{
Assert(Enumerable.SequenceEqual(_words, _words.Concat(_words).Distinct()));
Assert(Enumerable.SequenceEqual(_words, _words.Skip(0)));
Assert(_words.Skip(1).First() == "quick");
Assert(_words.SkipWhile(w => w.Length == 3).First() == "quick");
Assert(_words.Take(2).Last() == "quick");
Assert(_words.TakeWhile(w => w.Length == 3).Single() == "the");
Assert(_words.Where(w => w.Length == 5).Count() == 2);
}
/// <summary>
/// Split a page of data into its chunks.
/// </summary>
/// <param name="page">A string containing chunks of textual data, separated by whitespace.</param>
/// <returns>The chunks, split on newlines.</returns>
IEnumerable <string> getPageChunks(string page)
{
//a page is made up of a series of chunks, which contain field data
IEnumerable <string> chunks = page.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
//skip the header rows when starting a new page
if (FieldPatterns.RunDate.IsMatch(chunks.First()))
{
chunks = chunks.SkipWhile(s => !FieldPatterns.DataHeader.IsMatch(s)).Skip(1);
}
return(chunks);
}
public override void InitialiseRelationships(IEnumerable <Clause> clause)
{
_ = clause ?? throw new ArgumentNullException(nameof(clause));
// TODO: support more than one verb?? Or zero verbs?
// Find the noun before and after this verb.
var beforeMe = clause.TakeWhile(x => x != this);
var afterMe = clause.SkipWhile(x => x != this).Skip(1).Take(Int32.MaxValue);
// Link to this verb.
this.Subject = beforeMe.ToList();
this.Object = afterMe.ToList();
}
private static TEnum?NextIn <TEnum>(this TEnum value, IEnumerable <TEnum> inValues)
where TEnum : struct, Enum
{
var comparer = EqualityComparer <TEnum> .Default;
var next = inValues
.SkipWhile(e => !comparer.Equals(e, value))
.Skip(1)
.Cast <TEnum?>()
.FirstOrDefault();
return(next);
}
// analogue of string.Split
public static IEnumerable <IEnumerable <T> > Split <T>(this IEnumerable <T> xs, Func <T, bool> predicate)
{
var result = new List <IEnumerable <T> >();
IEnumerable <T> p = xs;
while (p.Any())
{
p = p.SkipWhile(predicate);
var chunk = p.TakeWhile(x => !predicate(x));
if (chunk.Any())
{
result.Add(chunk);
}
p = p.SkipWhile(x => !predicate(x));
}
return(result);
}
/// <summary>
/// Returns all elements in a sequence that follow the first occurence of an element that satisfies a specified condition.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sequence"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static IEnumerable <T> AfterFirst <T>(this IEnumerable <T> sequence, Func <T, bool> predicate)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(sequence.SkipWhile(x => !predicate.Invoke(x)).Skip(1));
}
private void GetFilterDivinationData(IEnumerable <string> lines)
{
DivinationValue value;
while (lines.Any())
{
lines = lines.SkipWhile(aline => !aline.StartsWith("Show ") && !aline.StartsWith("Hide "));
if (!lines.Any())
{
return;
}
string line = lines.First();
if (!line.Contains("# Divination Cards - "))
{
continue;
}
else if (line.Contains("10c+"))
{
value = DivinationValue.Chaos10;
}
else if (line.Contains("2-10c"))
{
value = DivinationValue.Chaos2to10;
}
else if (line.Contains("<2c") || line.Contains("< 2c"))
{
value = DivinationValue.ChaosLess2;
}
else if (line.Contains("Nearly Worthless"))
{
value = DivinationValue.NearlyWorthless;
}
else if (line.Contains("Worthless"))
{
value = DivinationValue.Worthless;
}
else
{
lines = lines.Skip(1);
continue;
}
lines = lines.Skip(1).SkipWhile(aline => !aline.TrimStart().StartsWith("BaseType ") && !aline.StartsWith("Show ") && !aline.StartsWith("Hide "));
line = lines.First().Trim();
if (line.StartsWith("BaseType "))
{
IEnumerable <string> baseTypes = SplitQuotedList(line).Skip(1);
FillFilterDivinationData(SC, baseTypes, value);
FillFilterDivinationData(HC, baseTypes, value);
}
}
}
private Individual GetRandomIndividualByFitnessProbability(IEnumerable <Individual> individualsSortedByFitness, double fitnessSum)
{
double targetFitness = r.NextDouble() * fitnessSum;
double fitness = 0;
Individual individual = individualsSortedByFitness.SkipWhile(i => { if ((fitness + i.Fitness) >= targetFitness)
{
return(false);
}
fitness += i.Fitness; return(true); }).FirstOrDefault();
return(individual);
}
private ParserContext HandleLocation(IEnumerable<string> parts)
{
var locationParts =
parts.SkipWhile(p => !p.StartsWith("@@"))
.Select(s => new String(s.SkipWhile(c => c.Equals('@')).ToArray())) //Take out the leading @@
.ToArray();
if (!locationParts.Any())
return CurrentParserContext;
CurrentParserContext.ContextLocation = String.Join(" ", locationParts);
return CurrentParserContext;
}
public static T Next <T>(this IEnumerable <T> source, T item)
{
if (item == null)
{
return(default(T));
}
var res = source.SkipWhile(x => x.GetHashCode() != item.GetHashCode()).Skip(1).FirstOrDefault();
if (res == null)
{
return(item);
}
return(res);
}
public static void SkipWhileSyntax()
{
IEnumerable <BuildingCategory> categories = DataSource.BuildingCategories;
//Select all categories, starting from Storage and following:
var fromStorageOn = categories.SkipWhile(c => !c.Category.StartsWith("Storage"));
Console.WriteLine("All elements, beginning with Storage and following:");
foreach (var c in fromStorageOn)
{
Console.WriteLine(c.Category);
}
}
public CrossWordLineTask(IEnumerable <int?> groupsOfCells)
{
_groups = groupsOfCells.SkipWhile(g => !g.HasValue)
.Select(g =>
{
if (g.HasValue)
{
return(g.Value);
}
throw new InvalidOperationException("Missed one of values in sequence");
})
.ToList();
}
public static IEnumerable <T> ParentChainReverse <T>(this T?start,
Func <T, T> parentSelector,
Func <T, bool>?stopCondition = null,
bool skipStart = false)
where T : class
{
IEnumerable <T> chain = ParentChain(start, parentSelector, skipStart: skipStart).Reverse();
if (stopCondition != null)
{
chain = chain.SkipWhile(item => !stopCondition(item));
}
return(chain);
}
private static IEnumerable <IEnumerable <ProgramLine> > DoGeneratedLiteralDc(
this IEnumerable <ProgramLine> lines, LabelTable lblTable)
{
// リテラルから生成される DC 命令は、END 命令の直前にまとめて配置される。
// END 命令の前までに続いて、生成された DC 命令を出力し、その後に END 命令以降を出力する。
Boolean notEnd(ProgramLine line) => !line.IsEnd();
yield return(lines.TakeWhile(notEnd));
yield return(lines.Select((line) => line.GenerateLiteralDc(lblTable))
.Where((generatedLine) => generatedLine != null));
yield return(lines.SkipWhile(notEnd));
}
private void GetFilterUniqueData(IEnumerable <string> lines)
{
UniqueValue value;
while (lines.Any())
{
lines = lines.SkipWhile(aline => !aline.StartsWith("Show ") && !aline.StartsWith("Hide "));
if (!lines.Any())
{
return;
}
string line = lines.ElementAt(0);
if (!line.Contains("# Uniques -"))
{
continue;
}
if (line.Contains("15c+"))
{
value = UniqueValue.Chaos15;
}
else if (line.Contains("5-15c"))
{
value = UniqueValue.Chaos5to15;
}
else if (line.Contains("3-5c"))
{
value = UniqueValue.Chaos3to5;
}
else if (line.Contains("Limited"))
{
value = UniqueValue.Limited;
}
else
{
//(line.Contains("<67")
lines = lines.Skip(1);
continue;
}
lines = lines.Skip(1).SkipWhile(aline => !aline.TrimStart().StartsWith("BaseType ") && !aline.StartsWith("Show ") && !aline.StartsWith("Hide "));
line = lines.First().TrimStart();
if (line.StartsWith("BaseType "))
{
IEnumerable <string> baseTypes = SplitQuotedList(line).Skip(1);
FillFilterUniqueData(SC, baseTypes, value);
FillFilterUniqueData(HC, baseTypes, value);
}
}
}
public async override Task ApplyAsync(ISearchContext context, ISearchResult result)
{
// Filter all species that don't have the given species as an ancestor.
ISpecies ancestorSpecies = (await context.Database.GetSpeciesAsync(Value)).FirstOrDefault();
Dictionary <long, bool> resultCache = new Dictionary <long, bool>();
await result.FilterByAsync(async (species) => {
bool isFiltered = true;
if (ancestorSpecies != null && species.Id != ancestorSpecies.Id && !resultCache.TryGetValue(species.Id.Value, out isFiltered))
{
// Get all of the ancestor IDs for this species, ordered from the oldest to the latest.
// Skip until we find the ancestor ID we're looking for.
IEnumerable <long> ancestorIds = await context.Database.GetAncestorIdsAsync(species.Id);
// Skip until we find the ID of the ancestor we're looking for.
// If we find it, all species beyond this point also have the ancestor.
// If we don't find it, none of these species has the ancestor.
IEnumerable <long> idsWithAncestor = ancestorIds.SkipWhile(id => id != ancestorSpecies.Id);
if (idsWithAncestor.Any())
{
// If the species does have the ancestor, do not filter it.
isFiltered = false;
foreach (long id in idsWithAncestor)
{
resultCache[id] = false;
}
}
else
{
// If the species does not have the ancestor, filter it.
isFiltered = true;
foreach (long id in ancestorIds)
{
resultCache[id] = true;
}
}
}
return(isFiltered);
}, Invert);
}
private void ParseArguments(IEnumerable <string> args)
{
_targetNames.AddRange(args.TakeWhile(s => !s.StartsWith("-")));
var arguments = new Queue <string>(args.SkipWhile(s => !s.StartsWith("-")));
while (arguments.Count > 0)
{
var argument = arguments.Dequeue();
var endTypeIndex = argument.IndexOf(":");
var type = argument.Substring(1, endTypeIndex - 1);
string name;
string value;
switch (type)
{
case "parameter":
case "p":
var endNameIndex = argument.IndexOf("=", endTypeIndex + 1);
if (endNameIndex == -1)
{
throw new BuildCsException("Parameter argument is mal-formed. Correct formation is -p:<name>=<value>");
}
name = argument.Substring(endTypeIndex + 1, endNameIndex - endTypeIndex - 1);
value = argument.Substring(endNameIndex + 1);
_parameters.Add(name, value);
break;
case "verbosity":
case "v":
value = argument.Substring(endTypeIndex + 1);
MessageLevel level;
if (!Enum.TryParse <MessageLevel>(value, out level))
{
throw new BuildCsException("Unknown logLevel '{0}'.".F(value));
}
Verbosity = level;
break;
case "listener":
value = argument.Substring(endTypeIndex + 1);
_listeners.Add(value);
break;
default:
throw new BuildCsException("Unknown argument type: {0}".F(type));
}
}
}
private static string GetFloodwatchThresholds(IEnumerable <HilltopFeed> thresholdsSite)
{
var body = "";
body += "<Thresholds>";
foreach (var threshold in thresholdsSite.SkipWhile(p => p.Indicator.Equals("NoThreshold", StringComparison.OrdinalIgnoreCase)))
{
body += "<Line Value='" + threshold.Minimum + "' Colour='Black' Title='" + threshold.GraphText + "' />";
body += "<Region Min='" + threshold.Minimum + "' Max='" + threshold.Maximum + "' Colour='" + threshold.Colour + "' />";
}
body += "</Thresholds>";
return(body);
}
/// <summary>
/// Разделяет исходный список source на блоки,
/// используя указанный предикат splitterSelector для определения элементов-разделителей
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">Исходный список</param>
/// <param name="splitterSelector">Предикат для выбора разделителей списка</param>
/// <returns></returns>
public static IEnumerable <IEnumerable <T> > Split <T>(this IEnumerable <T> source, Func <T, bool> splitterSelector)
{
return
(source
.GroupBy(
z => splitterSelector(z) || z.Equals(source.First()),
h =>
source
.SkipWhile(t => !t.Equals(h))
.Skip(h.Equals(source.First()) ? 0 : 1)
.TakeWhile(j => !splitterSelector(j)))
.Where(ww => ww.Key)
.SelectMany(x => x.Select(xx => xx.Select(xxx => xxx))));
}
/// <summary>
/// Given an element in a sequence, returns the next element
/// or throws if current was the last one
/// (notice: performance penalty, use with caution)
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source"></param>
/// <param name="current"></param>
/// <returns></returns>
public static TSource Next <TSource>(this IEnumerable <TSource> source, TSource current)
{
IEnumerable <TSource> rest = source.SkipWhile(item =>
!EqualityComparer <TSource> .Default.Equals(item, current)).Skip(1);
TSource next = rest.FirstOrDefault();
if (Equals(default(TSource), next))
{
throw new ArgumentException("The given element is the last one in the sequence");
}
return(next);
}
private static IEnumerable <Product> GetProductsForPeriod(IEnumerable <string[]> splitData, int i)
{
//var products = new List<IProduct>();
var productsData = splitData.SkipWhile(x => !x.Contains("3. Товарные показатели"));
//foreach (var productRow in productsData)
//{
// if (string.IsNullOrWhiteSpace(productRow[2]))
// continue;
// products.Add(new Product(productRow[2], new Revenue(Parse(productRow[i]), Parse(productRow[i + 1]))));
//}
return(productsData.Where(x => !string.IsNullOrWhiteSpace(x[2])).Select(x => new Product(x[2], new Revenue(Parse(x[i]), Parse(x[i + 1])))));
}
private static Hd44780Configuration LoadPcf8574Configuration(IEnumerable<string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "pcf8574", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Pcf8574Pin clockPin = Pcf8574Pin.P2;
const Pcf8574Pin readWritePin = Pcf8574Pin.P1;
const Pcf8574Pin registerSelectPin = Pcf8574Pin.P0;
const Pcf8574Pin backlightPin = Pcf8574Pin.P3;
var dataPins = new[]
{
Pcf8574Pin.P4,
Pcf8574Pin.P5,
Pcf8574Pin.P6,
Pcf8574Pin.P7
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over PCF8574 expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: {0}", readWritePin);
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor()) { ClockDivider = 512 };
var connection = new Pcf8574I2cConnection(driver.Connect(address));
return new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(p => (IOutputBinaryPin)connection.Out(p)))
{
Backlight = connection.Out(backlightPin),
ReadWrite = connection.Out(readWritePin),
}
};
}
private static Hd44780Configuration LoadMcp23008Configuration(IEnumerable<string> args)
{
var addressText = args.SkipWhile(s => !String.Equals(s, "mcp23008", StringComparison.InvariantCultureIgnoreCase)).Skip(1).DefaultIfEmpty("0x20").First();
var address = addressText.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
? Int32.Parse(addressText.Substring(2), NumberStyles.HexNumber)
: Int32.Parse(addressText);
const Mcp23008Pin registerSelectPin = Mcp23008Pin.Pin1;
const Mcp23008Pin clockPin = Mcp23008Pin.Pin2;
const Mcp23008Pin backlightPin = Mcp23008Pin.Pin7;
var dataPins = new[]
{
Mcp23008Pin.Pin3,
Mcp23008Pin.Pin4,
Mcp23008Pin.Pin5,
Mcp23008Pin.Pin6
};
Console.WriteLine();
Console.WriteLine("Using I2C connection over MCP23008 Expander");
Console.WriteLine("\tRegister Select: {0}", registerSelectPin);
Console.WriteLine("\tClock: {0}", clockPin);
Console.WriteLine("\tData 1: {0}", dataPins[0]);
Console.WriteLine("\tData 2: {0}", dataPins[1]);
Console.WriteLine("\tData 3: {0}", dataPins[2]);
Console.WriteLine("\tData 4: {0}", dataPins[3]);
Console.WriteLine("\tBacklight: {0}", backlightPin);
Console.WriteLine("\tRead/write: GND");
Console.WriteLine();
const ConnectorPin sdaPin = ConnectorPin.P1Pin03;
const ConnectorPin sclPin = ConnectorPin.P1Pin05;
var driver = new I2cDriver(sdaPin.ToProcessor(), sclPin.ToProcessor()) { ClockDivider = 512 };
var connection = new Mcp23008I2cConnection(driver.Connect(address));
var retVal = new Hd44780Configuration(driver)
{
Pins = new Hd44780Pins(
connection.Out(registerSelectPin),
connection.Out(clockPin),
dataPins.Select(pin => (IOutputBinaryPin)connection.Out(pin)))
};
retVal.Pins.Backlight = connection.Out(backlightPin);
return retVal;
}
private static IEnumerable<Token> PartitionSequences(
IEnumerable<Token> tokens,
Func<string, Maybe<Tuple<DescriptorType, Maybe<int>>>> typeLookup)
{
return from tseq in tokens.Pairwise(
(f, s) =>
f.IsName() && s.IsValue()
? typeLookup(f.Text).Return(info =>
info.Item1 == DescriptorType.Sequence
? new[] { f }.Concat(tokens.SkipWhile(t => t.Equals(f)).TakeWhile(v => v.IsValue()).Take(MaybeExtensions.Return(info.Item2, items => items, 0)))
: new Token[] { } , new Token[] { })
: new Token[] {})
from t in tseq
select t;
}
public static bool AllEqual([NotNull] this IEnumerable <object> values, [CanBeNull] out object value)
{
value = null;
var firstNotNull = values.FirstOrDefault(x => x != null);
// Either empty, or everything is null
if (firstNotNull == null)
{
return(true);
}
value = firstNotNull;
return(values.SkipWhile(x => x != firstNotNull).All(firstNotNull.Equals));
}
/// <summary>
/// 要素の取得（複数）
/// SkipWhile : 指定条件の要素をスキップして取得
/// </summary>
private static void SkipWhile()
{
// SkipWhileの動作(Idが6より小さい要素をスキップして取得)
var skipWhile = sampleData001.SkipWhile(x => x.Id < 6);
// 取り扱いデータを表示
ShowSample001();
// 結果を表示
Console.WriteLine("------------------------------");
Console.WriteLine("Enumerable.SkipWhile()のサンプルです");
Console.WriteLine("\tSkipWhile(x => x.Id < 6)により(Id < 6)となる要素をスキップして残りの要素を取得");
Console.WriteLine("------------------------------");
skipWhile.ForEach(x => { Console.WriteLine($"\tId = {x?.Id}, \t LinkId = {x?.LinkId}"); });
}
/// <summary>
/// Parse robots.txt from a specific prettyURL.
/// Assumes robots.txt is properly formatted.
/// </summary>
/// <param name="prettyURL"></param>
/// <param name="robotsContent"></param>
/// <returns>A regex to determine if a prettyURL is disallowed.</returns>
private Regex CalcRobotRegexForDomain(PrettyURL url, IEnumerable<string> robotsContent)
{
if (CachedRegexes.ContainsKey(url.GetDomain) && DateTime.Now - CachedRegexes[url.GetDomain].Item1 < MaxAge)
{
return CachedRegexes[url.GetDomain].Item2;
}
regexCalcWatch.Restart();
// No restrictions
//
if (robotsContent == null || robotsContent.Count() == 0)
{
return new Regex(@"@.");
}
// Find what is disallowed.
var disallow = robotsContent.SkipWhile(s => !Regex.IsMatch(s, @"User-Agent: \*", RegexOptions.IgnoreCase)) // Start from user agent *.
.TakeWhile(s => !string.IsNullOrWhiteSpace(s)) // Read until blank line (where allow/disallow hopefully ends).
.Skip(1) // Skip the user agent string.
.Where(s => s.StartsWith("Disallow")) // We only need disallowed stuff.
.Select(s => s.Split(':').Last().Trim()); // Select the disallowed stuff.
if (disallow.Count() == 0)
{
return new Regex(@"$.");
}
// Build the regex string
StringBuilder regPattern = new StringBuilder(url + "(" + disallow.First());
foreach (var s in disallow.Skip(1))
{
regPattern.Append('|');
//regPattern.Append(prettyURL);
regPattern.Append(s);
}
regPattern.Append(')');
regPattern.Replace("*", ".*").Replace(".", "\\.").Replace("+", "\\+");
CachedRegexes[url.GetDomain] = new Tuple<DateTime, Regex>(DateTime.Now, new Regex(regPattern.ToString()));
regexCalcWatch.Stop();
regexCalcTimes[url.GetDomain] = (int)regexCalcWatch.Elapsed.TotalMilliseconds;
return CachedRegexes[url.GetDomain].Item2;
}
private GameObject GetFirstMatchingObject(IEnumerable<IWord> words)
{
var with = words.FirstOrDefault(w => w.Word == "with");
if (with != null)
{
words.Substitute(with, new With());
}
var afterWith = words.SkipWhile(w => w.Word != "with").Skip(1);
if (afterWith.Any() && gameState.GetObject(afterWith.ElementAt(0).Word) != null )
{
var withObject = gameState.GetObject(afterWith.ElementAt(0).Word);
if (withObject != null)
return withObject;
}
return words.Select(word => gameState.GetObject(word.Word)).FirstOrDefault(gotObject => gotObject != null);
}
public static Maybe<TypeDescriptor> FindTypeDescriptorAndSibling(
string name,
IEnumerable<OptionSpecification> specifications,
StringComparer comparer)
{
var info =
specifications.SingleOrDefault(a => name.MatchName(a.ShortName, a.LongName, comparer))
.ToMaybe()
.Map(
first =>
{
var descr = TypeDescriptor.Create(first.TargetType, first.Max);
var next = specifications
.SkipWhile(s => s.Equals(first)).Take(1)
.SingleOrDefault(x => x.IsValue()).ToMaybe()
.Map(second => TypeDescriptor.Create(second.TargetType, second.Max));
return descr.WithNextValue(next);
});
return info;
}
/// <summary>
/// Filter strackframes by assembly filter
/// </summary>
/// <param name="stackFrames"></param>
/// <returns></returns>
private static IEnumerable<StackFrameWithIndex> FilterBySkipAssembly(IEnumerable<StackFrameWithIndex> stackFrames)
{
//skip while in "skip" assemlbl
stackFrames = stackFrames.SkipWhile(p => SkipAssembly(p.StackFrame));
return stackFrames;
}
private IEnumerable<ISprint> ToSprintList(IEnumerable<object> items)
{
// もし先頭にTaskが書かれてたら無所属なので除外
var seekedSprint = items.SkipWhile(x => (x is ISprint) == false).ToArray();
// 残りが無かったらおしまい
if (seekedSprint.Any() == false)
{
yield break;
}
// 今回処理するSprintを取り出し
var sprint = seekedSprint.First() as Sprint;
// 次のSprintまでに書かれているTaskを取り出し
var tasks = seekedSprint.Skip(1).TakeWhile(x => x is ITaskItem).OfType<ITaskItem>().ToArray();
// Sprintに追加
tasks.ForEach(sprint.AddTask);
// 返す
yield return sprint;
var tails = items.Where(x => x != sprint).Where(x => tasks.Any(y => y == x) == false).ToArray();
// 残りを再帰で処理
var result = ToSprintList(tails);
foreach (var item in result)
{
yield return item;
}
}
public PropertyEntity Parse(TypedEntity typedEntity, string name, IEnumerable<XElement> elements)
{
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute("class") != null &&
el.Attribute("class").Value == "declaration_indent"
select el).FirstOrDefault();
XElement discussionElement = (from el in elements
where el.Name == "h5" && el.Value.Trim() == "Discussion"
select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants("dt").FirstOrDefault()
let definition = el.Descendants("dd").FirstOrDefault()
where el.Name == "dl" &&
term != null &&
term.Value.Trim() == "Availability"
select definition).FirstOrDefault();
String signature = declarationElement.TrimAll();
// Extract abstract
List<String> summary = new List<String>();
IEnumerable<XElement> abstractElements = elements.SkipWhile(el => el.Name != "p").TakeWhile(el => el.Name == "p");
foreach (XElement element in abstractElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
summary.Add(line);
}
}
// Extract discussion
if (discussionElement != null)
{
IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
foreach (XElement element in discussionElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
summary.Add(line);
}
}
}
// Get the availability
String minAvailability = "MISSING";
if (availabilityElement != null)
{
minAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
}
// Extract property's attribute
List<String> attributes = new List<String>();
int attributesStart = signature.IndexOf('(');
int attributesEnd = signature.IndexOf(')');
if (attributesStart > 0 && attributesEnd > attributesStart)
{
String attributesAll = signature.Substring(attributesStart + 1, attributesEnd - attributesStart - 1);
attributes.AddRange(attributesAll.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries).Select(attr => attr.Trim()));
}
int typeStart = attributesEnd > 0 ? (attributesEnd + 1) : "@property".Length;
int typeEnd = signature.LastIndexOf(name);
string returnType = (typeStart > 0 && typeEnd > typeStart) ? signature.Substring(typeStart, typeEnd - typeStart).Trim() : "MISSING";
// Is the property readonly ?
bool readOnly = attributes.Contains("readonly");
// Is there an explicit getter
String getterSelector = attributes.Find(a => a.Contains("getter"));
if (getterSelector != null)
{
getterSelector = getterSelector.Substring(getterSelector.IndexOf('=') + 1);
}
else
{
getterSelector = name;
}
// Alter the name
name = name.UpperCaseFirstLetter();
// Is there an explicit setter
String setterSelector = attributes.Find(a => a.Contains("setter"));
if (setterSelector != null)
{
setterSelector = setterSelector.Substring(setterSelector.IndexOf('=') + 1);
}
else
{
setterSelector = "set" + name + ":";
}
bool isOut, isByRef, isBlock;
String type = this.TypeManager.ConvertType(returnType, out isOut, out isByRef, out isBlock, this.Logger);
PropertyEntity propertyEntity = new PropertyEntity();
propertyEntity.MinAvailability = minAvailability;
propertyEntity.Name = getterSelector.UpperCaseFirstLetter();
propertyEntity.Static = false;
propertyEntity.Summary = summary;
propertyEntity.Type = type;
propertyEntity.Getter = new MethodEntity();
propertyEntity.Getter.Signature = signature;
propertyEntity.Getter.Selector = getterSelector;
if (readOnly)
{
propertyEntity.Setter = null;
}
else
{
propertyEntity.Setter = new MethodEntity();
propertyEntity.Setter.Signature = signature;
propertyEntity.Setter.Selector = setterSelector;
}
return propertyEntity;
}
private IEnumerable<HtmlNode> AdvanceToNextEvent(IEnumerable<HtmlNode> nodes)
{
return nodes.SkipWhile(x => !isTitleNode(x));
}
/// <summary>Find the phase shift between an input signal and the zero-phase expected signal.
/// The phase shift is found by shifting the reference signal and finding the shift where the difference between
/// the input and the reference is at minimum.</summary>
/// <param name="inputSignal"> Input signal whos phase we want to find</param>
/// <param name="zeroPhasedSignal"> Zero phase reference signal.</param>
/// <param name="binsInPeriod"> The expected preiod of the input signal in bins.</param>
/// <param name="startShift"> The intitial shift to check.</param>
/// <param name=endShift"> The final shift to check.</param>
/// <remarks>The function assume that the zero phase signal start @ a global minimum!
/// Positive shift value shift the shifted signal right (negative value shift to the left).</remarks>
public static PhaseData FindBinPhaseByShift(IEnumerable<double> inputSignal, IEnumerable<double> zeroPhasedSignal, int binsInPeriod, int startShift, int endShift, bool showDebugWindow)
{
try
{
double tmpMin = inputSignal.Min();
double[] tmpSignal = inputSignal.SkipWhile(x => x != tmpMin).ToArray();
int skippedBins = inputSignal.Count() - tmpSignal.Count();
if (skippedBins > (inputSignal.Count() - binsInPeriod))
{
//skippedBins = skippedBins - binsInPeriod;
}
double differenceSum, minDifferenceSum;
int minDifferencePhase = 0;
int phaseShiftIndex = 0;
double[] sig = inputSignal.ToArray();
double[] refSig = zeroPhasedSignal.ToArray();
minDifferenceSum = double.PositiveInfinity;
int shift;
int i;
try
{
for (shift = startShift; shift <= endShift; shift++)
{
differenceSum = 0;
for (i = 0; i < binsInPeriod; i++)
{
phaseShiftIndex = skippedBins + shift + i;
phaseShiftIndex = phaseShiftIndex % inputSignal.Count();
phaseShiftIndex = (phaseShiftIndex < 0) ? phaseShiftIndex + binsInPeriod : phaseShiftIndex;
phaseShiftIndex = (phaseShiftIndex >= binsInPeriod) ? phaseShiftIndex - binsInPeriod : phaseShiftIndex;
differenceSum += Math.Abs(sig[phaseShiftIndex] - refSig[i]);
}
if (differenceSum < minDifferenceSum)
{
minDifferencePhase = shift;
minDifferenceSum = differenceSum;
}
}
}
catch (Exception ex)
{
string s = ex.Message;
}
PhaseData phaseData = new PhaseData((skippedBins + minDifferencePhase), binsInPeriod, minDifferenceSum / binsInPeriod);
int totalPhase = skippedBins + minDifferencePhase;
if (totalPhase < 0)
{
totalPhase += inputSignal.Count();
}
double[] shiftedSig = new double[binsInPeriod];
for (i = 0; i < binsInPeriod; i++)
{
int phaseIdx = (i + totalPhase) % sig.Length;
phaseIdx = (phaseIdx > sig.Length) ? phaseIdx - sig.Length : phaseIdx;
phaseIdx = (phaseIdx < 0) ? phaseIdx + sig.Length : phaseIdx;
if (phaseIdx >= sig.Length)
{
phaseIdx = phaseIdx - sig.Length;
}
shiftedSig[i] = sig[phaseIdx];
}
if (showDebugWindow)
{
SharedCode.DebugHelper.MatlabFigure tmp = new SharedCode.DebugHelper.MatlabFigure("ref", zeroPhasedSignal.ToArray());
tmp.AddPlot("phased", shiftedSig, true);
tmp.Show();
}
return phaseData;
}
catch (Exception ex)
{
string s = ex.Message;
throw new Exception("Find phase fail - " + ex.Message);
}
}
public MethodEntity Parse(TypedEntity typedEntity, String selector, IEnumerable<XElement> elements)
{
MethodEntity methodEntity = new MethodEntity();
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute("class") != null &&
el.Attribute("class").Value == "declaration_indent"
select el).FirstOrDefault();
XElement parameterElement = (from el in elements
where el.Name == "div" &&
el.Attribute("class") != null &&
el.Attribute("class").Value == "param_indent"
select el).FirstOrDefault();
XElement returnValueElement = (from el in elements
where el.Name == "h5" && el.Value.Trim() == "Return Value"
select el).FirstOrDefault();
//XElement discussionElement = (from el in elements
// where el.Name == "h5" && el.Value.Trim() == "Discussion"
// select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants("dt").FirstOrDefault()
let definition = el.Descendants("dd").FirstOrDefault()
where el.Name == "dl" &&
term != null &&
term.Value.Trim() == "Availability"
select definition).FirstOrDefault();
methodEntity.Selector = selector;
methodEntity.Name = GetMethodName(methodEntity);
methodEntity.Signature = declarationElement.TrimAll();
methodEntity.Signature = methodEntity.Signature.TrimEnd(';');
methodEntity.Static = methodEntity.Signature.StartsWith("+");
// Extract abstract
IEnumerable<XElement> abstractElements = elements.SkipWhile(el => el.Name != "p").TakeWhile(el => el.Name == "p");
foreach (XElement element in abstractElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
methodEntity.Summary.Add(line);
}
}
//// Extract discussion
//if (discussionElement != null)
//{
// IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
// foreach (XElement element in discussionElements)
// {
// String line = element.TrimAll();
// if (!String.IsNullOrEmpty(line))
// {
// methodEntity.Summary.Add(line);
// }
// }
//}
// Extract return type
MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator(methodEntity.Signature);
if (signatureEnumerator.MoveNext())
{
methodEntity.ReturnType = this.TypeManager.ConvertType(signatureEnumerator.Current.TrimAll(), this.Logger);
}
else
{
methodEntity.ReturnType = "Id";
}
// Extract parameter type and name
MethodParametersEnumerator parameterTypesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, false);
MethodParametersEnumerator parameterNamesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, true);
while (parameterTypesEnumerator.MoveNext() && parameterNamesEnumerator.MoveNext())
{
MethodParameterEntity parameterEntity = new MethodParameterEntity();
bool isOut, isByRef, isBlock;
parameterEntity.Type = this.TypeManager.ConvertType(parameterTypesEnumerator.Current, out isOut, out isByRef, out isBlock, this.Logger);
parameterEntity.IsOut = isOut;
parameterEntity.IsByRef = isByRef;
parameterEntity.IsBlock = isBlock;
parameterEntity.Name = parameterNamesEnumerator.Current.Trim();
methodEntity.Parameters.Add(parameterEntity);
}
if (methodEntity.Parameters.Count > 0 && parameterElement != null)
{
XElement termList = parameterElement.Descendants("dl").FirstOrDefault();
if (termList != null)
{
IEnumerable<XElement> dtList = from el in termList.Elements("dt") select el;
IEnumerable<XElement> ddList = from el in termList.Elements("dd") select el;
if (dtList.Count() == ddList.Count())
{
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++)
{
String term = dtList.ElementAt(i).TrimAll();
//String summary = ddList.ElementAt(i).TrimAll();
IEnumerable<String> summaries = ddList.ElementAt(i).Elements("p").Select(p => p.Value.TrimAll());
// Find the parameter
MethodParameterEntity parameterEntity = methodEntity.Parameters.Find(p => String.Equals(p.Name, term));
if (parameterEntity != null)
{
//parameterEntity.Summary.Add(summary);
foreach (string sum in summaries)
{
parameterEntity.Summary.Add(sum);
}
}
}
}
}
}
// Fix the name only after looking for the documentation
for (int i = 0; i < methodEntity.Parameters.Count; i++)
{
methodEntity.Parameters[i].Name = this.TypeManager.ConvertName(methodEntity.Parameters[i].Name);
}
// Get the summary for return type
if (!String.Equals(methodEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase) && returnValueElement != null)
{
IEnumerable<XElement> returnTypeElements = returnValueElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
methodEntity.ReturnsDocumentation = String.Empty;
foreach (XElement element in returnTypeElements)
{
String line = element.TrimAll();
if (!String.IsNullOrEmpty(line))
{
methodEntity.ReturnsDocumentation += line;
}
}
}
// Get the availability
if (availabilityElement != null)
{
methodEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
}
return methodEntity;
}
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;
}
static string ExtractMigration(IEnumerable<string> lines)
{
var sqlLines = lines.SkipWhile(IsPartOfComments);
return string.Join(Environment.NewLine, sqlLines);
}
public FunctionEntity Parse(TypedEntity typedEntity, string name, IEnumerable<XElement> elements)
{
FunctionEntity functionEntity = new FunctionEntity ();
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "declaration_indent"
select el).FirstOrDefault ();
declarationElement = declarationElement ?? (from el in elements
where el.Name == "pre"
select el).FirstOrDefault ();
XElement parameterElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "param_indent"
select el).FirstOrDefault ();
XElement returnValueElement = (from el in elements
where el.Name == "h5" && el.Value.Trim () == "Return Value"
select el).FirstOrDefault ();
//XElement discussionElement = (from el in elements
// where el.Name == "h5" && el.Value.Trim() == "Discussion"
// select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants ("dt").FirstOrDefault ()
let definition = el.Descendants ("dd").FirstOrDefault ()
where el.Name == "dl" &&
term != null &&
term.Value.Trim () == "Availability"
select definition).FirstOrDefault ();
functionEntity.Name = name;
String signature = declarationElement.TrimAll ();
if (signature.StartsWith ("#define")) {
this.Logger.WriteLine ("SKIPPING define statement: " + name);
return null;
}
if (!signature.Contains ("(")) { // e.g. NS_DURING
this.Logger.WriteLine ("SKIPPING non-function statement: " + name);
return null;
}
// Trim down signature
while (signature.IndexOf(" ") != -1) {
signature = signature.Replace (" ", " ");
}
functionEntity.Signature = signature;
//Console.WriteLine("signature='" + signature + "'");
// Extract abstract
IEnumerable<XElement> abstractElements = elements.SkipWhile (el => el.Name != "p").TakeWhile (el => el.Name == "p");
foreach (XElement element in abstractElements) {
String line = element.TrimAll ();
if (!String.IsNullOrEmpty (line)) {
functionEntity.Summary.Add (line);
}
}
//// Extract discussion
//if (discussionElement != null)
//{
// IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
// foreach (XElement element in discussionElements)
// {
// String line = element.TrimAll();
// if (!String.IsNullOrEmpty(line))
// {
// methodEntity.Summary.Add(line);
// }
// }
//}
// Parse signature
signature = signature.Replace ("extern", String.Empty).Trim ();
int pos = signature.IndexOf (name);
if (pos == -1) {
this.Logger.WriteLine ("MISMATCH between name and declaration: " + name);
return null;
}
String returnType = signature.Substring (0, pos).Trim ();
int paramsIndex = pos + name.Length;
int paramsLength = signature.IndexOf(')') + 1 - paramsIndex; // Stop before getting to function body
String parameters = signature.Substring (paramsIndex, paramsLength).Trim ();
parameters = parameters.Trim (';', '(', ')').Trim();
if (parameters != "void") {
foreach (string parameter in parameters.Split(new []{','}, StringSplitOptions.RemoveEmptyEntries)) {
String parameterType = "NOTYPE";
String parameterName = "NONAME";
//Console.WriteLine("parameter='" + parameter + "'");
Match r = PARAMETER_REGEX.Match (parameter);
if (r.Success) {
parameterType = r.Groups [2].Value.Trim ();
parameterName = r.Groups [3].Value.Trim ();
} else if (parameter.Trim () == "...") {
parameterType = "params Object[]";
parameterName = "values";
} else {
this.Logger.WriteLine ("FAILED to parse parameter: " + parameter);
return null;
}
MethodParameterEntity parameterEntity = new MethodParameterEntity ();
bool isOut, isByRef, isBlock;
parameterEntity.Type = this.TypeManager.ConvertType (parameterType, out isOut, out isByRef, out isBlock, this.Logger);
parameterEntity.IsOut = isOut;
parameterEntity.IsByRef = isByRef;
parameterEntity.IsBlock = isBlock;
parameterEntity.Name = TypeManager.ConvertName(parameterName);
functionEntity.Parameters.Add (parameterEntity);
}
}
// Extract return type
functionEntity.ReturnType = this.TypeManager.ConvertType (returnType, this.Logger);
if (functionEntity.Parameters.Count > 0 && parameterElement != null) {
XElement termList = parameterElement.Descendants ("dl").FirstOrDefault ();
if (termList != null) {
IEnumerable<XElement> dtList = from el in termList.Elements ("dt") select el;
IEnumerable<XElement> ddList = from el in termList.Elements ("dd") select el;
if (dtList.Count () == ddList.Count ()) {
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++) {
String term = dtList.ElementAt (i).TrimAll ();
//String summary = ddList.ElementAt(i).TrimAll();
IEnumerable<String> summaries = ddList.ElementAt (i).Elements ("p").Select (p => p.Value.TrimAll ());
// Find the parameter
MethodParameterEntity parameterEntity = functionEntity.Parameters.Find (p => String.Equals (p.Name, term));
if (parameterEntity != null) {
//parameterEntity.Summary.Add(summary);
foreach (string sum in summaries) {
parameterEntity.Summary.Add (sum);
}
}
}
}
}
}
// Fix the name only after looking for the documentation
for (int i = 0; i < functionEntity.Parameters.Count; i++) {
functionEntity.Parameters [i].Name = this.TypeManager.ConvertName (functionEntity.Parameters [i].Name);
}
// Get the summary for return type
if (!String.Equals (functionEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase) && returnValueElement != null) {
IEnumerable<XElement> returnTypeElements = returnValueElement.ElementsAfterSelf ().TakeWhile (el => el.Name == "p");
functionEntity.ReturnsDocumentation = String.Empty;
foreach (XElement element in returnTypeElements) {
String line = element.TrimAll ();
if (!String.IsNullOrEmpty (line)) {
functionEntity.ReturnsDocumentation += line;
}
}
}
// Get the availability
if (availabilityElement != null) {
functionEntity.MinAvailability = CommentHelper.ExtractAvailability (availabilityElement.TrimAll ());
}
return functionEntity;
}
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 EnumerationEntity Parse(TypedEntity typedEntity, String name, IEnumerable<XElement> elements)
{
EnumerationEntity enumerationEntity = new EnumerationEntity ();
XElement declarationElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "declaration_indent"
select el).FirstOrDefault ();
XElement parameterElement = (from el in elements
where el.Name == "div" &&
el.Attribute ("class") != null &&
el.Attribute ("class").Value == "param_indent"
select el).FirstOrDefault ();
//XElement discussionElement = (from el in elements
// where el.Name == "h5" && el.Value.Trim() == "Discussion"
// select el).FirstOrDefault();
XElement availabilityElement = (from el in elements
let term = el.Descendants ("dt").FirstOrDefault ()
let definition = el.Descendants ("dd").FirstOrDefault ()
where el.Name == "dl" &&
term != null &&
term.Value.Trim () == "Availability"
select definition).FirstOrDefault ();
String declaration = declarationElement.TrimAll ();
String type = "NOTYPE";
String values = String.Empty;
bool result = this.SplitEnumeration (declaration, ref name, ref type, ref values);
if (!result) {
return null;
}
enumerationEntity.Name = name;
enumerationEntity.BaseType = type;
enumerationEntity.Namespace = "MISSING";
// Extract abstract
IEnumerable<XElement> abstractElements = elements.SkipWhile (el => el.Name != "p").TakeWhile (el => el.Name == "p");
foreach (XElement element in abstractElements) {
String line = element.TrimAll ();
if (!String.IsNullOrEmpty (line)) {
enumerationEntity.Summary.Add (line);
}
}
//// Extract discussion
//if (discussionElement != null)
//{
// IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
// foreach (XElement element in discussionElements)
// {
// String line = element.TrimAll();
// if (!String.IsNullOrEmpty(line))
// {
// enumerationEntity.Summary.Add(line);
// }
// }
//}
// Parse the values
string[] pairs = values.Split (new []{','}, StringSplitOptions.RemoveEmptyEntries);
foreach (string pair in pairs) {
if (String.Equals (pair.TrimAll (), String.Empty)) {
continue;
}
String key;
String value = String.Empty;
if (pair.IndexOf ('=') != -1) {
string[] parts = pair.Split (new []{'='}, StringSplitOptions.RemoveEmptyEntries);
key = parts [0].Trim ();
value = parts [1].Trim ();
} else {
key = pair.Trim ();
}
// Add a new value
EnumerationValueEntity enumerationValueEntity = new EnumerationValueEntity ();
enumerationValueEntity.Name = key;
if (value.Length == 6 && value.StartsWith ("'") && value.EndsWith ("'")) {
String v = value.Trim ('\'');
enumerationValueEntity.Value = "0x" + FourCharToInt (v).ToString ("X8");
} else {
enumerationValueEntity.Value = value;
}
enumerationEntity.Values.Add (enumerationValueEntity);
}
XElement termList = parameterElement != null ? parameterElement.Descendants ("dl").FirstOrDefault () : null;
if (termList != null) {
IEnumerable<XElement> dtList = from el in termList.Elements ("dt") select el;
IEnumerable<XElement> ddList = from el in termList.Elements ("dd") select el;
if (dtList.Count () == ddList.Count ()) {
// Iterate over definitions
for (int i = 0; i < dtList.Count(); i++) {
String term = dtList.ElementAt (i).TrimAll ();
//String summary = ddList.ElementAt(i).TrimAll();
IEnumerable<String> summaries = ddList.ElementAt (i).Elements ("p").Select (p => p.Value.TrimAll ());
// Find the parameter
EnumerationValueEntity enumerationValueEntity = enumerationEntity.Values.Find (p => String.Equals (p.Name, term));
if (enumerationValueEntity != null) {
foreach (string sum in summaries) {
enumerationValueEntity.Summary.Add (sum);
}
}
}
}
}
// Get the availability
if (availabilityElement != null) {
enumerationEntity.MinAvailability = CommentHelper.ExtractAvailability (availabilityElement.TrimAll ());
}
return enumerationEntity;
}
string ChooseSong( IEnumerable<string> songs )
{
if (!songs.Any())
return null;
if (Game.Settings.Sound.Shuffle)
return songs.Random(Game.CosmeticRandom);
return songs.SkipWhile(m => m != CurrentSong)
.Skip(1).FirstOrDefault() ?? songs.FirstOrDefault();
}
public static float PlatformPathDistance(IEnumerable<GameObject> path, GameObject platform)
{
var remainingPath = path.SkipWhile(x => x != platform).ToArray();
float dist = 0f;
for (int i = 0; i < remainingPath.Count () - 1; i++) {
dist += remainingPath [i].Distance (remainingPath [i + 1]);
}
return dist;
}
