public void Ordinal_should_result_in_four_claims()
{
var hashSet = new HashSet <Claim>(_claims, new ClaimComparer(new ClaimComparer.Options {
IgnoreValueCase = false
}));
hashSet.Count.Should().Be(4);
var item = hashSet.First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("value");
item.Issuer.Should().Be("issuer1");
item = hashSet.Skip(1).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("Value");
item.Issuer.Should().Be("issuer1");
item = hashSet.Skip(2).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("value");
item.Issuer.Should().Be("issuer2");
item = hashSet.Skip(3).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("Value");
item.Issuer.Should().Be("issuer2");
}
public void Default_options_should_result_in_four_claims()
{
var hashSet = new HashSet <Claim>(_claims, new ClaimComparer());
hashSet.Count.Should().Be(4);
var item = hashSet.First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("value");
item.Issuer.Should().Be("issuer1");
item = hashSet.Skip(1).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("Value");
item.Issuer.Should().Be("issuer1");
item = hashSet.Skip(2).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("value");
item.Issuer.Should().Be("issuer2");
item = hashSet.Skip(3).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("Value");
item.Issuer.Should().Be("issuer2");
}
static void Main(string[] args)
{
const int limit = 1000000;
var primes = new HashSet <int>();
for (mpz_t p = 2; p <= limit; p = p.NextPrimeGMP())
{
primes.Add((int)p);
}
var indexes = Enumerable.Range(0, primes.Count + 1).ToArray();
int max = 0;
int bestprime = 0;
for (int i = 0; i < primes.Count &&
primes.Skip(i).Take(max).Sum() <= limit /* is it possible to generate a longer string? */
; i++)
{
for (int c = max; c <= primes.Count - i; c++)
{
var sum = primes.Skip(i).Take(c).Sum();
if (sum >= limit)
{
break;
}
if (c > max && primes.Contains(sum))
{
bestprime = sum;
max = c;
}
}
}
Console.WriteLine($"\n{bestprime}, max = {max}");
}
public static bool IsEventAvailable()
{
var possibleActions = new HashSet <int>(ActionsParser.Events.Keys);
possibleActions.ExceptWith(PreviouslyUsedIndexes.Skip(System.Math.Max(0, PreviouslyUsedIndexes.Count - 5)));
return(possibleActions.Any());
}
public void BinarySeachTreeTestCase1()
{
var rnd = new Random();
var set = new HashSet <int>();
do
{
var value = rnd.Next(100, 1000);
set.Add(value);
Console.WriteLine($"Choosing value: {value}");
} while (set.Count < 10);
BinarySeachTree <int> searchTree = null;
foreach (var item in set)
{
searchTree = BinarySeachTree <int> .Insert(searchTree, item);
}
var expectedOutput = set.Skip(4).First();
var actualOutput = BinarySeachTree <int> .Search(searchTree, expectedOutput);
Assert.AreEqual(expectedOutput, actualOutput.Value, "Value does not match");
}
static void Main()
{
var listOfLists = new HashSet <int>[]
{
new HashSet <int> {
1, 2, 3
},
new HashSet <int> {
0, 2, 4
},
new HashSet <int> {
0, 1, 2
}
};
var r = listOfLists[0]; foreach (var rc in listOfLists.Skip(1))
{
r.IntersectWith(rc);
}
foreach (var item in r)
{
System.Console.WriteLine(item);
}
}
private async Task RunAsync(CancellationToken token)
{
try
{
while (!token.IsCancellationRequested)
{
await Task.Delay(_random.Next(1024, 8192), token);
if (Update == null || _prices.Count == 0)
{
continue;
}
var price = _prices.Skip(_random.Next(_prices.Count)).First();
var newPrice = price.Price + _random.Next(-99, 99) / 10m;
if (newPrice < 0)
{
newPrice = 0m;
}
price.Price = newPrice;
Update?.Invoke(this, new StockPriceUpdateEventArgs(price.Symbol, price.Price));
}
}
catch (OperationCanceledException)
{
// Ignored
}
}
public async Task <Dictionary <string, EmailVerificationStatus> > GetStatusAsync(HashSet <string> emailAddresses, CancellationToken ct = default)
{
var result = new Dictionary <string, EmailVerificationStatus>();
var buckets = (int)Math.Ceiling((double)emailAddresses.Count / MaxEmailAddressesPerRequest);
for (var i = 0; i < buckets; i++)
{
ct.ThrowIfCancellationRequested();
var bucketAddresses = emailAddresses.Skip(i * MaxEmailAddressesPerRequest).Take(MaxEmailAddressesPerRequest);
var request = new GetIdentityVerificationAttributesRequest
{
Identities = bucketAddresses.ToList()
};
var response = await amazonSES.GetIdentityVerificationAttributesAsync(request, ct);
foreach (var(key, attr) in response.VerificationAttributes)
{
result[key] = MapStatus(attr.VerificationStatus);
}
}
return(result);
}
private async Task <Dictionary <int, string> > GetProjectNamesForUserMapping(HashSet <int> projectIds, int?userId)
{
var projectNameIdDictionary = (await _artifactRepository.GetProjectNameByIdsAsync(projectIds)).ToDictionary(x => x.ItemId, x => x.Name);
if (!userId.HasValue)
{
return(projectNameIdDictionary);
}
var projectIdPermissions = new List <KeyValuePair <int, RolePermissions> >();
int iterations = (int)Math.Ceiling((double)projectIds.Count / 50);
for (int i = 0; i < iterations; i++)
{
var chunkProjectIds = projectIds.Skip(i * 50).Take(50);
var newDictionary = await _artifactPermissionsRepository.GetArtifactPermissions(chunkProjectIds, userId.Value);
projectIdPermissions.AddRange(newDictionary.ToList());
}
var projectIdPermissionsDictionary = projectIdPermissions.ToDictionary(x => x.Key, x => x.Value);
foreach (int projectId in projectIds)
{
if (!projectIdPermissionsDictionary.ContainsKey(projectId) || !projectIdPermissionsDictionary[projectId].HasFlag(RolePermissions.Read))
{
projectNameIdDictionary[projectId] = ServiceConstants.NoPermissions;
}
}
return(projectNameIdDictionary);
}
private void LoadDirectoryHistory()
{
var fn = GetHistoryFileName();
if (File.Exists(fn))
{
var strs = new HashSet <string>();
using (var stream = File.OpenRead(fn))
using (var tr = new StreamReader(stream))
{
while (true)
{
var line = tr.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
break;
}
var s = line.Trim();
if (Directory.Exists(s))
{
strs.Add(s);
}
}
}
if (5 < strs.Count)
{
strs = new HashSet <string>(strs.Skip(strs.Count - 5));
}
DirectoryHistory = new ObservableCollection <string>(strs);
}
else
{
DirectoryHistory = new ObservableCollection <string>();
}
}
public IGenome <TSimulation> PickRandomGenome()
{
var random = evolutionSettings.RandomnessProvider;
return(genomes
.Skip(random.Next(0, genomes.Count))
.First());
}
private HashSet <NotifyEntry> TrimSet(HashSet <NotifyEntry> entries)
{
if (entries.Count <= 20)
{
return(entries);
}
return(new HashSet <NotifyEntry>(entries.Skip(entries.Count - 20)));
}
public static T RandomElement <T>(this HashSet <T> source, Random r)
{
if (source.Count <= 0)
{
throw new IndexOutOfRangeException();
}
int randomIndex = r.Next(source.Count);
return(source.Skip(randomIndex).First());
}
public long QuantumEntanglement()
{
long quantumEntanglement = _packages.First();
foreach (var pack in _packages.Skip(1))
{
quantumEntanglement *= pack;
}
return(quantumEntanglement);
}
HashSet <string> GetTempResults(HashSet <int> tempIds, Dictionary <int, HashSet <string> > tempFullOddResults)
{
return(tempIds.Skip(1)
.Aggregate(
new HashSet <string>(tempFullOddResults[tempIds.First()]),
(h, e) =>
{
h.IntersectWith(tempFullOddResults[e]); return h;
}
));
}
public static ushort GetFreePort()
{
var ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
var tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections();
var usedPorts = new HashSet<ushort>(tcpConnInfoArray.Select(x => (ushort)x.LocalEndPoint.Port));
var availablePorts = new HashSet<ushort>(Enumerable.Range(1024, 65535 - 1024).Select(x => (ushort)x));
availablePorts.ExceptWith(usedPorts);
return availablePorts.Skip(new Random().Next(availablePorts.Count - 1)).First();
}
public static ushort GetFreePort()
{
var ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
var tcpConnInfoArray = ipGlobalProperties.GetActiveTcpConnections();
var usedPorts = new HashSet <ushort>(tcpConnInfoArray.Select(x => (ushort)x.LocalEndPoint.Port));
var availablePorts = new HashSet <ushort>(Enumerable.Range(1024, 65535 - 1024).Select(x => (ushort)x));
availablePorts.ExceptWith(usedPorts);
return(availablePorts.Skip(new Random().Next(availablePorts.Count - 1)).First());
}
/// <summary>
/// Returns all nodes that in its input ports' scope. A node is in its
/// scope if that node is one of its upstream nodes.
/// </summary>
/// <param name="portIndex">Inport index</param>
/// <param name="checkEscape">
/// If need to exclude nodes that one of their downstream nodes are not
/// in the scope
/// </param>
/// <param name="isInclusive">
/// If a upstream node is ScopedNodeModel, need to include all upstream
/// nodes of that node.
/// </param>
/// <param name="forceToGetNodeForInport"></param>
/// <returns></returns>
public IEnumerable <NodeModel> GetInScopeNodesForInport(
int portIndex,
bool checkEscape = true,
bool isInclusive = true,
bool forceToGetNodeForInport = false)
{
// The related test cases are in DynmoTest.ScopedNodeTest.
var scopedNodes = new HashSet <NodeModel>();
Tuple <int, NodeModel> inputTuple = null;
if ((!forceToGetNodeForInport && !IsScopedInport(portIndex)) ||
!this.TryGetInput(portIndex, out inputTuple))
{
return(scopedNodes);
}
scopedNodes.Add(this);
var inputNode = inputTuple.Item2;
var workingList = new Queue <NodeModel>();
if (!checkEscape || (checkEscape && IsNodeInScope(inputNode, scopedNodes)))
{
workingList.Enqueue(inputNode);
scopedNodes.Add(inputNode);
}
// Collect all upstream nodes in BFS order
while (workingList.Any())
{
var currentNode = workingList.Dequeue();
if (!isInclusive && currentNode is ScopedNodeModel)
{
continue;
}
foreach (int index in Enumerable.Range(0, currentNode.InPortData.Count))
{
if (currentNode.TryGetInput(index, out inputTuple))
{
inputNode = inputTuple.Item2;
if (!checkEscape || (checkEscape && IsNodeInScope(inputNode, scopedNodes)))
{
workingList.Enqueue(inputNode);
scopedNodes.Add(inputNode);
}
}
}
}
return(scopedNodes.Skip(1));
}
static char[][] getPFMatrix(string key)
{
var set = new HashSet <char>(key.ToUpper() + pfAlphabet);
var matrix = new char[5][];
for (int i = 0; i < 5; i++)
{
matrix[i] = set.Skip(5 * i).Take(5).ToArray();
}
return(matrix);
}
/// <summary>Evicts entries from the strongly-referenced cache until the <see cref="MaximumSize"/> is satisfied.</summary>
private void evictStrong()
{
while (CurrentSize > MaximumSize && _strong.Count > 0)
{
// Pick two random entries and evict the one that's been used the least.
var item1 = _strong.Skip(Rnd.Next(_strong.Count)).First();
var item2 = _strong.Skip(Rnd.Next(_strong.Count)).First();
if (item1.UseCount < item2.UseCount)
{
_strong.Remove(item1);
CurrentSize -= item1.Strong.Size;
item1.Strong = null;
}
else
{
_strong.Remove(item2);
CurrentSize -= item2.Strong.Size;
item2.Strong = null;
}
Evictions++;
}
}
private HashSet <KeySet> GetDestinationKeySets(
HashSet <KeySet> immutableKeySets,
TableMapping tableMapping,
Dictionary <string, DbColumnType> destColumnNameTypeMappings,
IEnumerable <string> keyColumnNames)
{
var keySets = new HashSet <KeySet>();
var chunkIndex = 0;
var chunkSize = 1000;
while (chunkIndex * chunkSize < immutableKeySets.Count)
{
var chunkedImmutableKeySets = immutableKeySets.Skip(chunkIndex++ *chunkSize).Take(chunkSize);
using (IDbCommand cmd = GetDbCommand(
BuildSqlCmdTextForLoadDestinationKeySets(
chunkedImmutableKeySets,
tableMapping,
keyColumnNames), _conn, _trans))
{
cmd.CommandTimeout = _sqlCommandTimeout;
using (IDataReader dataReader = cmd.ExecuteReader())
{
while (dataReader.Read())
{
var keySet = new KeySet();
foreach (var keyColumnName in keyColumnNames)
{
keySet.Add(keyColumnName, destColumnNameTypeMappings[keyColumnName], dataReader[keyColumnName]);
}
if (keySets.Contains(keySet))
{
throw new Exception(
string.Format(
"The destination table ({0}) contains data with duplicated keys ({1})",
tableMapping.Destination,
keySet.ToString()));
}
keySets.Add(keySet);
}
}
}
}
return(keySets);
}
public static async Task <int> Task1(string file)
{
var rules = await ParseRules(file);
var lookup = rules
.SelectMany(kvp => kvp.Value, (kvp, c) => (from: kvp.Key, bag: c.Item1))
.ToLookup(x => x.bag, x => x.from);
var bags = new HashSet <string>();
BagsThatContain("shiny gold", lookup, bags);
return(bags.Skip(1).Count());
}
/// <summary>
/// Helper method for the SetCellContents methods.
/// Creates and adds valid cells to the object dictionary.
/// Creates, adds and removes dependecies as needed.
/// Invariant that the cell name is valid as it was checked in SetContentsOfCell
///
///
/// Throws an InvalidNameException if the name is invalid or null
/// Throws an ArgumentNullException if the contents are null
/// </summary>
/// <param name="name"></param>
/// <param name="contents"></param>
/// <returns></returns>
private HashSet <String> HandleSetCell(string name, Object contents)
{
HashSet <string> allDependentsForCell;
Cell oldCell = null;
//Checks if the cell already exists
if (cells.ContainsKey(name))
{
oldCell = cells[name];
cells.Remove(name); //Remove the cell if it exists already
}
HashSet <String> oldDependees = RecalculateDependecies(name, contents);
//Makes a new HashSet of all of the cells that will be affected by changing this cell
// plus this cell.
//Throws a CircularException if there is a circular dependency.
try
{
allDependentsForCell = new HashSet <string>(GetCellsToRecalculate(name).ToArray <string>());
}
catch (CircularException)
{
//If an exception is found, revert the dependency graph and contents then throw the exception
dependencies.ReplaceDependees(name, oldDependees);
if (oldCell != null)
{
cells.Add(name, oldCell);
}
throw;
}
//If the cell doesn't contain an empty string, add the new cell to the set
// (otherwise it stays removed from the dictionary)
if (!contents.Equals(""))
{
Cell cell = new Cell(contents, Lookup);
cells.Add(name, cell);
}
//Recalculates all of the values that depend on this cell, except for the current cell
//This is important if the cell is an empty string and doesn't exist in the dictionary
foreach (String dependent in allDependentsForCell.Skip(1))
{
cells[dependent].CalculateValue(Lookup);
}
return(allDependentsForCell);
}
public ActionResult <ResourceModel> Save(ResourceModel model)
{
if (_resourceModification.GetAllResources <IResource>(r => r.Id == model.Id).Count() > 0)
{
return(Conflict($"The resource '{model.Id}' already exists."));
}
var id = _resourceModification.Create(_resourceTypeTree[model.Type].ResourceType, r => {
var resourcesToSave = new HashSet <long>();
var resourceCache = new Dictionary <long, Resource>();
FromModel(model, resourcesToSave, resourceCache, r);
resourcesToSave.Skip(1).ForEach(id => _resourceModification.Modify(id, r => true));
});
return(GetDetails(id));
}
protected void ReevaluateSelected()
{
if (!Children.Any())
{
return;
}
// The state of this needs to be indeterminate if
// - at least one child is indeterminate, OR
// - at least two children differ in state
// Otherwise, the state of this needs to be the same as all the children, which is the same as the state of the first child.
var state = Children.First().Selected;
state = state == null ? null : (Children.Skip(1).Any(c => c.Selected != state) ? null : state);
if (Selected == state)
{
return;
}
SelectedChanged(state);
}
/// <summary>
/// bring out each combination given a set.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="set"></param>
/// <returns></returns>
static public HashSet <HashSet <T> > Eval <T>(HashSet <T> set)
{
if (set.Count == 0)
{
return(new HashSet <HashSet <T> >(
new HashSet <T>[] { new HashSet <T>(set.Comparer) }
,
HashSet <T> .CreateSetComparer()
));
}
else
{
///take the first element
///
//HashSet<T> head= new HashSet<T>();
//head.Add(set.First());
HashSet <T> beheadedSet = new HashSet <T>(set.Skip(1), set.Comparer);
var beheadedSetCombination = Eval(beheadedSet);
var withFirstCombination = new HashSet <HashSet <T> >(HashSet <T> .CreateSetComparer());
foreach (var item in beheadedSetCombination)
{
var t = new HashSet <T>(item, set.Comparer);
t.Add(set.First());
withFirstCombination.Add(t);
}
beheadedSetCombination.UnionWith(withFirstCombination);
return(beheadedSetCombination);
}
}
/// <summary>
/// Автоматический шаг дальше
/// </summary>
/// <param name="milliseconds"></param>
protected override void AutoNextCore()
{
if (CanSelectQuestion)
{
var index = new Random().Next(_questionsTable.Count);
var pair = _questionsTable.Skip(index).First();
SelectQuestion(pair.Item1, pair.Item2);
return;
}
if (CanSelectTheme)
{
var themeIndex = new Random().Next(_themesTable.Count);
themeIndex = _themesTable.Skip(themeIndex).First();
SelectTheme(themeIndex);
}
}
public static int CountAcresLongTime(IEnumerable <string> input)
{
var area = GetArea(input);
var values = new HashSet <int>();
for (int minute = 0; minute < 1000000000; minute++)
{
area = area.Select((s, i) => s.Select((s2, j) => Transform(s2, i, j, area)).ToList()).ToList();
if ((minute + 1) % 1000 == 0)
{
if (!values.Add(area.Sum(s => s.Count(c => c == '|')) * area.Sum(s => s.Count(c => c == '#'))))
{
return(values.Skip(1000000 % (minute + 1) - 1).First());
}
}
}
return(area.Sum(s => s.Count(c => c == '|')) * area.Sum(s => s.Count(c => c == '#')));
}
public void Ignoring_issuer_should_result_in_one_claim()
{
var hashSet = new HashSet <Claim>(_claims, new ClaimComparer(new ClaimComparer.Options {
IgnoreIssuer = true
}));
hashSet.Count.Should().Be(2);
var item = hashSet.First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("value");
item.Issuer.Should().Be("issuer1");
item = hashSet.Skip(1).First();
item.Type.Should().Be("claim_type1");
item.Value.Should().Be("Value");
item.Issuer.Should().Be("issuer1");
}
static string PlayFair(string input, string key, int dir)
{
var set = new HashSet <char>(key.ToUpper() + pfAlphabet);
var matrix = new char[5][];
for (int i = 0; i < 5; i++)
{
matrix[i] = set.Skip(5 * i).Take(5).ToArray();
}
var text = input.ToUpper().Replace('J', 'I').Replace(" ", string.Empty);
if (text.Length % 2 != 0)
{
text += 'X';
}
var pairs = Regex.Matches(text, "..").Cast <Match>().Select(x => DuplicatesPlayFair(x.Value.ToCharArray())).ToArray();
return(string.Join("", pairs.Select(x => new string(PairEncryption(matrix, x, dir))).ToArray()));
}
/// <summary>
/// 在指定函数调用过程中，从指定的索引分割当前操作为指定长度的集合。
/// </summary>
/// <param name="index">开始索引。</param>
/// <param name="length">操作长度。</param>
/// <param name="action">执行的操作。</param>
public void Split(int index, int length, Action action)
{
if (length > 0 && index >= 0 && length + index <= Count)
{
try
{
_SubItems = _Items.Skip(index).Take(length);
_SubCount = length;
action();
}
finally
{
_SubItems = null;
}
}
else
{
action();
}
}
/// <summary>
/// Get all nodes that in its input ports's scope. A node is in its
/// scope if that node is one of its upstream nodes.
/// </summary>
/// <param name="portIndex">Inport index</param>
/// <param name="checkEscape">
/// If need to exclude nodes that one of their downstream nodes are not
/// in the scope
/// </param>
/// <param name="isInclusive">
/// If a upstream node is ScopedNodeModel, need to include all upstream
/// nodes of that node.
/// </param>
/// <returns></returns>
public IEnumerable<NodeModel> GetInScopeNodesForInport(
int portIndex,
bool checkEscape = true,
bool isInclusive = true,
bool forceToGetNodeForInport = false)
{
// The related test cases are in DynmoTest.ScopedNodeTest.
var scopedNodes = new HashSet<NodeModel>();
Tuple<int, NodeModel> inputTuple = null;
if ((!forceToGetNodeForInport && !IsScopedInport(portIndex)) ||
!this.TryGetInput(portIndex, out inputTuple))
{
return scopedNodes;
}
scopedNodes.Add(this);
var inputNode = inputTuple.Item2;
var workingList = new Queue<NodeModel>();
if (!checkEscape || (checkEscape && IsNodeInScope(inputNode, scopedNodes)))
{
workingList.Enqueue(inputNode);
scopedNodes.Add(inputNode);
}
// Collect all upstream nodes in BFS order
while (workingList.Any())
{
var currentNode = workingList.Dequeue();
if (!isInclusive && currentNode is ScopedNodeModel)
{
continue;
}
foreach (int index in Enumerable.Range(0, currentNode.InPortData.Count))
{
if (currentNode.TryGetInput(index, out inputTuple))
{
inputNode = inputTuple.Item2;
if (!checkEscape || (checkEscape && IsNodeInScope(inputNode, scopedNodes)))
{
workingList.Enqueue(inputNode);
scopedNodes.Add(inputNode);
}
}
}
}
return scopedNodes.Skip(1);
}
public virtual void GenerateVMTCode(HashSet<Type> aTypesSet, HashSet<MethodBase> aMethodsSet, Func<Type, uint> aGetTypeID, Func<MethodBase, uint> aGetMethodUID)
{
new Comment("---------------------------------------------------------");
new Cosmos.Assembler.Label(InitVMTCodeLabel);
new Push { DestinationReg = Registers.EBP };
new Mov { DestinationReg = Registers.EBP, SourceReg = Registers.ESP };
mSequences = new DebugInfo.SequencePoint[0];
var xSetTypeInfoRef = VTablesImplRefs.SetTypeInfoRef;
var xSetMethodInfoRef = VTablesImplRefs.SetMethodInfoRef;
var xTypesFieldRef = VTablesImplRefs.VTablesImplDef.GetField("mTypes",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
string xTheName = DataMember.GetStaticFieldName(xTypesFieldRef);
DataMember xDataMember = (from item in Cosmos.Assembler.Assembler.CurrentInstance.DataMembers
where item.Name == xTheName
select item).FirstOrDefault();
if (xDataMember != null)
{
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Remove((from item in Cosmos.Assembler.Assembler.CurrentInstance.DataMembers
where item == xDataMember
select item).First());
}
var xData = new byte[16 + (aTypesSet.Count * GetVTableEntrySize())];
var xTemp = BitConverter.GetBytes(aGetTypeID(typeof(Array)));
xTemp = BitConverter.GetBytes(0x80000002);
Array.Copy(xTemp, 0, xData, 4, 4);
xTemp = BitConverter.GetBytes(aTypesSet.Count);
Array.Copy(xTemp, 0, xData, 8, 4);
xTemp = BitConverter.GetBytes(GetVTableEntrySize());
Array.Copy(xTemp, 0, xData, 12, 4);
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xTheName + "__Contents", xData));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xTheName + "__Handle", ElementReference.New(xTheName + "__Contents")));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xTheName, Cosmos.Assembler.ElementReference.New(xTheName + "__Handle")));
#if VMT_DEBUG
using (var xVmtDebugOutput = XmlWriter.Create(@"c:\data\vmt_debug.xml"))
{
xVmtDebugOutput.WriteStartDocument();
xVmtDebugOutput.WriteStartElement("VMT");
#endif
//Push((uint)aTypesSet.Count);
foreach (var xType in aTypesSet)
{
#if VMT_DEBUG
xVmtDebugOutput.WriteStartElement("Type");
xVmtDebugOutput.WriteAttributeString("TypeId", aGetTypeID(xType).ToString());
if (xType.BaseType != null)
{
xVmtDebugOutput.WriteAttributeString("BaseTypeId", aGetTypeID(xType.BaseType).ToString());
}
xVmtDebugOutput.WriteAttributeString("Name", xType.FullName);
#endif
// value contains true if the method is an interface method definition
SortedList<MethodBase, bool> xEmittedMethods = new SortedList<MethodBase, bool>(new MethodBaseComparer());
foreach (MethodBase xMethod in xType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (aMethodsSet.Contains(xMethod))
{ //) && !xMethod.IsAbstract) {
if (!xEmittedMethods.ContainsKey(xMethod))
{
xEmittedMethods.Add(xMethod, false);
}
}
}
foreach (MethodBase xCtor in xType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (aMethodsSet.Contains(xCtor))
{ // && !xCtor.IsAbstract) {
if (!xEmittedMethods.ContainsKey(xCtor))
{
xEmittedMethods.Add(xCtor, false);
}
}
}
foreach (var xIntf in xType.GetInterfaces())
{
foreach (var xMethodIntf in xIntf.GetMethods())
{
var xActualMethod = xType.GetMethod(xIntf.FullName + "." + xMethodIntf.Name,
(from xParam in xMethodIntf.GetParameters()
select xParam.ParameterType).ToArray());
if (xActualMethod == null)
{
// get private implemenation
xActualMethod = xType.GetMethod(xMethodIntf.Name,
(from xParam in xMethodIntf.GetParameters()
select xParam.ParameterType).ToArray());
}
if (xActualMethod == null)
{
try
{
if (!xIntf.IsGenericType)
{
var xMap = xType.GetInterfaceMap(xIntf);
for (int k = 0; k < xMap.InterfaceMethods.Length; k++)
{
if (xMap.InterfaceMethods[k] == xMethodIntf)
{
xActualMethod = xMap.TargetMethods[k];
break;
}
}
}
}
catch
{
}
}
if (aMethodsSet.Contains(xMethodIntf))
{
if (!xEmittedMethods.ContainsKey(xMethodIntf))
{
xEmittedMethods.Add(xMethodIntf, true);
}
}
}
}
int? xBaseIndex = null;
if (xType.BaseType == null)
{
xBaseIndex = (int)aGetTypeID(xType);
}
else
{
for (int t = 0; t < aTypesSet.Count; t++)
{
// todo: optimize check
var xItem = aTypesSet.Skip(t).First();
if (xItem.ToString() == xType.BaseType.ToString())
{
xBaseIndex = (int)aGetTypeID(xItem);
break;
}
}
}
if (xBaseIndex == null)
{
throw new Exception("Base type not found!");
}
for (int x = xEmittedMethods.Count - 1; x >= 0; x--)
{
if (!aMethodsSet.Contains(xEmittedMethods.Keys[x]))
{
xEmittedMethods.RemoveAt(x);
}
}
if (!xType.IsInterface)
{
Push(aGetTypeID(xType));
Move("VMT__TYPE_ID_HOLDER__" + DataMember.FilterStringForIncorrectChars(LabelName.GetFullName(xType) + " ASM_IS__" + xType.Assembly.GetName().Name), (int)aGetTypeID(xType));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(
new DataMember("VMT__TYPE_ID_HOLDER__" + DataMember.FilterStringForIncorrectChars(LabelName.GetFullName(xType) + " ASM_IS__" + xType.Assembly.GetName().Name), new int[] { (int)aGetTypeID(xType) }));
Push((uint)xBaseIndex.Value);
xData = new byte[16 + (xEmittedMethods.Count * 4)];
xTemp = BitConverter.GetBytes(aGetTypeID(typeof(Array)));
Array.Copy(xTemp, 0, xData, 0, 4);
xTemp = BitConverter.GetBytes(0x80000002); // embedded array
Array.Copy(xTemp, 0, xData, 4, 4);
xTemp = BitConverter.GetBytes(xEmittedMethods.Count); // embedded array
Array.Copy(xTemp, 0, xData, 8, 4);
xTemp = BitConverter.GetBytes(4); // embedded array
Array.Copy(xTemp, 0, xData, 12, 4);
string xDataName = "____SYSTEM____TYPE___" + DataMember.FilterStringForIncorrectChars(LabelName.GetFullName(xType) + " ASM_IS__" + xType.Assembly.GetName().Name) + "__MethodIndexesArray";
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName, xData));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName + "_Handle", ElementReference.New(xDataName)));
Push(xDataName + "_Handle");
xDataName = "____SYSTEM____TYPE___" + DataMember.FilterStringForIncorrectChars(LabelName.GetFullName(xType) + " ASM_IS__" + xType.Assembly.GetName().Name) + "__MethodAddressesArray";
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName, xData));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName + "_Handle", ElementReference.New(xDataName)));
Push(xDataName + "_Handle");
xData = new byte[16 + Encoding.Unicode.GetByteCount(xType.FullName + ", " + xType.Module.Assembly.GetName().FullName)];
xTemp = BitConverter.GetBytes(aGetTypeID(typeof(Array)));
Array.Copy(xTemp, 0, xData, 0, 4);
xTemp = BitConverter.GetBytes(0x80000002); // embedded array
Array.Copy(xTemp, 0, xData, 4, 4);
xTemp = BitConverter.GetBytes((xType.FullName + ", " + xType.Module.Assembly.GetName().FullName).Length);
Array.Copy(xTemp, 0, xData, 8, 4);
xTemp = BitConverter.GetBytes(2); // embedded array
Array.Copy(xTemp, 0, xData, 12, 4);
xDataName = "____SYSTEM____TYPE___" + DataMember.FilterStringForIncorrectChars(LabelName.GetFullName(xType) + " ASM_IS__" + xType.Assembly.GetName().Name);
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName, xData));
Cosmos.Assembler.Assembler.CurrentInstance.DataMembers.Add(new DataMember(xDataName + "_Handle", ElementReference.New(xDataName)));
Push("0" + xEmittedMethods.Count.ToString("X") + "h");
Call(xSetTypeInfoRef);
}
for (int j = 0; j < xEmittedMethods.Count; j++)
{
MethodBase xMethod = xEmittedMethods.Keys[j];
#if VMT_DEBUG
xVmtDebugOutput.WriteStartElement("Method");
xVmtDebugOutput.WriteAttributeString("Id", aGetMethodUID(xMethod).ToString());
xVmtDebugOutput.WriteAttributeString("Name", xMethod.GetFullName());
xVmtDebugOutput.WriteEndElement();
#endif
var xMethodId = aGetMethodUID(xMethod);
if (!xType.IsInterface)
{
if (xEmittedMethods.Values[j])
{
var xNewMethod = xType.GetMethod(xMethod.DeclaringType.FullName + "." + xMethod.Name,
(from xParam in xMethod.GetParameters()
select xParam.ParameterType).ToArray());
if (xNewMethod == null)
{
// get private implementation
xNewMethod = xType.GetMethod(xMethod.Name,
(from xParam in xMethod.GetParameters()
select xParam.ParameterType).ToArray());
}
if (xNewMethod == null)
{
try
{
var xMap = xType.GetInterfaceMap(xMethod.DeclaringType);
for (int k = 0; k < xMap.InterfaceMethods.Length; k++)
{
if (xMap.InterfaceMethods[k] == xMethod)
{
xNewMethod = xMap.TargetMethods[k];
break;
}
}
}
catch
{
}
}
xMethod = xNewMethod;
}
Push((uint)aGetTypeID(xType));
Push((uint)j);
Push((uint)xMethodId);
if (xMethod.IsAbstract)
{
// abstract methods dont have bodies, oiw, are not emitted
Push(0);
}
else
{
Push(ILOp.GetMethodLabel(xMethod));
}
Push(0);
Call(VTablesImplRefs.SetMethodInfoRef);
}
}
#if VMT_DEBUG
xVmtDebugOutput.WriteEndElement(); // type
#endif
}
#if VMT_DEBUG
xVmtDebugOutput.WriteEndElement(); // types
xVmtDebugOutput.WriteEndDocument();
}
#endif
new Cosmos.Assembler.Label("_END_OF_" + InitVMTCodeLabel);
new Pop { DestinationReg = Registers.EBP };
new Return();
}
protected async Task FetchUrlInfos(Status[] ses)
{
if (ses == null || ses.Length == 0)
return;
var mem = MemoryCache.Default;
var urls = new HashSet<string>();
foreach (var s in ses)
{
var us = Utils.ExtractUrlFromWeibo(s.text);
foreach(var url in us)
{
if (mem.Get("http://t.cn/" + url) == null)
urls.Add(url);
}
//urls.Add(us);
if (s.retweeted_status != null)
{
var rus = Utils.ExtractUrlFromWeibo(s.retweeted_status.text);
foreach (var url in rus)
{
if (mem.Get("http://t.cn/" + url) == null)
urls.Add(url);
}
}
}
if(urls.Count >= 20)
{
var tasks = new Task[2];
var u1 = urls.Take(20);
tasks[0] = FetchUrlInfosImp(u1);
var u2 = urls.Skip(20);
tasks[1] = FetchUrlInfosImp(u2);
await Task.WhenAll(tasks);
}else
{
await FetchUrlInfosImp(urls);
}
}
//added by gremlin aggruthmanager
private void DoAggRuthAgentManager()
{
string Names;
float income = this.spyBudget;
this.DesiredAgentsPerHostile = (int)(income * .08f) + 1;
this.DesiredAgentsPerNeutral = (int)(income * .03f) + 1;
//this.DesiredAgentsPerHostile = 5;
//this.DesiredAgentsPerNeutral = 2;
this.BaseAgents = empire.GetPlanets().Count / 2;
this.DesiredAgentCount = 0;
foreach (KeyValuePair<Empire, Ship_Game.Gameplay.Relationship> Relationship in this.empire.GetRelations())
{
if (!Relationship.Value.Known || Relationship.Key.isFaction || Relationship.Key.data.Defeated)
{
continue;
}
if (Relationship.Value.Posture == Posture.Hostile)
{
GSAI desiredAgentCount = this;
desiredAgentCount.DesiredAgentCount = desiredAgentCount.DesiredAgentCount + this.DesiredAgentsPerHostile;
}
if (Relationship.Value.Posture != Posture.Neutral)
{
continue;
}
GSAI gSAI = this;
gSAI.DesiredAgentCount = gSAI.DesiredAgentCount + this.DesiredAgentsPerNeutral;
}
GSAI desiredAgentCount1 = this;
desiredAgentCount1.DesiredAgentCount = desiredAgentCount1.DesiredAgentCount + this.BaseAgents;
int empirePlanetSpys = this.empire.GetPlanets().Count() / 3 + 3;// (int)(this.spyBudget / (this.empire.GrossTaxes * 3));
int currentSpies = this.empire.data.AgentList.Count;
if (this.spyBudget >= 250f && currentSpies < empirePlanetSpys)
{
Names = (!File.Exists(string.Concat("Content/NameGenerators/spynames_", this.empire.data.Traits.ShipType, ".txt")) ? File.ReadAllText("Content/NameGenerators/spynames_Humans.txt") : File.ReadAllText(string.Concat("Content/NameGenerators/spynames_", this.empire.data.Traits.ShipType, ".txt")));
string[] Tokens = Names.Split(new char[] { ',' });
Agent a = new Agent();
a.Name = AgentComponent.GetName(Tokens);
this.empire.data.AgentList.Add(a);
this.spyBudget -= 250f;
}
int Defenders = 0;
int Offense = 0;
foreach (Agent a in this.empire.data.AgentList)
{
if (a.Mission == AgentMission.Defending)
{
Defenders++;
}
else if (a.Mission != AgentMission.Undercover)
{
Offense++;
}
if (a.Mission != AgentMission.Defending || a.Level >= 2 || this.spyBudget <= 50f)
{
continue;
}
a.AssignMission(AgentMission.Training, this.empire, "");
}
int DesiredOffense = (int)(this.empire.data.AgentList.Count * .3f);
//int DesiredOffense = (int)(this.empire.data.AgentList.Count - empire.GetPlanets().Count * .33f); // (int)(0.33f * (float)this.empire.data.AgentList.Count);
//int DesiredOffense = this.empire.data.AgentList.Count / 2;
foreach (Agent agent in this.empire.data.AgentList)
{
if (agent.Mission != AgentMission.Defending && agent.Mission != AgentMission.Undercover || Offense >= DesiredOffense )
{
continue;
}
List<Empire> PotentialTargets = new List<Empire>();
foreach (KeyValuePair<Empire, Ship_Game.Gameplay.Relationship> Relation in this.empire.GetRelations())
{
if (!Relation.Value.Known || Relation.Key.isFaction || Relation.Key.data.Defeated || Relation.Value.Posture != Posture.Neutral && Relation.Value.Posture != Posture.Hostile)
{
continue;
}
PotentialTargets.Add(Relation.Key);
}
if (PotentialTargets.Count <= 0)
{
continue;
}
HashSet<AgentMission> PotentialMissions = new HashSet<AgentMission>();
Empire Target = PotentialTargets[HelperFunctions.GetRandomIndex(PotentialTargets.Count)];
if (this.empire.GetRelations()[Target].AtWar)
{
if (agent.Level >= 8)
{
PotentialMissions.Add(AgentMission.InciteRebellion);
PotentialMissions.Add(AgentMission.Assassinate);
PotentialMissions.Add(AgentMission.StealTech);
}
if (agent.Level >= 4)
{
PotentialMissions.Add(AgentMission.StealTech);
PotentialMissions.Add(AgentMission.Robbery);
PotentialMissions.Add(AgentMission.Sabotage);
}
if (agent.Level < 4)
{
PotentialMissions.Add(AgentMission.Sabotage);
PotentialMissions.Add(AgentMission.StealTech);
PotentialMissions.Add(AgentMission.Robbery);
//PotentialMissions.Add(AgentMission.Infiltrate);
}
}
if (this.empire.GetRelations()[Target].Posture == Posture.Hostile)
{
if (agent.Level >= 8)
{
PotentialMissions.Add(AgentMission.StealTech);
PotentialMissions.Add(AgentMission.Assassinate);
}
if (agent.Level >= 4)
{
PotentialMissions.Add(AgentMission.Robbery);
PotentialMissions.Add(AgentMission.Sabotage);
}
if (agent.Level < 4)
{
PotentialMissions.Add(AgentMission.Sabotage);
}
}
if (this.empire.GetRelations()[Target].SpiesDetected > 0)
{
if (agent.Level >= 4) PotentialMissions.Add(AgentMission.Assassinate);
}
HashSet<AgentMission> remove = new HashSet<AgentMission>();
foreach(AgentMission mission in PotentialMissions)
{
switch (mission)
{
case AgentMission.Defending:
case AgentMission.Training:
break;
case AgentMission.Infiltrate:
if (ResourceManager.AgentMissionData.InfiltrateCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.Assassinate:
if (ResourceManager.AgentMissionData.AssassinateCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.Sabotage:
if (ResourceManager.AgentMissionData.SabotageCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.StealTech:
if (ResourceManager.AgentMissionData.StealTechCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.Robbery:
if (ResourceManager.AgentMissionData.RobberyCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.InciteRebellion:
if (ResourceManager.AgentMissionData.RebellionCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.Undercover:
if (ResourceManager.AgentMissionData.InfiltrateCost > this.spyBudget)
{
remove.Add(mission);
}
break;
case AgentMission.Recovering:
break;
default:
break;
}
}
foreach(AgentMission removeMission in remove)
{
PotentialMissions.Remove(removeMission);
}
if (PotentialMissions.Count <= 0)
{
continue;
}
AgentMission am = PotentialMissions.Skip(HelperFunctions.GetRandomIndex(PotentialMissions.Count)).FirstOrDefault();
if(am !=null)
agent.AssignMission(am, this.empire, Target.data.Traits.Name);
Offense++;
}
}
