public MainForm(IApplication app) { InitializeComponent(); application = app; protocol = application.GetProtocol(ProtocolVersion.x100); inserter = new Inserter(insert); status = new StatusHandle(); incer = new Incer(IncP); initer = new Initer(InitProgressBar); }
public static async Task <Document> RefactorAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, bool prefixIdentifierWithUnderscore = true, CancellationToken cancellationToken = default(CancellationToken)) { string fieldName = Identifier.ToCamelCase( propertyDeclaration.Identifier.ValueText, prefixWithUnderscore: prefixIdentifierWithUnderscore); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); fieldName = Identifier.EnsureUniqueMemberName(fieldName, propertyDeclaration.SpanStart, semanticModel, cancellationToken); FieldDeclarationSyntax fieldDeclaration = CreateBackingField(propertyDeclaration, fieldName) .WithFormatterAnnotation(); PropertyDeclarationSyntax newPropertyDeclaration = ExpandPropertyAndAddBackingField(propertyDeclaration, fieldName); newPropertyDeclaration = ExpandPropertyRefactoring.ReplaceAbstractWithVirtual(newPropertyDeclaration); newPropertyDeclaration = newPropertyDeclaration .WithTriviaFrom(propertyDeclaration) .WithFormatterAnnotation(); var parentMember = (MemberDeclarationSyntax)propertyDeclaration.Parent; SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers(); int propertyIndex = members.IndexOf(propertyDeclaration); if (IsReadOnlyAutoProperty(propertyDeclaration)) { IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken); ImmutableArray <SyntaxNode> oldNodes = await document.FindSymbolNodesAsync(propertySymbol, cancellationToken).ConfigureAwait(false); IdentifierNameSyntax newNode = IdentifierName(fieldName); MemberDeclarationSyntax newParentMember = parentMember.ReplaceNodes(oldNodes, (f, g) => newNode.WithTriviaFrom(f)); members = newParentMember.GetMembers(); } SyntaxList <MemberDeclarationSyntax> newMembers = members.ReplaceAt(propertyIndex, newPropertyDeclaration); newMembers = Inserter.InsertMember(newMembers, fieldDeclaration); return(await document.ReplaceNodeAsync(parentMember, parentMember.SetMembers(newMembers), cancellationToken).ConfigureAwait(false)); }
public void Execute() { //Inserter.StartModelUpdate(); for (int i = 0; i < Operations.Count; i++) { Point tileCoords = Operations[i].IndexCoords; int tileId = Operations[i].TileIdAfter; Inserter.SetValue(tileCoords, tileId); } //Inserter.Model.Update(); //Inserter.FinishModelUpdate(); }
private static void Insert(SQLiteConnection conn, int count, Dictionary <int, string> dict) { Random r = new Random(); for (int i = 0; i < count; ++i) { int a = r.Next(); string b = Guid.NewGuid().ToString(); Inserter inserter = new Inserter("Temp", conn); inserter.Set("A", a); inserter.Set("B", b, false); inserter.Execute(); dict[a] = b; } }
/// <inheritdoc /> public async Task FillAsync() { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation($"Converting DBC file: {typeof(TDBCEntryType).Name} to database table."); } ParsedDBCFile <TDBCEntryType> dbc = await DbcReader.Parse(); if (dbc == null) { throw new InvalidOperationException($"Failed to parse DBC for Type: {typeof(TDBCEntryType).Name}"); } await Inserter.InsertEntriesAsync(dbc.RecordDatabase.Values.ToArray()); }
/// <summary> /// Used to make sure the *Type tables are updated /// </summary> /// <param name="conn">The connection to the database</param> /// <param name="values">The key/value pair that needs to exist in the DB. If there's a missing entry, or the description /// changed, we'll insert or update as appropriate</param> /// <param name="table">The table we're going to be updating</param> /// <param name="type_column">The name of the type column.</param> public static void PopulateTypesTable(this SQLiteConnection conn, Dictionary <int, string> values, string table, string type_column) { ILog log = LogManager.GetLogger(typeof(Extensions)); Dictionary <int, string> db_values = new Dictionary <int, string>(); string select_query = string.Format("SELECT {0}, Description FROM {1};", type_column, table); using (SQLiteCommand command = new SQLiteCommand(select_query, conn)) using (SQLiteDataReader reader = command.ExecuteReader()) { while (reader.Read()) { db_values[reader.GetInt32(0)] = reader.GetString(1); } } List <int> db_types = new List <int>(db_values.Keys); List <int> types = new List <int>(values.Keys); db_types.ForEach(t => types.Remove(t)); // Whatever's left needs to be added foreach (int type in types) { log.Info($"Inserting {type}=>{values[type]} into {table}"); Inserter inserter = new Inserter(table, conn); inserter.Set(type_column, type); inserter.Set("Description", values[type], false); inserter.Execute(); db_values[type] = values[type]; } // Now compare the existing descriptions with the descriptions in values foreach (int type in values.Keys) { if (values[type] != db_values[type]) { log.Info($"Changing {type}=>{db_values[type]} to {values[type]} in {table}"); Updater updater = new Updater(table, $"{type_column} = {type}", conn); updater.Set("Description", values[type], false); updater.Execute(); } } }
public void ProperlyHandleLongs() { using (FileDeleter fd = new FileDeleter(Extensions.GetTempDBFile())) { Database db = new Database(new Context(fd.Fi)); using (SQLiteConnection conn = db.Connection) { conn.Open(); conn.ExecuteNonQuery("CREATE TABLE Temp(A INTEGER NOT NULL PRIMARY KEY, B INTEGER NOT NULL)"); Assert.True(conn.DoesTableExist("Temp")); Dictionary <int, long> dict = new Dictionary <int, long>(); Random r = new Random(); int count = 100; for (int i = 0; i < count; ++i) { int a = r.Next(); long b = r.NextLong(); Inserter ins = new Inserter("Temp", conn); ins.Set("A", a); ins.Set("B", b); ins.Execute(); dict[a] = b; } foreach (int a in dict.Keys) { string sql = $"SELECT B FROM Temp WHERE A = {a}"; using (SQLiteCommand command = new SQLiteCommand(sql, conn)) using (SQLiteDataReader reader = command.ExecuteReader()) { bool read = reader.Read(); Assert.True(read); if (read) { long b = reader.GetInt64(0); Assert.Equal(dict[a], b); } } } } } }
public void ProperlyHandleDates() { using (FileDeleter fd = new FileDeleter(Extensions.GetTempDBFile())) { Database db = new Database(new Context(fd.Fi)); using (SQLiteConnection conn = db.Connection) { conn.Open(); conn.ExecuteNonQuery("CREATE TABLE Temp(A INTEGER NOT NULL PRIMARY KEY, B TEXT NOT NULL)"); Assert.True(conn.DoesTableExist("Temp")); Dictionary <int, DateTimeOffset> dict = new Dictionary <int, DateTimeOffset>(); Random r = new Random(); int count = 100; for (int i = 0; i < count; ++i) { int a = r.Next(); DateTimeOffset b = new DateTimeOffset(2018, r.Next(1, 12), r.Next(1, 28), r.Next(0, 23), r.Next(0, 59), r.Next(0, 59), r.Next(0, 999), TimeSpan.FromHours(r.Next(-12, 12))); Inserter ins = new Inserter("Temp", conn); ins.Set("A", a); ins.Set("B", b); ins.Execute(); dict[a] = b; } foreach (int a in dict.Keys) { string sql = $"SELECT B FROM Temp WHERE A = {a}"; using (SQLiteCommand command = new SQLiteCommand(sql, conn)) using (SQLiteDataReader reader = command.ExecuteReader()) { bool read = reader.Read(); Assert.True(read); if (read) { DateTimeOffset b = DateTimeOffset.Parse(reader.GetString(0)); Assert.Equal(dict[a], b); } } } } } }
public static EventFieldDeclarationSyntax AddStaticModifier(EventFieldDeclarationSyntax eventFieldDeclaration) { if (eventFieldDeclaration == null) { throw new ArgumentNullException(nameof(eventFieldDeclaration)); } SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { return(Inserter.InsertModifier(eventFieldDeclaration, SyntaxKind.StaticKeyword)); } else { return(eventFieldDeclaration); } }
private static void VerifyMeasureAndLocalize( string inDirPath, string expDirPath, DirectoryInfo outDir, string outDirPath) { var profile = LanguageSupports.GetCoverageModeByClassName("C"); Inserter.InsertMeasurementCode(outDir, new Collection <FileInfo>(), null, outDir, profile, RecordingMode.TextFile); // .cと.hファイルが存在するか Assert.That( File.Exists(Path.Combine(outDirPath, "covman.c")), Is.True); Assert.That( File.Exists(Path.Combine(outDirPath, "covman.h")), Is.True); var covinfo = Path.Combine(outDirPath, OccfNames.CoverageInfo); var testinfo = Path.Combine(outDirPath, OccfNames.TestInfo); var targets = Directory.EnumerateFiles( expDirPath, "*.c", SearchOption.AllDirectories) .Concat( Directory.EnumerateFiles( expDirPath, OccfNames.BackupSuffix, SearchOption.AllDirectories)) .Concat(new[] { covinfo, testinfo }); foreach (var target in targets) { AssertEqualFiles(target, expDirPath, inDirPath); } Compile(outDirPath); RunTest(outDirPath); var ret = BugLocalizer.Run( new[] { outDirPath, Path.Combine(outDirPath, "testresult.txt") }); Assert.That(ret, Is.True); }
public static Task <Document> RefactorAsync( Document document, EventFieldDeclarationSyntax eventFieldDeclaration, IEventSymbol eventSymbol, ITypeSymbol eventArgsSymbol, bool supportsCSharp6, CancellationToken cancellationToken = default(CancellationToken)) { var containingMember = (MemberDeclarationSyntax)eventFieldDeclaration.Parent; SyntaxList <MemberDeclarationSyntax> members = containingMember.GetMembers(); MethodDeclarationSyntax method = CreateOnEventMethod(eventSymbol, eventArgsSymbol, supportsCSharp6) .WithFormatterAnnotation(); SyntaxList <MemberDeclarationSyntax> newMembers = Inserter.InsertMember(members, method); return(document.ReplaceNodeAsync(containingMember, containingMember.SetMembers(newMembers), cancellationToken)); }
private static async Task <Document> RefactorAsync( Document document, MemberDeclarationSyntax declaration, List <MemberDeclarationSyntax> assignableMembers, CancellationToken cancellationToken = default(CancellationToken)) { MemberDeclarationSyntax parentMember = GetContainingMember(declaration); SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers(); SyntaxList <MemberDeclarationSyntax> newMembers = Inserter.InsertMember( members, CreateConstructor(GetConstructorIdentifierText(parentMember), assignableMembers)); MemberDeclarationSyntax newNode = parentMember.SetMembers(newMembers) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(parentMember, newNode, cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Create a new Hyper file with a single table and write some data into it. /// </summary> /// <param name="exampleDataDir">Path to the directory with example data.</param> public override void Execute(string exampleDataDir) { Console.WriteLine("EXAMPLE - Insert data into a single tables within a new Hyper file."); // Start the Hyper process with telemetry enabled. using (HyperProcess hyper = new HyperProcess(Telemetry.SendUsageDataToTableau)) { // Connect to hyper and create new Hyper file "superstore.hyper". // Replaces file if it already exists when CreateMode.CreateAndReplace is set. using (Connection connection = new Connection(hyper.Endpoint, "superstore.hyper", CreateMode.CreateAndReplace)) { // The table is called "Extract" and will be created in the "Extract" schema. // This has historically been the default table name and schema for extracts created by Tableau. TableName extractTable = new TableName("Extract", "Extract"); TableDefinition extractTableDefinition = new TableDefinition(extractTable) .AddColumn("Customer ID", SqlType.Text(), Nullability.NotNullable) .AddColumn("Customer Name", SqlType.Text(), Nullability.NotNullable) .AddColumn("Loyalty Reward Points", SqlType.BigInt(), Nullability.NotNullable) .AddColumn("Segment", SqlType.Text(), Nullability.NotNullable); // Create the schema and the table connection.Catalog.CreateSchema("Extract"); connection.Catalog.CreateTable(extractTableDefinition); // Insert data into the "Extract"."Extract" table using (Inserter inserter = new Inserter(connection, extractTable)) { inserter.AddRow("DK-13375", "Dennis Kane", 518, "Consumer"); inserter.AddRow("EB-13705", "Ed Braxton", 815, "Corporate"); inserter.Execute(); } // ExecuteScalarQuery is for executing a query that returns exactly one row with one column long count = connection.ExecuteScalarQuery <long>($"SELECT COUNT(*) FROM {extractTable}"); Console.WriteLine($"Table {extractTable} has a count of {count} rows"); } Console.WriteLine("The connection to the Hyper file has been closed."); } Console.WriteLine("The Hyper process has been shut down."); }
private static Task <Document> RefactorAsync( Document document, StructDeclarationSyntax structDeclaration, INamedTypeSymbol typeSymbol, INamedTypeSymbol equatableSymbol, SemanticModel semanticModel, CancellationToken cancellationToken) { int position = structDeclaration.SpanStart; SimpleBaseTypeSyntax baseType = SimpleBaseType(equatableSymbol.ToMinimalTypeSyntax(semanticModel, position)); StructDeclarationSyntax newNode = AddBaseType(structDeclaration, baseType); TypeSyntax classType = typeSymbol.ToMinimalTypeSyntax(semanticModel, position); newNode = Inserter.InsertMember(newNode, CreateEqualsMethod(classType, semanticModel, position)); return(document.ReplaceNodeAsync(structDeclaration, newNode, cancellationToken)); }
public void NotBeNullable() { using (FileDeleter fd = new FileDeleter(Extensions.GetTempDBFile())) { Database db = new Database(new Context(fd.Fi)); using (SQLiteConnection conn = db.Connection) { conn.Open(); conn.ExecuteNonQuery("CREATE TABLE Temp(A INTEGER NOT NULL PRIMARY KEY, B TEXT NOT NULL)"); Assert.True(conn.DoesTableExist("Temp")); Inserter i = new Inserter("Temp", conn); i.Set("A", 1); i.SetNull("B"); Assert.Throws <SQLiteException>(() => i.Execute()); } } }
public static void SetValue(string path, string value, bool normalize, DateTimeOffset timestamp, SQLiteConnection conn) { if (string.IsNullOrEmpty(path)) { return; } string existing_value = GetValue(path, conn); if (value != existing_value) { Clear(path, conn); Inserter insert = new Inserter("Configuration", conn); insert.Set("Path", path, true); insert.Set("Value", value ?? string.Empty, normalize); insert.Set("DateAdded", timestamp); insert.Set("IsValid", 1); insert.Execute(); } }
#pragma warning disable S3241 // Methods should not return values that are never used private async Task StartFileTransfer() #pragma warning restore S3241 // Methods should not return values that are never used { //build staging table if (!Context.IsAppendingDataToExistingTable) { DestinationTableCreator TableMaker = new DestinationTableCreator(Context); TableMaker.CreateTable(); } //create buffer ConcurrentQueue <List <string> > Queu = new ConcurrentQueue <List <string> >(); //create threads to transfer file SourceFileReader Reader = new SourceFileReader(Context, Queu); Inserter Writer = new Inserter(Context, Queu); Writer.done = false; Reader.ReadFinished += Writer.StopWriting; Writer.FinishedWriting += OnWriterFinishing; // start everything up and monitor for finish Reader.StartReading(); for (int i = 0; i < NumberOfWriterThreads; i++) { Writer.CreateConcurrentWriter(); } await Task.Run(() => { while (NumberOfWriterThreads > NumberOfFinishedThreads) { Task.Delay(1000).Wait(); } }); btnStartTransfer.Enabled = true; OnLoadStageOneFinished(); }
public static ConstructorDeclarationSyntax AddStaticModifier(ConstructorDeclarationSyntax constructorDeclaration) { if (constructorDeclaration == null) { throw new ArgumentNullException(nameof(constructorDeclaration)); } SyntaxTokenList modifiers = constructorDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.StaticKeyword)) { SyntaxTokenList newModifiers = modifiers; if (modifiers.ContainsAccessModifier()) { newModifiers = modifiers.RemoveAccessModifiers(); if (newModifiers.Any()) { newModifiers = newModifiers.ReplaceAt(0, newModifiers[0].WithLeadingTrivia(modifiers[0].LeadingTrivia)); newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword); } else { newModifiers = Inserter.InsertModifier(newModifiers, CSharpFactory.StaticKeyword().WithLeadingTrivia(modifiers[0].LeadingTrivia)); } } else { newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword); } return(constructorDeclaration.WithModifiers(newModifiers)); } else { return(constructorDeclaration); } }
public static MemberDeclarationSyntax AddNewDocumentationComment( MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (memberDeclaration == null) { throw new ArgumentNullException(nameof(memberDeclaration)); } if (CanGenerateFromBase(memberDeclaration.Kind())) { BaseDocumentationCommentInfo info = GenerateFromBase(memberDeclaration, semanticModel, cancellationToken); if (info.Success) { return(Inserter.InsertDocumentationComment(memberDeclaration, info.Trivia, indent: true)); } } return(AddNewDocumentationComment(memberDeclaration, settings)); }
private static SyntaxTokenList GetNewModifiers(SyntaxTokenList modifiers, Accessibility accessibility) { switch (accessibility) { case Accessibility.Public: { return(Inserter.InsertModifier(modifiers, SyntaxKind.PublicKeyword)); } case Accessibility.Internal: { return(Inserter.InsertModifier(modifiers, SyntaxKind.InternalKeyword)); } case Accessibility.Protected: { return(Inserter.InsertModifier(modifiers, SyntaxKind.ProtectedKeyword)); } case Accessibility.ProtectedOrInternal: { modifiers = Inserter.InsertModifier(modifiers, SyntaxKind.ProtectedKeyword); return(Inserter.InsertModifier(modifiers, SyntaxKind.InternalKeyword)); } case Accessibility.Private: { return(Inserter.InsertModifier(modifiers, SyntaxKind.PrivateKeyword)); } default: { Debug.Assert(false, accessibility.ToString()); return(modifiers); } } }
/// <summary> /// Updates a device's status. If the new status is null, the existing status should be invalidated and no new /// entry added. If the new status is non-null, see it the existing status matches the new status. If the new /// and old status are identical, do nothing. If the new and old status are different somehow (the status itself, /// the is-alarm flag or the message are different), invalidate the old status and insert a new status. /// /// A single device may have different statuses, so we need to restrict our decisions to a set of types, which /// is included in the 3rd parameter. For example, the memory statuses are adequate, low, or critically low. Only /// one of these should be 'active' at a given time. /// </summary> /// <param name="device_id">The ID of the device we're checking</param> /// <param name="type">The new type. Can be null to indicate the status should be cleared</param> /// <param name="statuses">The full set of statuses we should be considering. Will be a subset of all /// the statuses a device can have.</param> /// <param name="message">A message regarding the status</param> /// <param name="conn">The DB connection to use</param> protected static void SetDeviceStatus(long device_id, EStatusType?type, List <EStatusType> statuses, string message, SQLiteConnection conn) { if (type.HasValue) { Debug.Assert(statuses.Contains(type.Value)); } EAlertLevel alert_level = (type.HasValue ? type.Value.GetAlertLevel() : null) ?? EAlertLevel.Normal; string in_clause = statuses.Join(); string clause = $"DeviceID = {device_id} AND StatusType IN ({in_clause}) AND IsValid = 1"; string sql = $"SELECT StatusType, IsAlarm, Message FROM DeviceStatus WHERE {clause};"; bool insert = type.HasValue; bool remove = type.HasValue == false; if (type.HasValue) { // We may be inserting a new type. We need to see if the current value for the device/status is the // same, or has changed. If it's the same we don't need to do anything. If it's changed, we'll want to // mark the old value as invalid, and insert the new value. using (SQLiteCommand command = new SQLiteCommand(sql, conn)) using (SQLiteDataReader reader = command.ExecuteReader()) { if (reader.Read()) { EStatusType existing_type = (EStatusType)reader.GetInt32(0); EAlertLevel existing_alert_level = (EAlertLevel)reader.GetInt32(1); string existing_message = reader.IsDBNull(2) ? string.Empty : reader.GetString(2); // An existing record exists, so insert the new one and update the old one if something's changed. // If nothing changed, we'll leave the old one alone bool something_changed = (type.Value != existing_type) || (alert_level != existing_alert_level) || (string.Compare(message, existing_message) != 0); // If something has changed, we'll want to remove the old version, and insert the new // version. If nothing changed, we don't want to do either. insert = remove = something_changed; } // If it wasn't found, just insert, which is the default } } // In this case there's no status value, so that means were clearing out the old one, if it exists. if (insert || remove) { if (remove) { Updater updater = new Updater("DeviceStatus", clause, conn); updater.Set("IsValid", 0); updater.Execute(); } if (insert) { Inserter inserter = new Inserter("DeviceStatus", conn); inserter.Set("DeviceID", device_id); inserter.Set("StatusType", (int)type); inserter.Set("IsAlarm", (int)alert_level); inserter.Set("Date", DateTimeOffset.Now); inserter.Set("Message", message, false); inserter.Set("IsValid", 1); inserter.Execute(); } } // else, no change }
public void InsertNumber_ThrowArgumentOutOfRangeException() { NUnit.Framework.Assert.Throws <ArgumentOutOfRangeException>(() => Inserter.InsertNumber(8, 12, -4, 2)); NUnit.Framework.Assert.Throws <ArgumentOutOfRangeException>(() => Inserter.InsertNumber(8, 12, -4, -2)); }
public int InsertTest(int a, int b, int i, int j) { return(Inserter.InsertNumber(a, b, i, j)); }
public void InsertNumber_ThrowException_WrongInterval() { Inserter.InsertNumber(7, 12, 9, 6); }
public void InsertNumberBoundaryArgumentsTest() { Assert.AreEqual(Int32.MinValue + 1, Inserter.InsertNumber(Int32.MinValue, Int32.MaxValue, 0, 0)); Assert.AreEqual(-8, Inserter.InsertNumber(-8, -15, 31, 31)); Assert.AreEqual(15, Inserter.InsertNumber(8, 15, 0, 31)); }
public void InsertNumberArgumentExceptionTest() { Assert.ThrowsException <ArgumentException>(() => Inserter.InsertNumber(-15, -15, 32, 33)); Assert.ThrowsException <ArgumentException>(() => Inserter.InsertNumber(-15, -15, -1, -2)); Assert.ThrowsException <ArgumentException>(() => Inserter.InsertNumber(-15, -15, 8, 3)); }
public void InsertNumberMethod_IndexArgsLowerThanZero_ArgumentOutOfRangeException() { Inserter.InsertNumber(8, 15, -1, -1); }
public void InsertNumberMethod_FirstIndBiggerThanSecondInd_ArgumentOutOfRangeException() { Inserter.InsertNumber(8, 15, 10, 5); }
public void InsertNumber_ThrowArgumentException() { NUnit.Framework.Assert.Throws <ArgumentException>(() => Inserter.InsertNumber(8, 12, 4, 2)); }
public void InsertNumberMethod_IndexArgsBiggerThanRange_ArgumentOutOfRangeException() { Inserter.InsertNumber(8, 15, 32, 32); }
public void InsertNumberNegativeNumbersTest() { Assert.AreEqual(-15, Inserter.InsertNumber(-15, -15, 0, 0)); Assert.AreEqual(-7, Inserter.InsertNumber(-8, -15, 0, 0)); Assert.AreEqual(-120, Inserter.InsertNumber(-8, -15, 3, 8)); }