public void Reset() { Ignores.Clear(); UpdateRules(); Set(Ignores); }
public void IgnoreByPath(string path) { Ignores.Add(path); UpdateRules(); Set(Ignores); }
/// <inheritdoc/> ITransformationMap <TCollection, TElement> ITransformationMap <TCollection, TElement> .Ignore(params string[] memberSelectors) { if (memberSelectors is null) { throw new ArgumentNullException(nameof(memberSelectors)); } Ignores.AddRange(memberSelectors); return(this); }
/// <inheritdoc/> ITransformationMap <TCollection, TElement> ITransformationMap <TCollection, TElement> .Ignore( string memberSelector1, string memberSelector2, string memberSelector3) { Ignores.Add(memberSelector1); Ignores.Add(memberSelector2); Ignores.Add(memberSelector3); return(this); }
public IgnoresVM(Ignores ignores, bool isReadOnly) { _ignores = ignores; if (_ignores == null) { _ignores = new Ignores(); } IsReadOnly = isReadOnly; }
/// <inheritdoc/> ITransformationMap <TCollection, TElement> ITransformationMap <TCollection, TElement> .Ignore(string memberSelector1) { if (memberSelector1 is null) { throw new ArgumentNullException(nameof(memberSelector1)); } Ignores.Add(memberSelector1); return(this); }
//----------------------------------------------------- //true则忽略不显示 public bool IsIgnoreField(string columnName) { string[] ignores = Ignores.Split(','); if (ignores.Length < 1) { return(false); } string result = ignores.FirstOrDefault(p => p.ToLower().Equals(columnName.ToLower())); return(!string.IsNullOrEmpty(result)); }
private async Task <Ignores> FetchFolderIgnoresAsync(string folderId, CancellationToken cancellationToken) { // Until startup is complete, these can return a 500. // There's no sensible way to determine when startup *is* complete, so we just have to keep trying... // Again, there's the possibility that we've just abort the API... ISyncThingApiClient apiClient; lock (this.apiClient.LockObject) { cancellationToken.ThrowIfCancellationRequested(); apiClient = this.apiClient.UnsynchronizedValue; if (apiClient == null) { throw new InvalidOperationException("ApiClient must not be null"); } } Ignores ignores = null; // We used to time out after an absolute time here. However, there's the possiblity of going to sleep // halfway through polling, which throws things off. Therefore use a number of iterations var numRetries = this.ignoresFetchTimeout.TotalSeconds; // Each iteration is a second for (var retriesCount = 0; retriesCount < numRetries; retriesCount++) { try { ignores = await apiClient.FetchIgnoresAsync(folderId); // No need to log: ApiClient did that for us break; } catch (ApiException e) { logger.Debug("Attempting to fetch folder {0}, but received status {1}", folderId, e.StatusCode); if (e.StatusCode != HttpStatusCode.InternalServerError) { throw; } } await Task.Delay(1000, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); } if (ignores == null) { throw new SyncThingDidNotStartCorrectlyException($"Unable to fetch ignores for folder {folderId}. Syncthing returned 500 after {this.ignoresFetchTimeout}"); } return(ignores); }
public bool Parse(string[] args) { if (args == null || args.Length == 0) { return(false); } Path = args[0]; for (int i = 1; i < args.Length; i++) { Ignores.Add(args[i]); } return(true); }
private void monitor(XmlDocument doc) { XmlNodeList monitor_check = doc.DocumentElement.SelectNodes("/config/monitor/check"); XmlNodeList monitor_ignore = doc.DocumentElement.SelectNodes("/config/monitor/ignore"); for (int i = 0; i < monitor_check.Count; i++) { string txt_check = monitor_check.Item(i).InnerText; Checks.Add(txt_check); console_write("check >> " + txt_check); } for (int i = 0; i < monitor_ignore.Count; i++) { string txt_ignore = monitor_ignore.Item(i).InnerText; Ignores.Add(txt_ignore); console_write("ignore > " + txt_ignore); } }
protected virtual void ProcessProperty(SerializedProperty property) { if (Ignores.Contains(property)) { return; } if (Overrides.Contains(property)) { Overrides.Draw(property); } else if (Disabled.Contains(property)) { DrawDisabled(property); } else { DrawDefault(property); } }
public void ImportOld(string path) { if (File.Exists(path)) { OldConfig oldConfig = new OldConfig(path); ParityDir = oldConfig.ParityDir; TempDir = oldConfig.TempDir; MaxTempRAM = oldConfig.MaxTempRAM; IgnoreHidden = oldConfig.IgnoreHidden; for (int i = 0; i < oldConfig.BackupDirs.Length; i++) { Drives.Add(new Drive(oldConfig.BackupDirs[i], String.Format("files{0}.dat", i))); } foreach (string i in oldConfig.Ignores) { Ignores.Add(i); } UpdateIgnoresRegex(); Save(); } }
protected virtual Stack <Rigidbody> ExtractHits(Collider[] colliders) { Stack <Rigidbody> rigidbodies = new Stack <Rigidbody>(); Rigidbody rigidbody; for (int i = 0; i < colliders.Length; i++) { if (Ignores.Contains(colliders[i])) { continue; } rigidbody = colliders[i].attachedRigidbody; if (rigidbody && !rigidbodies.Contains(rigidbody) && !Ignores.Contains(rigidbody)) { rigidbodies.Push(colliders[i].attachedRigidbody); } } return(rigidbodies); }
public async Task Process(SetAccountRelation rel) { if (!IsLoggedIn) { return; } if (string.IsNullOrEmpty(rel.TargetName) && string.IsNullOrEmpty(rel.SteamID)) { return; } using (var db = new ZkDataContext()) { ulong steamId = 0; var srcAccount = db.Accounts.Find(User.AccountID); ulong.TryParse(rel.SteamID, out steamId); var trgtAccount = Account.AccountByName(db, rel.TargetName) ?? db.Accounts.FirstOrDefault(x => x.SteamID == steamId); if (trgtAccount == null) { if (!string.IsNullOrEmpty(rel.TargetName)) { await Respond("No such account found"); // only warn if name is set and not just steam id } return; } var friendAdded = false; var entry = srcAccount.RelalationsByOwner.FirstOrDefault(x => x.TargetAccountID == trgtAccount.AccountID); if ((rel.Relation == Relation.None) && (entry != null)) { db.AccountRelations.Remove(entry); } if (rel.Relation != Relation.None) { if (entry == null) { if (rel.Relation == Relation.Friend) { friendAdded = true; } entry = new AccountRelation() { Owner = srcAccount, Target = trgtAccount, Relation = rel.Relation }; srcAccount.RelalationsByOwner.Add(entry); } else { entry.Relation = rel.Relation; } } db.SaveChanges(); ConnectedUser targetConnectedUser; if (server.ConnectedUsers.TryGetValue(trgtAccount.Name, out targetConnectedUser)) { targetConnectedUser.LoadFriendsIgnores(); // update partner's mutual lists if (friendAdded) // friend added, sync new friend to me (user, battle and channels) { await server.TwoWaySyncUsers(Name, new List <string>() { targetConnectedUser.Name }); foreach (var chan in server.Channels.Values.Where( x => (x != null) && x.Users.ContainsKey(Name) && x.Users.ContainsKey(targetConnectedUser.Name))) { await SendCommand(new ChannelUserAdded() { ChannelName = chan.Name, UserName = targetConnectedUser.Name }); } } } LoadFriendsIgnores(); await SendCommand(new FriendList() { Friends = FriendEntries.ToList() }); await SendCommand(new IgnoreList() { Ignores = Ignores.ToList() }); } }
public Status(string path) { RootPath = path; ignores = new Ignores(path, ".hgignore"); }
/// <inheritdoc/> ITransformationMap <TCollection, TElement> ITransformationMap <TCollection, TElement> .Ignore(params string[] memberSelectors) { Ignores.AddRange(memberSelectors); return(this); }
public CombinedOptions OverrideWith(IEnumerable <Attribute> attributes) { if (attributes == null) { return(this); } if (DisableOverrides) { Ignores.AddRange(attributes .Where(attr => attr is YamlIgnoreAttribute) .Select(attr => (YamlIgnoreAttribute)attr) .Where(attr => (attr.IfEquals == null) && (attr.IfEquals == null))); return(this); } foreach (var attr in attributes.Reverse()) { var type = attr.GetType(); if (type == typeof(YamlNameAttribute)) { Name = ((YamlNameAttribute)attr).Name; } else if (type == typeof(YamlIgnoreAttribute)) { Ignores.Add((YamlIgnoreAttribute)attr); } else if (type == typeof(YamlFormatAttribute)) { var fmt = (YamlFormatAttribute)attr; if (fmt.Format != null) { Format = fmt.Format; } if (fmt.MaybeBlankLinesBefore.HasValue) { BlankLinesBefore = fmt.MaybeBlankLinesBefore.Value; } if (fmt.MaybeBlankLinesAfter.HasValue) { BlankLinesAfter = fmt.MaybeBlankLinesAfter.Value; } if (fmt.MaybeAlwaysNested.HasValue) { AlwaysNested = fmt.MaybeAlwaysNested.Value; } if (fmt.MaybeQuoted.HasValue) { Quoted = fmt.MaybeQuoted.Value; } if (fmt.MaybeDoubleQuoted.HasValue) { DoubleQuoted = fmt.MaybeDoubleQuoted.Value; } if (fmt.MaybeBlock.HasValue) { Block = fmt.MaybeBlock.Value; } if (fmt.MaybeIndentStep.HasValue) { IndentStep = fmt.MaybeIndentStep.Value; } } else if (type == typeof(YamlCommentAttribute)) { Comments.Add((YamlCommentAttribute)attr); } } return(this); }
public void Load() { if (!File.Exists(filename)) { return; } using (XmlReader reader = XmlReader.Create(new StreamReader(filename))) { for (; ;) { reader.Read(); if (reader.EOF) { break; } if (reader.NodeType == XmlNodeType.Whitespace) { continue; } if (reader.Name == "Options" && reader.IsStartElement()) { for (; ;) { if (!reader.Read() || reader.EOF) { break; } if (reader.NodeType == XmlNodeType.Whitespace) { continue; } else if (reader.NodeType == XmlNodeType.EndElement) { break; } if (reader.Name == "TempDir") { reader.Read(); TempDir = reader.Value; reader.Read(); } else if (reader.Name == "MaxTempRAM") { reader.Read(); MaxTempRAM = Convert.ToUInt32(reader.Value); reader.Read(); } else if (reader.Name == "IgnoreHidden") { reader.Read(); IgnoreHidden = (reader.Value == "true") ? true : false; reader.Read(); } else if (reader.Name == "MonitorDrives") { reader.Read(); MonitorDrives = (reader.Value == "true") ? true : false; reader.Read(); } else if (reader.Name == "UpdateDelay") { reader.Read(); UpdateDelay = Convert.ToUInt32(reader.Value); reader.Read(); } else if (reader.Name == "UpdateMode") { reader.Read(); int mode = Convert.ToInt32(reader.Value); reader.Read(); if (mode == 1) { UpdateMode = UpdateMode.NoAction; } else if (mode == 2) { UpdateMode = UpdateMode.ScanOnly; } else if (mode == 3) { UpdateMode = UpdateMode.ScanAndUpdate; } } else if (reader.Name == "Ignores") { for (; ;) { if (!reader.Read() || reader.EOF) { break; } if (reader.NodeType == XmlNodeType.Whitespace) { continue; } else if (reader.NodeType == XmlNodeType.EndElement) { break; } if (reader.Name == "Ignore" && reader.IsStartElement()) { reader.Read(); Ignores.Add(reader.Value); reader.Read(); // skip end element } } } } } else if (reader.Name == "Parity") { ParityDir = reader.GetAttribute("Path"); } else if (reader.Name == "Layout" && reader.IsStartElement()) { for (; ;) { if (!reader.Read() || reader.EOF) { break; } if (reader.NodeType == XmlNodeType.Whitespace) { continue; } else if (reader.NodeType == XmlNodeType.EndElement) { break; } else if (reader.Name == "MainWindowX") { reader.Read(); MainWindowX = Convert.ToInt32(reader.Value); reader.Read(); } else if (reader.Name == "MainWindowY") { reader.Read(); MainWindowY = Convert.ToInt32(reader.Value); reader.Read(); } else if (reader.Name == "MainWindowWidth") { reader.Read(); MainWindowWidth = Convert.ToInt32(reader.Value); reader.Read(); } else if (reader.Name == "MainWindowHeight") { reader.Read(); MainWindowHeight = Convert.ToInt32(reader.Value); reader.Read(); } } } else if (reader.Name == "Drives" && reader.IsStartElement()) { for (; ;) { if (!reader.Read() || reader.EOF) { break; } if (reader.NodeType == XmlNodeType.Whitespace) { continue; } else if (reader.NodeType == XmlNodeType.EndElement) { break; } if (reader.Name == "Drive") { Drives.Add(new Drive(reader.GetAttribute("Path"), reader.GetAttribute("Meta"))); } } } } } UpdateIgnoresRegex(); }
public void IgnoreByPath(string path) { Ignores.Add(path); Set(Ignores); }
public void Reset() { Ignores.Clear(); Set(Ignores); }
public bool IsIgnored(string path) { return(Ignores.Contains(path, StringComparer.OrdinalIgnoreCase)); }