public string UpdateParamsWithValues(string originalSql) { string[] parts = originalSql.Replace("N'", "'").Replace("''", "'").Split(';'); if (parts.Length <= 1) return originalSql; string sql = String.Join(";", parts.Take(parts.Length - 1).ToArray()); string paramList = parts.Last(); var parameters = new Dictionary<string, string>(); ITokenizer tokenizer = new SqlTokenizer(paramList); tokenizer.ReadNextToken(); do { string parameter = tokenizer.Current.Value; tokenizer.ReadNextToken(); tokenizer.ExpectToken(Constants.Assignment); parameters.Add(parameter, ProcessParameter(tokenizer, parameter)); } while (tokenizer.TokenEquals(Constants.Comma)); foreach (var item in parameters.Reverse()) sql = sql.Replace(item.Key, item.Value); return sql; }
public static void DataBind(this Motor engine, Route route) { var list = new Dictionary<string, object>(); var function = engine.RuntimeContext.Runnable.FunctionTable[route.Action]; var instructions = engine.RuntimeContext.Runnable.Instructions; for (int i = function.EntryPoint; i < instructions.Length; i++) { var inst = instructions[i]; if (inst.OpCode == OpCode.DCL) { var value = route.Context.Request[inst.Operands[0].Value.ToString()] ?? string.Empty; list.Add(inst.Operands[0].Value.ToString(), value); } if (inst.OpCode == OpCode.EMP) break; } foreach (var keypar in list.Reverse()) { var op = new Operand(OperandType.Literal, keypar.Value); engine.RuntimeContext.Runnable.ParamStack.Push(op); } }
internal static void CreateSearchNavigationNodes(ClientContext clientContext, Web web, Dictionary<string, string> searchNavigationNodes) { if (searchNavigationNodes == null || searchNavigationNodes.Count == 0) return; var searchNavigation = web.Navigation.GetNodeById(1040); NavigationNodeCollection nodeCollection = searchNavigation.Children; clientContext.Load(searchNavigation); clientContext.Load(nodeCollection); clientContext.ExecuteQuery(); for (int i = nodeCollection.Count - 1; i >= 0; i--) { nodeCollection[i].DeleteObject(); } foreach (KeyValuePair<string, string> newNode in searchNavigationNodes.Reverse<KeyValuePair<string, string>>()) { nodeCollection.Add(new NavigationNodeCreationInformation { Title = newNode.Key, Url = newNode.Value }); } clientContext.ExecuteQuery(); }
static void ValidateUserNames(string input) { string pattern = @"(?<=[\s\\\/]|^)([A-Za-z][A-Za-z0-9_]{3,25})"; Regex regex = new Regex(pattern); MatchCollection matchCollection = regex.Matches(input); Dictionary<int, string> sumOfUsernames = new Dictionary<int, string>(); for(int i = 0; i < matchCollection.Count - 1; i++) { string userNames = matchCollection[i].Value + " " + matchCollection[i + 1].Value; int sumOfUsers = GetSumOfUserNames(userNames); if(!sumOfUsernames.ContainsKey(sumOfUsers)) sumOfUsernames.Add(sumOfUsers, userNames); } SortedDictionary<int, string> sortedSum = new SortedDictionary<int, string>(sumOfUsernames); foreach(KeyValuePair<int, string> key in sumOfUsernames.Reverse()) { string[] userNames = key.Value.Split(' ').ToArray(); Console.WriteLine(userNames[0]); Console.WriteLine(userNames[1]); break; } }
static void MakeSchedule() { int currentDuration = 0; trainScheduleForward = stationsInfo.ToDictionary( kvp => stationsByName[kvp.Key], kvp => currentDuration += kvp.Value ); trainScheduleDuration = currentDuration; trainScheduleBackwards = trainScheduleForward.Reverse().ToDictionary( kvp => kvp.Key, kvp => trainScheduleDuration - kvp.Value ); #if DEBUG Console.WriteLine("# Schedule"); Console.WriteLine(string.Join(Environment.NewLine, trainScheduleForward)); Console.WriteLine(); Console.WriteLine(string.Join(Environment.NewLine, trainScheduleBackwards)); Console.WriteLine(); #endif }
private void TickAllTimers() { float time = Time.deltaTime; // Purpose of this is the same as a reverse for loop, if a timer is removed, shifting would occur // If we iterate backwards we won't get a CollectionWasModifier error // Placeholder to prevent table head smacking foreach (var kvp in timers.Reverse()) { kvp.Value.TryTick(time); } }
public Dictionary <string, int> GetTotalFiles() { Dictionary <string, int> totalFiles = new Dictionary <string, int>(); try { StringBuilder sbQuery = new StringBuilder(); //select sbQuery.Append("select create_at, count(*) Count "); //from sbQuery.Append("from files "); //group by sbQuery.Append($"group by create_at "); //order by sbQuery.Append($"order by create_at desc "); //limit sbQuery.Append($"limit 5 "); SQLiteCommand command = new SQLiteCommand(sbQuery.ToString(), connect); SQLiteDataReader queryReader = command.ExecuteReader(); while (queryReader.Read()) { string dateName = string.Empty; //2020908 -> 9.8 dateName = queryReader[0].ToString(); dateName = dateName.Substring(4, 4).Insert(2, "."); if (dateName[3] == '0') { dateName = dateName.Remove(3, 1); } if (dateName[0] == '0') { dateName = dateName.Remove(0, 1); } totalFiles.Add(dateName, Convert.ToInt32(queryReader[1])); } totalFiles = totalFiles.Reverse().ToDictionary(dict => dict.Key, dict => dict.Value); } catch { return(null); } return(totalFiles); }
protected void AddANewShortCutToEndOfList() { var ShortCuts = GetWindowShortCuts(); var CanUsed = (from x in WinList.Reverse() where !(ShortCuts.FindIndex(y => y.WindowGuid == x.Key) > -1) select x).ToList(); if (CanUsed.Count > 0) { AddNewShortCutWindow(CanUsed[0].Key, false); } }
internal static string ContractToString(double value) { foreach (var m in Multipliers.Reverse()) { if (value >= m.Value) { return((value / m.Value).ToString() + m.Key); } } return(value.ToString()); }
/// <summary> /// Returns a <see cref="string"/> that represents this instance. /// </summary> /// <returns>A <see cref="string"/> that represents this instance.</returns> public override string ToString() { foreach (var multiplier in multipliers.Reverse()) { if (Value >= multiplier.Value && Value % ((decimal)multiplier.Value / 1000) == 0) { return($"{Value / (decimal)multiplier.Value}{multiplier.Key}".ToString(CultureInfo.CurrentCulture)); } } return($"{Value.ToString(CultureInfo.CurrentCulture)}{B}"); }
public static void Main() { string input = Console.ReadLine(); var nameAndDateInDictionary = new Dictionary <string, DateTime>(); while (input != "end") { List <string> NameAndDate = input .Split(' ') //! like Yoan Enchev -> 27.04.2017 .ToList(); string name = NameAndDate[0]; string Getdate = NameAndDate[2]; //[1] -> var date = DateTime.ParseExact(Getdate, "dd/MM/yyyy", CultureInfo.InvariantCulture); nameAndDateInDictionary[name] = date; input = Console.ReadLine(); } int howManyEqualPairs = 0; foreach (var kvp_1 in nameAndDateInDictionary) { DateTime date_1 = kvp_1.Value; string name_1 = kvp_1.Key; foreach (var kvp_2 in nameAndDateInDictionary) { DateTime date_2 = kvp_2.Value; string name_2 = kvp_2.Key; if (date_1 == date_2 && name_1 != name_2) { howManyEqualPairs++; } } } Dictionary <string, DateTime> DescendingDate; DescendingDate = nameAndDateInDictionary .Reverse() .OrderByDescending(d => d.Value) .ToDictionary(x => x.Key, y => y.Value); var takeFiveOrLess = DescendingDate .Skip(DescendingDate.Count - 5) .Take(5) .ToDictionary(x => x.Key, y => y.Value); Console.WriteLine(string.Join(Environment.NewLine, takeFiveOrLess.Keys)); }
private static void PrintUsers(Dictionary <string, DateTime> registeredUsers) { var result = registeredUsers .Reverse() .OrderBy(e => e.Value) .Take(5) .OrderByDescending(e => e.Value) .ToDictionary(e => e.Key, e => e.Value) .Keys; Console.Write(string.Join(Environment.NewLine, result)); }
static void ReplaceUppercaseWords(StringBuilder text, Dictionary <Match, string> replacementsByMatches) { foreach (KeyValuePair <Match, string> pair in replacementsByMatches.Reverse()) { string upcaseWord = pair.Key.Value; int index = pair.Key.Index; string replacement = pair.Value; text.Remove(index, upcaseWord.Length); text.Insert(index, replacement); } }
public string IntToRoman(int num) { string s = ""; while (num > 0) { var rom = Dict.Reverse().Where(x => num - x.Value >= 0).FirstOrDefault(); s += rom.Key; num -= rom.Value; } return(s); }
public void InsertCash(float value) { if (RemainingCosts <= 0) { MessageBox.Show("No remaining costs, buy a ticket below."); return; } if (Balance <= 0) { MessageBox.Show("Out of cash."); return; } if (_money[value].Amount > 0) { RemainingCosts -= value; _money[value].Amount -= 1; CalculateBalance(); // Check if Tickets are paid off and calculate exchange if (RemainingCosts <= 0) { float returnMoney = (float)Math.Round(Math.Abs(RemainingCosts), 2); var exchange = returnMoney; foreach (KeyValuePair <float, MoneyItem> entry in _money.Reverse()) { returnMoney = (float)Math.Round(returnMoney, 2); float rest = returnMoney / entry.Key; if (rest >= 1) { returnMoney -= (float)Math.Floor(rest) * entry.Key; _money[entry.Key].Amount += (int)Math.Floor(rest); } } RemainingCosts = 0; CalculateBalance(); // Output string output = ""; output += "Ticket(s) purchased!\n"; output += "--------------------\n"; output += $"{this.ticketOutput}\n"; output += $"Exchange: \t{exchange.ToString("0.00")}€"; MessageBox.Show(output); this.ticketOutput = ""; } } }
public static IDictionary <string, string> GetIrregularPlurals() { var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); foreach (KeyValuePair <string, string> item in dictionary.Reverse()) { if (!result.ContainsKey(item.Value)) { result.Add(item.Value, item.Key); } } return(result); }
private static string GetSubjectNameItemString(Dictionary <string, string> dic) { var rev = dic.Reverse(); var sb = new StringBuilder(); foreach (var item in rev) { sb.Append(item.Key + "=" + item.Value + ","); } sb.Length--; return(sb.ToString()); }
internal static Dictionary <string, string> GetIrregularPlurals() { var result = new Dictionary <string, string>(); foreach (var item in dictionary.Reverse()) { if (!result.ContainsKey(item.Value)) { result.Add(item.Value, item.Key); } } return(result); }
public IList <IList <int> > LevelOrderBottom(TreeNode root) { RunLevelOrderBottom(root, 0); var reversed = treeValueCol.Reverse(); IList <IList <int> > results = new List <IList <int> >(); foreach (KeyValuePair <int, IList <int> > level in reversed) { results.Add(level.Value); } return(results); }
public static AssemblyResourceStore GetResourceStoreFromVirtualPath(string virtualPath) { string path = VirtualPathUtility.ToAppRelative(virtualPath).ToLower(); foreach (var pair in AssemblyResourceStores.Reverse()) { if (path.Contains(pair.Key) && pair.Value.IsPathResourceStream(path)) { return(pair.Value); } } return(null); }
static void Main(string[] args) { string path = null; try { path = Directory.GetCurrentDirectory() + @"\text.txt"; } catch { Console.WriteLine("File not found!"); } string text = null; if (path != null) { text = ReadInfo(path); } var wordsAndCounter = new Dictionary <string, int>(); if (text != null) { int value = 0; var words = text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); words = words.OrderBy(s => s).ToArray(); words = words.Reverse().ToArray(); foreach (var word in words) { if (wordsAndCounter.TryGetValue(word, out value)) { wordsAndCounter[word]++; } else { wordsAndCounter.Add(word, 1); } } wordsAndCounter = wordsAndCounter.OrderBy(pair => pair.Value).ToDictionary(pair => pair.Key, pair => pair.Value); wordsAndCounter = wordsAndCounter.Reverse().ToDictionary(pair => pair.Key, pair => pair.Value); int cnt = 0; foreach (var word in wordsAndCounter) { if (cnt < 10) { Console.WriteLine(word.Key + " - " + word.Value); } cnt++; } } }
public void ModifyDashSequence(BaseBrick brick, int brickLimit, out BaseBrick lastBrick) { lastBrick = brick; if (dashSequence != null) { //checking if sequence already has the brick in sequence or not. If not then we will add it to sequence if (!dashSequence.ContainsKey(brick.ID) && brick != null) { brick.ToggleSelectState(true); dashSequence.Add(brick.ID, brick); Debug.Log("Added to seq brick ID : " + brick.ID); } else { //if brick is already present then we want to remove it from the sequence if user selected the brick again List <string> toRemove = new List <string>(); //finding all the bricks from the end of the sequence to the point user has touched foreach (KeyValuePair <string, BaseBrick> pair in dashSequence.Reverse()) { if (pair.Key != brick.ID) { toRemove.Add(pair.Key); } if (pair.Key == brick.ID) { toRemove.Add(pair.Key); break; } } //removing it from the sequence foreach (string key in toRemove) { dashSequence[key].ToggleSelectState(false); dashSequence.Remove(key); Debug.Log("Brick removed with ID : " + key); } //last brick is needed to find the next adjacent bricks to avoid adjacent movements if (dashSequence.Count > 0) { lastBrick = dashSequence[dashSequence.Keys.Last()]; } else { //if all the items were removed then we want the current cell player is in to be returned lastBrick = currentBrickCell; } } } }
void MineLonger(IEnumerable <string> previous, double minSupport, Dictionary <string, double> subFList, List <ItemSet> SubFreqKey) { foreach (var kvpair in subFList.Reverse()) { var items = previous.ToList(); items.Add(kvpair.Key); // add all (n+1)-itemsets containing previous and where n = previous.Count ItemSet its = new ItemSet(items, kvpair.Value); if (its.Support >= minSupport) { patterns.Add(its); } } foreach (var kvpair in subFList.Reverse()) { var items = previous.ToList(); items.Add(kvpair.Key); List <ItemSet> subFreqByKey = new List <ItemSet>(); FPTree subsubTree = BuildSubTree(SubFreqKey, items[items.Count - 2], minSupport); MinePatterns(subsubTree.rootNode, kvpair.Key, minSupport, subFreqByKey); var _subFList = GenerateFList(subFreqByKey, kvpair.Key, minSupport); //create new FList for newly added pattern MineLonger(items, minSupport, _subFList, subFreqByKey); } }
private void InitializeEncoder(string input) { frequencies = new Dictionary <char, decimal>(256); foreach (var c in input) { if (!frequencies.ContainsKey(c)) { frequencies.Add(c, 0); } frequencies[c]++; } frequencies = frequencies.Reverse().ToDictionary(pair => pair.Key, pair => pair.Value); }
private static void DrawIcons_(Component[] components, Rect target_rect) { // DynamicBoneのm_Rootの対象となるGameObject if (dynamic_bone_roots_.Contains(components[0].transform)) { DrawIcon_(icon_resources_["DynamicBoneRoot"], target_rect); return; } foreach (Component component in components) { foreach (var icon_info in icon_resources_.Reverse()) { if (component != null && component.GetType().Name.Contains(icon_info.Key)) { var icon = icon_info.Value; // DynamicBoneのm_Rootに対象となるTransformが設定されていない場合は専用のアイコンに切り替える if (kDynamicBoneType != null && component.GetType() == kDynamicBoneType) { if (kDynamicBoneType.GetField("m_Root").GetValue(component) == null) { icon = icon_resources_["DynamicBonePartial"]; } } #if (VRC_SDK_VRCSDK3 && !UDON) // PBがアタッチされていたら専用のアイコンに切り替える. rootTransformが設定されていない場合は警告用のアイコンを表示する foreach (var pb in component.GetComponents <VRCPhysBone>().Where(obj => obj != null)) { if (pb.rootTransform != null) { icon = icon_resources_["VRCPhysBoneRoot"]; } else { icon = icon_resources_["VRCPhysBonePartial"]; } } #endif DrawIcon_(icon, target_rect); if (VRChierarchyHighlighterEdit.is_draw_vers.GetValue()) { PreviewVers_(component, target_rect); } return; } } } }
static void Main(string[] args) { graph = new Dictionary <string, List <string> >(); dependencies = new Dictionary <string, int>(); graph = ReadGraph(); dependencies = DefineDependencies(); dependencies = dependencies.Reverse().ToDictionary(x => x.Key, x => x.Value); var sorted = SearchGraph(); if (sorted != null) { Console.WriteLine(string.Join(" ", sorted)); } }
private static void PrintFirstFiveRegisteredUsers() { var result = userCollection .Reverse() .OrderBy(user => user.Value) .Take(5) .OrderByDescending(user => user.Value) .ToDictionary(x => x.Key, x => x.Value); foreach (var user in result) { Console.WriteLine(user.Key); } }
public void DrawMeshOnEachBranch() { foreach (var branch in SplinePlus.SPData.DictBranches) { //update branches layers if (!DMBranches.ContainsKey(branch.Key)) { var newBranchLayer = new DMBranch(); newBranchLayer.MeshHolder = new GameObject("Mesh Holder"); newBranchLayer.MeshHolder.AddComponent <MeshFilter>(); newBranchLayer.MeshHolder.AddComponent <MeshRenderer>(); newBranchLayer.MeshHolder.transform.parent = this.gameObject.transform; DMBranches.Add(branch.Key, newBranchLayer); } //Draw all branches meshesB if (branch.Value.Vertices.Count > 0 && DMBranches[branch.Key].PrefabMeshes.Count > 0) { var dMBranch = DMBranches[branch.Key]; var branchFinalMesh = DrawMesh(branch.Value, dMBranch); branchFinalMesh.RecalculateBounds(); if (dMBranch.SmoothNormals) { NormalSolver.RecalculateNormals(branchFinalMesh, dMBranch.SmoothNormalsAngle); } else { branchFinalMesh.RecalculateNormals(); } dMBranch.MeshHolder.GetComponent <MeshFilter>().sharedMesh = branchFinalMesh; } } foreach (var dMBranch in DMBranches.Reverse()) { if (!SplinePlus.SPData.DictBranches.ContainsKey(dMBranch.Key)) { MonoBehaviour.DestroyImmediate(dMBranch.Value.MeshHolder); DMBranches.Remove(dMBranch.Key); } } if (IsUpdateBase) { IsUpdateBase = false; } }
internal void AddTownToListReversed(int pathlenght, Centers towncenter, Dictionary <Centers, Centers> camefrom) { if (!TownAlreadyMeasured(towncenter) || pathlenght < distancetoalltowns[towncenter].Distance) { reversecamefrom.Clear(); foreach (KeyValuePair <Centers, Centers> node in camefrom.Reverse()) { reversecamefrom[node.Value] = node.Key; } distancetoalltowns[towncenter] = (new TownDistance { Distance = pathlenght, town = towncenter, pathway = reversecamefrom }); } }
/// <summary> /// Updates the UI listing, it creates the necessary items not yet listed, update existing items and remove unused entries /// </summary> public void UpdateUI() { List <int> processedIDs = new List <int>(); // Update existing slots and add new ones foreach (PhotonPlayer player in PhotonNetwork.playerList) { // Update existing slot if (_slots.ContainsKey(player.ID)) { // Found ID, refresh data _slots[player.ID].RefreshData(player); // Add ID to processed IDs list processedIDs.Add(player.ID); Debug.Log("Player " + player.NickName + " already has a playerslot, updating existing slot..."); } // Create new slot else { // Instantiate prefab and set data GameObject slot = Instantiate(_playerSlotPrefab, _playerSlotHolder); slot.transform.localScale = Vector3.one; slot.transform.localPosition = new Vector3(slot.transform.localPosition.x, slot.transform.localPosition.y, 0); PlayerSlot playerSlot = slot.GetComponent <PlayerSlot>(); playerSlot.RefreshData(player); // Add to dictionary _slots.Add(player.ID, playerSlot); // Add ID to processed IDs list processedIDs.Add(player.ID); Debug.Log("Creating a new PlayerSlot for player: " + player.NickName); } } // Remove playerslots of players that are no longer connected to the room foreach (var slot in _slots.Reverse()) { if (!processedIDs.Contains(slot.Key)) { _slots.Remove(slot.Key); Destroy(slot.Value.gameObject); } } }
/// <summary> /// Finds the supervisor. /// </summary> /// <param name="nPlant">The n plant.</param> /// <param name="nonBlocking">if set to <c>true</c> [non blocking].</param> private void FindSupervisor(int nPlant, bool nonBlocking) { _numberOfRunningThreads = 0; _statesStack = new Stack <StatesTuple>(); _removeBadStates = new Stack <bool>(); _validStates = new Dictionary <StatesTuple, bool>(StatesTupleComparator.GetInstance()); MakeReverseTransitions(); var initialIndex = new StatesTuple(new int[_statesList.Count], _bits, _tupleSize); _statesStack.Push(initialIndex); _removeBadStates.Push(false); var vThreads = new Task[NumberOfThreads - 1]; for (var i = 0; i < NumberOfThreads - 1; ++i) { vThreads[i] = Task.Factory.StartNew(() => FindStates(nPlant)); } FindStates(nPlant); for (var i = 0; i < NumberOfThreads - 1; ++i) { vThreads[i].Wait(); } foreach (var s in _validStates.Reverse()) { if (s.Value) { _validStates.Remove(s.Key); } } bool vNewBadStates; do { vNewBadStates = DepthFirstSearch(false, true); GC.Collect(); if (nonBlocking) { vNewBadStates |= RemoveBlockingStates(true); } } while (vNewBadStates); }
/// <summary> /// Merge given dictionaries /// </summary> /// <param name="dictionaries">dictionaries to merge</param> /// <param name="overrideDueplicateWithLatterDictionaryValue"> /// If true and duplicate key exists, then dupe key's values are overriden by latter dictionary values /// </param> public Dictionary<string, string> MergeDictionaries( Dictionary<int, Dictionary<string, string>> dictionaries, bool overrideDueplicateWithLatterDictionaryValue = true) { Dictionary<string, string> result = new Dictionary<string, string>(dictionaries.Count); var query = overrideDueplicateWithLatterDictionaryValue ? dictionaries.Reverse() : dictionaries; foreach (var index in query) { Dictionary<string, string> d2 = index.Value; result = result.Concat(d2.Where(x => !result.Keys.Contains(x.Key))).ToDictionary(o => o.Key, o => o.Value); } return result; }
/// <summary> /// Merge given dictionaries /// </summary> /// <param name="dictionaries">dictionaries to merge</param> /// <param name="overrideDueplicateWithLatterDictionaryValue"> /// If true and duplicate key exists, then dupe key's values are overriden by latter dictionary values /// </param> public Dictionary <string, string> MergeDictionaries( Dictionary <int, Dictionary <string, string> > dictionaries, bool overrideDueplicateWithLatterDictionaryValue = true) { Dictionary <string, string> result = new Dictionary <string, string>(dictionaries.Count); var query = overrideDueplicateWithLatterDictionaryValue ? dictionaries.Reverse() : dictionaries; foreach (var index in query) { Dictionary <string, string> d2 = index.Value; result = result.Concat(d2.Where(x => !result.Keys.Contains(x.Key))).ToDictionary(o => o.Key, o => o.Value); } return(result); }
public void RemoveBillBoard(Point bPoint, int billBoardSize) { bool check = false; Dictionary <Point, bool> tempBillBoarPoint = new Dictionary <Point, bool>(t.billBoardPoint); foreach (KeyValuePair <Point, bool> item in tempBillBoarPoint.Reverse()) { if (item.Key == bPoint || (check == true && billBoardSize > 0)) { t.billBoardPoint[item.Key] = false; billBoardSize--; check = true; } } }
public void RenameFolders() { RenameQueue.Reverse().ToList().ForEach(pair => { try { Debug.WriteLine(pair.Key + " >> " + pair.Value); Directory.Move(pair.Key, pair.Value); } catch (Exception ex) { options.Logger.FatalLog(ex.ToString()); } }); }
public string Convert(int arabicNumber) { _arabicNumber = arabicNumber; _romanNumeralBuilder.Clear(); _romanNumberStore .Reverse() .ToList() .ForEach ( i => romanNumeralAppender(i) ); return(_romanNumeralBuilder.ToString()); }
private static void ParseNodeInternal(XElement element, DataSchemaKey key) { foreach (XElement el in element.Elements()) { string name = el.Attribute("name").Value; switch (el.Name.LocalName) { case "value" : string mappedColumn = el.Value; DataSchemaValue v = new DataSchemaValue(name, mappedColumn); ParseNodeInternal(el, v); key.AddChild(v); break; case "container" : DataSchemaKey c = new DataSchemaKey(DataSchemaKeyType.Container, name); ParseNodeInternal(el, c); key.AddChild(c); break; case "iterator" : int max = Int32.Parse(el.Attribute("maxItemCount").Value); DataSchemaIterator i = new DataSchemaIterator(name, max); ParseNodeInternal(el, i); key.AddChild(i); break; case "iteratorValue" : Dictionary<DataSchemaIterator,int> iterators = new Dictionary<DataSchemaIterator,int>(); FindIterators(key, iterators); iterators.Reverse(); List<DataSchemaIteratorValueMappedColumn> columns = new List<DataSchemaIteratorValueMappedColumn>(); string tmpl = el.Value; GenCoulumns(tmpl, iterators, columns, 0); DataSchemaIteratorValue iv = new DataSchemaIteratorValue(name, columns); ParseNodeInternal(el, iv); key.AddChild(iv); break; } } }
async private void CompareButton_OnClick(object sender, RoutedEventArgs e) { if (File.Exists(OldFilePathTextBox.Text) == false || File.Exists(NewFilePathTextBox.Text) == false) { return; } OldFile = new FileInfo(OldFilePathTextBox.Text).FullName; NewFile = new FileInfo(NewFilePathTextBox.Text).FullName; CompareButton.Content = new Run("Comparing..."); Task<Dictionary<string, string>> fastDiffTask = Task.Run(() => { Dictionary<string, string> diffTableDictionary = new Dictionary<string, string>(); //diffTableDictionary.Add("-----", string.Empty); using (SQLiteConnection connection = new SQLiteConnection(DAL.ConnectionString)) { connection.Open(); //连接两个库 string attachSql = "ATTACH '" + OldFile + "' AS old;ATTACH '" + NewFile + "' AS new;"; SQLiteCommand attachCommand = new SQLiteCommand(attachSql, connection); attachCommand.ExecuteNonQuery(); //循环每个表 foreach (MASTERDB type in Enum.GetValues(typeof(MASTERDB))) { if (type == MASTERDB.LEVEL_DATA_MASTER) { //地图表没啥比对价值 continue; } //检查表存在性 SQLiteCommand existCommand = new SQLiteCommand(string.Format(ExistSql, type.ToString()), connection); int existCount = Convert.ToInt32(existCommand.ExecuteScalar()); if (existCount == 1) { //只有一边存在 diffTableDictionary.Add("[New]" + type.ToString(), type.ToString()); } else if (existCount == 2) { //检查数据是否存在差异 int oldHasNew = 0, newHasNew = 0; string hasDiffMark = string.Empty; try { existCommand.CommandText = string.Format(ExistInNewSql, type.ToString()); if (existCommand.ExecuteScalar() != null) { newHasNew = 1; } existCommand.CommandText = string.Format(ExistInOldSql, type.ToString()); if (existCommand.ExecuteScalar() != null) { oldHasNew = 1; } switch ((oldHasNew << 1) | newHasNew) { case 3: { hasDiffMark = "←→"; break; } case 2: { hasDiffMark = "← "; break; } case 1: { hasDiffMark = " →"; break; } default: break; } } catch (Exception) { //表结构发生变化 //todo 不出异常的解决方案 hasDiffMark = "Cng"; } if (string.IsNullOrEmpty(hasDiffMark) == false) { diffTableDictionary.Add("[" + hasDiffMark + "]" + type.ToString(), type.ToString()); } } } } //trick to add to dict first var reverseDict = diffTableDictionary.Reverse().ToDictionary(pair => pair.Key, pair => pair.Value); reverseDict.Add("Results:" + diffTableDictionary.Count, ""); return reverseDict.Reverse().ToDictionary(pair => pair.Key, pair => pair.Value); }); TableSelectComboBox.ItemsSource = await fastDiffTask; TableSelectComboBox.SelectedIndex = 0; CompareButton.Content = new Run("Compare"); }
private static string GetSubjectNameItemString(Dictionary<string, string> dic) { var rev = dic.Reverse(); var sb = new StringBuilder(); foreach (var item in rev) { sb.Append(item.Key + "=" + item.Value + ","); } sb.Length--; return sb.ToString(); }
public Playlist [] GetPlaylists (uint index, uint max_count, string order, bool reverse_order) { var playlist_sources = ServiceManager.SourceManager.FindSources<AbstractPlaylistSource> (); switch (order) { case "Alphabetical": playlist_sources = playlist_sources.OrderBy (p => p.Name); break; case "UserDefined": playlist_sources = playlist_sources.OrderBy (p => p.Order); break; } if (reverse_order) { playlist_sources = playlist_sources.Reverse (); } var playlists = new List<Playlist> (); foreach (var pl in playlist_sources.Skip ((int)index).Take ((int)max_count)) { playlists.Add (BuildPlaylistFromSource (pl)); } return playlists.ToArray (); }
public void TestDetermineHierarchy05() { DetermineHierarchyTest test = new DetermineHierarchyTest(); // hierarchy mappings: // A > B > C // > D > E > F // G > H TemplateInSet templateA = test.CreateTemplateInSet("A"); TemplateInSet templateB = test.CreateTemplateInSet("B"); TemplateInSet templateC = test.CreateTemplateInSet("C"); TemplateInSet templateD = test.CreateTemplateInSet("D"); TemplateInSet templateE = test.CreateTemplateInSet("E"); TemplateInSet templateF = test.CreateTemplateInSet("F"); TemplateInSet templateG = test.CreateTemplateInSet("G"); TemplateInSet templateH = test.CreateTemplateInSet("H"); Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>> mappings = new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>() { {templateA, null}, {templateB, new TemplateInSet[] { templateA }}, {templateC, new TemplateInSet[] { templateB }}, {templateD, new TemplateInSet[] { templateA }}, {templateE, new TemplateInSet[] { templateD }}, {templateF, new TemplateInSet[] { templateE }}, {templateG, null}, {templateH, new TemplateInSet[] { templateG }} }; mappings.Reverse(); test.Run(mappings); Assert.IsNull(templateA.BaseTemplateInSet); Assert.IsNull(templateG.BaseTemplateInSet); Assert.AreSame(templateA, templateB.BaseTemplateInSet); Assert.AreSame(templateB, templateC.BaseTemplateInSet); Assert.AreSame(templateA, templateD.BaseTemplateInSet); Assert.AreSame(templateD, templateE.BaseTemplateInSet); Assert.AreSame(templateE, templateF.BaseTemplateInSet); Assert.AreSame(templateG, templateH.BaseTemplateInSet); }
private string getParentName(Dictionary<string, int> jointOrderCollection, int index) { foreach (var item in jointOrderCollection.Reverse()) { if (item.Value.Equals(index)) { return item.Key; } } return String.Empty; }
private static Dictionary<Game, int> MergeMatches(Dictionary<Game, int> matchList1, Dictionary<Game, int> matchList2) { var merged = new Dictionary<Game, int>(); int team1Index = 0; foreach (var match in matchList1) { int team2Index = 0; foreach (var otherMatch in matchList2.Reverse()) { if(team2Index>team1Index) { break; } if(team1Index==team2Index) { merged.Add(new Game(match.Key.HomeTeam, otherMatch.Key.GuestTeam), match.Value); } team2Index++; } team1Index++; } return merged; }
private Dictionary<string, double> BenjaminiHochberg(Dictionary<string, double> pvalueDict) { Dictionary<string, double> tempretDict = new Dictionary<string, double>(); Dictionary<string, double> retDict = new Dictionary<string, double>(); Dictionary<string, double> sortedDict = pvalueDict.OrderBy(x => x.Value).ToDictionary(x => x.Key, x => x.Value); int count = 1; foreach (KeyValuePair<string, double> kvp in sortedDict) { double qValue = kvp.Value * sortedDict.Values.Count / (count); tempretDict.Add(kvp.Key, qValue); count++; } Dictionary<string, double> reverseSortedDict = tempretDict.Reverse().ToDictionary(x => x.Key, x => x.Value); int i = 0; foreach (KeyValuePair<string, double> kvp in reverseSortedDict) { if (i != 0) { if (retDict.ElementAt(i - 1).Value < kvp.Value) { retDict.Add(kvp.Key, retDict.ElementAt(i - 1).Value); } else { retDict.Add(kvp.Key, kvp.Value); } } else { retDict.Add(kvp.Key, kvp.Value); } i++; } return retDict; }
public void TestDetermineHierarchyForContributingTemplates01() { DetermineHierarchyTest test = new DetermineHierarchyTest(); // hierarchy mappings: // A > B > C // > D > E > F // G > // H > J // I > ContributingTemplateInSet templateA = test.CreateContributingTemplateInSet("A"); ContributingTemplateInSet templateB = test.CreateContributingTemplateInSet("B"); ContributingTemplateInSet templateC = test.CreateContributingTemplateInSet("C"); ContributingTemplateInSet templateD = test.CreateContributingTemplateInSet("D"); ContributingTemplateInSet templateE = test.CreateContributingTemplateInSet("E"); ContributingTemplateInSet templateF = test.CreateContributingTemplateInSet("F"); ContributingTemplateInSet templateG = test.CreateContributingTemplateInSet("G"); ContributingTemplateInSet templateH = test.CreateContributingTemplateInSet("H"); ContributingTemplateInSet templateI = test.CreateContributingTemplateInSet("I"); ContributingTemplateInSet templateJ = test.CreateContributingTemplateInSet("J"); Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>> mappings = new Dictionary<TemplateInSetBase, IEnumerable<TemplateInSetBase>>() { {templateA, null}, {templateB, new ContributingTemplateInSet[] { templateA }}, {templateC, new ContributingTemplateInSet[] { templateB }}, {templateD, new ContributingTemplateInSet[] { templateA }}, {templateE, new ContributingTemplateInSet[] { templateD }}, {templateF, new ContributingTemplateInSet[] { templateE }}, {templateG, null}, {templateH, new ContributingTemplateInSet[] { templateG, templateI }}, {templateI, null}, {templateJ, new ContributingTemplateInSet[] { templateH }} }; mappings.Reverse(); test.Run(mappings); Assert.IsNull(templateA.BaseContributingTemplatesInSet); Assert.IsNull(templateG.BaseContributingTemplatesInSet); Assert.IsNull(templateI.BaseContributingTemplatesInSet); Assert.AreSame(templateA, templateB.BaseContributingTemplatesInSet.First()); Assert.AreSame(templateB, templateC.BaseContributingTemplatesInSet.First()); Assert.AreSame(templateA, templateD.BaseContributingTemplatesInSet.First()); Assert.AreSame(templateD, templateE.BaseContributingTemplatesInSet.First()); Assert.AreSame(templateE, templateF.BaseContributingTemplatesInSet.First()); Assert.AreSame(templateH, templateJ.BaseContributingTemplatesInSet.First()); Assert.IsTrue(templateH.BaseContributingTemplatesInSet.Contains(templateG)); Assert.IsTrue(templateH.BaseContributingTemplatesInSet.Contains(templateI)); Assert.IsFalse(templateC.BaseContributingTemplatesInSet.Contains(templateA)); Assert.IsFalse(templateF.BaseContributingTemplatesInSet.Contains(templateD)); Assert.IsFalse(templateF.BaseContributingTemplatesInSet.Contains(templateA)); Assert.IsFalse(templateE.BaseContributingTemplatesInSet.Contains(templateA)); Assert.IsFalse(templateJ.BaseContributingTemplatesInSet.Contains(templateG)); Assert.IsFalse(templateJ.BaseContributingTemplatesInSet.Contains(templateI)); }
private static void Build(string file) { var jumpTable = new Dictionary<string, ushort>(); string directory = Path.GetDirectoryName(Path.GetFullPath(file)); string[] lines = File.ReadAllLines(file); bool waitEndIf = false; foreach (var _line in lines) { string line = _line.Trim(); if (line.StartsWith("#") || string.IsNullOrEmpty(line)) continue; if (waitEndIf) { if (line == "endif") waitEndIf = false; else continue; } if (line.StartsWith("asm ")) { string[] parts = line.Split(' '); if (verbose) Console.WriteLine("Assemling " + parts[1]); Spasm(Path.Combine(directory, parts[1]), Path.Combine(directory, parts[2]), null, configuration); } else if (line.StartsWith("if ")) waitEndIf = configuration != line.Substring(3); else if (line.StartsWith("link ")) { string[] parts = line.Split(' '); byte[] data = new byte[int.Parse(parts[3], NumberStyles.HexNumber)]; for (int i = 0; i < data.Length; i++) data[i] = 0xFF; using (Stream stream = File.Open(Path.Combine(directory, parts[1]), FileMode.Open)) stream.Read(data, 0, (int)stream.Length); output.Seek(int.Parse(parts[2], NumberStyles.HexNumber), SeekOrigin.Begin); output.Write(data, 0, data.Length); output.Flush(); } else if (line.StartsWith("echo ")) Console.WriteLine(line.Substring(5)); else if (line.StartsWith("load ")) LoadLabels(Path.Combine(directory, line.Substring(5))); else if (line.StartsWith("jump finish ")) { // C3 34 12 string[] parts = line.Split(' '); int tableAddress = int.Parse(parts[2], NumberStyles.HexNumber); output.Seek(tableAddress - (jumpTable.Count * 3), SeekOrigin.Begin); string include = ""; foreach (var jumpValue in jumpTable.Reverse()) { byte[] value = BitConverter.GetBytes(jumpValue.Value); include = jumpValue.Key + " .equ $" + ((ushort)output.Position).ToString("X4") + Environment.NewLine + include; output.Write(new byte[] { 0xC3, // jp value[0], value[1] }, 0, 3); } include = ";This file was generated by a tool" + Environment.NewLine + include; File.WriteAllText(Path.Combine(directory, parts[3]), include); } else if (line.StartsWith("jump include ")) jumpTable.Add(line.Substring(13), (ushort)labels[line.Substring(13).ToLower()]); else if (line.StartsWith("rm ")) { string[] parts = line.Substring(3).Split(' '); foreach (var part in parts) { if (File.Exists(Path.Combine(directory, part))) File.Delete(Path.Combine(directory, part)); if (Directory.Exists(Path.Combine(directory, part))) Directory.Delete(Path.Combine(directory, part), true); } } else if (line.StartsWith("cp")) { string[] parts = line.Substring(3).Split(' '); File.Copy(Path.Combine(directory, parts[0]), Path.Combine(directory, parts[1])); } else if (line.StartsWith("mkdir ")) Directory.CreateDirectory(Path.Combine(directory, line.Substring(6))); else if (line.StartsWith("fscreate ")) CreateFilesystem(Path.Combine(directory, line.Substring(9))); else if (line.StartsWith("pages ")) { var parts = line.Substring(6).Split(' '); foreach (var part in parts) AddPage(byte.Parse(part, NumberStyles.HexNumber)); } else if (line == "endif") { } else { Console.WriteLine("Unknown build directive: " + line); throw new InvalidOperationException("Unknown build directive"); } } }