public PatternEntry <TPattern> AddPattern(EntryKind kind, TPattern pattern) { PatternEntry <TPattern> p = new PatternEntry <TPattern>(kind, pattern); AddPattern(p); return(p); }
/// <summary> /// Get the time that the last update was done for this user/machine/entryType /// </summary> /// <param name="aEntryKind">Kind to search for</param> /// <returns>Last time or Time.Min if never</returns> public static DateTime Latest(EntryKind aEntryKind) { SQLHistoryDataSetTableAdapters.HistoryTableAdapter TableAdapter = new SQLHistoryDataSetTableAdapters.HistoryTableAdapter(); DateTime? re = TableAdapter.LatestQuery(Duplicati.Scheduler.Utility.User.UserName, Environment.MachineName, aEntryKind.ToString()); if (re == null) return DateTime.MinValue; return (DateTime)re; }
public LogEntry(EntryKind kind, int level, string text, Exception error = null) { Kind = kind; LogLevel = level; Text = text; Error = error; }
public IssueEntry( DataModelIssue issue, EntryKind kind, IEnumerable <Label> styledLabels = null, string styleName = null) : base(issue, styledLabels, styleName) { Kind = kind; IsPullRequest = issue.IsPullRequest; IssueNumber = issue.Number; }
public Entry SearchEntry(string path, EntryKind stopAt) { if (rootNode == null) { InitRoot(); } else if (System.IO.Directory.GetLastWriteTime(rootPath) > lastWriteTime) { UpdateRoot(); } return(SearchEntry(path, rootNode, rootPath, stopAt)); }
private static string GetKindClassPrefix(EntryKind kind) { if (kind == EntryKind.New) { return("new"); } if ((kind == EntryKind.Moved) || (kind == EntryKind.Closed)) { return("gone"); } throw new InvalidProgramException($"Unexpected issue kind {kind}"); }
/// <summary> /// Update a record /// </summary> /// <param name="aUserName">Domain/User</param> /// <param name="aMachineName">Yeah</param> /// <param name="aEntryType">Kind of entry to update</param> /// <param name="aModificationDate">Entry time</param> /// <param name="aContent">XML to send</param> public static void Update(string aUserName, string aMachineName, EntryKind aEntryType, DateTime aModificationDate, string aContent) { SQLHistoryDataSetTableAdapters.HistoryTableAdapter TableAdapter = new SQLHistoryDataSetTableAdapters.HistoryTableAdapter(); SQLHistoryDataSet.HistoryDataTable Table = TableAdapter.GetDataBy(aUserName, aMachineName, aEntryType.ToString(), aModificationDate); HistoryRow Row = null; if (Table.Count == 0) Row = Table.AddHistoryRow(aUserName, aMachineName, aEntryType.ToString(), aModificationDate, aContent); else Row = ((HistoryRow)Table.Rows[0]); Row.XmlContent = aContent; TableAdapter.Update(Table); //Console.WriteLine(Row.EntryType + ":" + Row.XmlContent); }
public PatternModel(EntryKind entryKind, string currentPattern, string metadata, ObservableCollection <PatternModel> owner, Func <Watcher <GlobPatternWithMetadata> > watcher) { _watcher = watcher; _owner = owner; Kind = entryKind; _currentPattern = currentPattern; _metadata = metadata; RawPattern = new GlobPatternWithMetadata(currentPattern, metadata); RemovePatternCommand = new ActionCommand(() => { _owner.Remove(this); _watcher()?.RemovePattern(Pattern); }); }
internal static int GetEntriesCount(Node node, EntryKind[] kinds) { int count = 0; foreach (var entry in node.Nodes) { foreach (var kind in kinds) { if (entry.Kind == kind) { count++; break; } } } return count; }
public void Log(LogStreamerSession session, EntryKind kind, string msg) { if (session != null) { Log(new LogEntry() { SessionId = session.SessionId, When = DateTime.Now, Kind = kind, Guid = session.PeerGuid, Name = session.PeerDatabaseName, Message = msg }); return; } Log(new LogEntry() { SessionId = 0, When = DateTime.Now, Kind = kind, Guid = Guid.Empty, Name = string.Empty, Message = msg }); }
// PushEntry // ========= // input: loc, name, Type // output: Scope // returns a new scope with everything the same as this, excpet for a new entry // public Scope PushEntry(EntryKind loc, String name, ExprType type) { Scope scope = new Scope(this); switch (loc) { case EntryKind.STACK: scope.esp_pos -= Utils.RoundUp(type.SizeOf, 4); scope.locals.Add(new Utils.StoreEntry(name, type, scope.esp_pos)); break; case EntryKind.GLOBAL: scope.globals.Add(new Utils.StoreEntry(name, type, 0)); break; case EntryKind.TYPEDEF: scope.typedefs.Add(new Utils.StoreEntry(name, type, 0)); break; default: return(null); } return(scope); }
public Entry SearchEntry(string path, EntryKind stopAt) { if (rootNode == null) InitRoot(); else if (System.IO.Directory.GetLastWriteTime(rootPath) > lastWriteTime) { UpdateRoot(); } return SearchEntry(path, rootNode, rootPath, stopAt); }
private static Entry SearchEntry(string path, Node parent, string rootPath, EntryKind? stopAt) { Entry result = null; string[] pathComponents = path.Split(System.IO.Path.DirectorySeparatorChar); Node currentNode = parent; for (int i = 0; i < pathComponents.Length; i++) { result = null; foreach (var entry in currentNode.Nodes) { if (entry.Name == pathComponents[i]) { result = entry; break; } } if (result == null) { break; } if (((result.Kind == EntryKind.File) || (result.Kind == EntryKind.ZipFileEntry)) && (i + 1 < pathComponents.Length)) { throw new System.IO.DirectoryNotFoundException(); } if (result.Node == null) { if (rootPath == null) { throw new System.IO.IOException(); } string elementPath = System.IO.Path.Combine(rootPath, string.Join(new string(System.IO.Path.DirectorySeparatorChar, 1), pathComponents, 0, i + 1)); if (result.Kind == EntryKind.Directory) { result.Node = DirectoryGenerator.Generate(new System.IO.DirectoryInfo(elementPath), false); result.UpdateSize(); } if (result.Kind == EntryKind.ZipFile) { result.Node = ZipFileGenerator.Generate(new System.IO.FileInfo(elementPath)); result.UpdateSize(); } } else if (rootPath != null) { string elementPath = System.IO.Path.Combine(rootPath, string.Join(new string(System.IO.Path.DirectorySeparatorChar, 1), pathComponents, 0, i + 1)); if (result.Kind == EntryKind.Directory) { if (result.LastWriteTime < System.IO.Directory.GetLastWriteTime(elementPath)) { System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(elementPath); DirectoryGenerator.Update(di, result.Node); Entry newEntry = new Entry(di); newEntry.Node = result.Node; newEntry.UpdateSize(); currentNode.Nodes.Remove(result); currentNode.Nodes.Add(newEntry); result = newEntry; } } if (result.Kind == EntryKind.File) { if (result.LastWriteTime < System.IO.File.GetLastWriteTime(elementPath)) { System.IO.FileInfo fi = new System.IO.FileInfo(elementPath); Entry newEntry = new Entry(fi, false); currentNode.Nodes.Remove(result); currentNode.Nodes.Add(newEntry); result = newEntry; } } } if (stopAt.HasValue && (result.Kind == stopAt.Value)) break; currentNode = result.Node; } if ((result != null) && stopAt.HasValue && (result.Kind != stopAt.Value)) return null; return result; }
// PushEntry // ========= // input: loc, name, Type // ouput: Environment // return a new environment which adds a symbol entry // public Env PushEntry(EntryKind loc, String name, ExprType type) { Scope top = this._scopes.Peek(); return new Env(this._scopes.Pop().Push(top.PushEntry(loc, name, type))); }
// PushEntry // ========= // input: loc, name, Type // ouput: Environment // return a new environment which adds a symbol entry // public Env PushEntry(EntryKind loc, String name, ExprType type) { Scope top = this._scopes.Peek(); return(new Env(this._scopes.Pop().Push(top.PushEntry(loc, name, type)))); }
public Entry(EntryKind kind, ExprType type, Int32 offset) { this.Kind = kind; this.Type = type; this.Offset = offset; }
public void Add(EntryKind kind, string tableName, string columnName, string text) { entries.Add(new Entry { EntryKind = kind, TableName = tableName, ColumnName = columnName, Text = text }); }
public void Add(EntryKind kind, string tableName, string text) { Add(kind, tableName, null, text); }
/// <summary> /// The Enum Operator For Has. /// </summary> /// <param name="Entry">The Source</param> /// <param name="Other">The Other Instance</param> /// <returns>The Results</returns> public static bool Has(this EntryKind Entry, EntryKind Other) { return((Entry & Other) == Other); }
public Entry(EntryKind kind, ExprType type, Int32 offset) { this.kind = kind; this.type = type; this.offset = offset; }
public PatternEntry(EntryKind kind, TPattern pattern) { Kind = kind; Pattern = pattern; }
// PushEntry // ========= // input: loc, name, type // ouput: Environment // return a new environment which adds a symbol entry // public Env PushEntry(EntryKind loc, String name, ExprType type) { // note the nested copy constructor. this is because the constructor would reverse the elements. Stack<Scope> scopes = new Stack<Scope>(new Stack<Scope>(env_scopes)); Scope top = scopes.Pop().PushEntry(loc, name, type); scopes.Push(top); return new Env(scopes); }
public void Add(EntryKind kind, string text) { Add(kind, null, null, text); }
// PushEntry // ========= // input: loc, name, type // output: Scope // returns a new scope with everything the same as this, excpet for a new entry // public Scope PushEntry(EntryKind loc, String name, ExprType type) { Scope scope = new Scope(this); switch (loc) { case EntryKind.STACK: scope.esp_pos -= Utils.RoundUp(type.SizeOf, 4); scope.locals.Add(new Utils.StoreEntry(name, type, scope.esp_pos)); break; case EntryKind.GLOBAL: scope.globals.Add(new Utils.StoreEntry(name, type, 0)); break; case EntryKind.TYPEDEF: scope.typedefs.Add(new Utils.StoreEntry(name, type, 0)); break; default: return null; } return scope; }
/// <summary> /// The Enum Operator For Any. /// </summary> /// <param name="Entry">The Source</param> /// <param name="Other">The Other Instance</param> /// <returns>The Results</returns> public static bool Any(this EntryKind Entry, EntryKind Other) { return((Entry & Other) > 0); }