Ejemplo n.º 1
0
        // Creates Sound wrapper
        private Sound CreateItem(
            // Fields of Sound table
            Guid SoundId,
            PinSide PinSide,
            string Notation,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = SoundId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            SoundData dataSound = new SoundData()
            {
                SoundId  = SoundId,
                PinSide  = PinSide,
                Notation = Notation,
                Note     = Note,
            };

            return(this.Create(this.Table.Insert(ref dataSound), rowIdCircuit));
        }
Ejemplo n.º 2
0
        // Creates LogicalCircuit wrapper
        private LogicalCircuit CreateItem(
            // Fields of LogicalCircuit table
            Guid LogicalCircuitId,
            string Name,
            string Notation,
            string Note,
            string Category,
            bool IsDisplay
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = LogicalCircuitId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            LogicalCircuitData dataLogicalCircuit = new LogicalCircuitData()
            {
                LogicalCircuitId = LogicalCircuitId,
                Name             = Name,
                Notation         = Notation,
                Note             = Note,
                Category         = Category,
                IsDisplay        = IsDisplay,
            };

            return(this.Create(this.Table.Insert(ref dataLogicalCircuit), rowIdCircuit));
        }
Ejemplo n.º 3
0
        // Creates all foreign keys of the table
        public static void CreateForeignKeys(StoreSnapshot store)
        {
            TableSnapshot <CircuitSymbolData> table = (TableSnapshot <CircuitSymbolData>)store.Table("CircuitSymbol");

            table.CreateForeignKey("FK_Circuit_CircuitSymbol", store.Table("Circuit"), CircuitSymbolData.CircuitIdField.Field, ForeignKeyAction.Cascade, false);
            table.CreateForeignKey("FK_LogicalCircuit_CircuitSymbol", store.Table("LogicalCircuit"), CircuitSymbolData.LogicalCircuitIdField.Field, ForeignKeyAction.Restrict, false);
        }
Ejemplo n.º 4
0
        // Creates CircuitProbe wrapper
        private CircuitProbe CreateItem(
            // Fields of CircuitProbe table
            Guid CircuitProbeId,
            string Name,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = CircuitProbeId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            CircuitProbeData dataCircuitProbe = new CircuitProbeData()
            {
                CircuitProbeId = CircuitProbeId,
                Name           = Name,
                Note           = Note,
            };

            return(this.Create(this.Table.Insert(ref dataCircuitProbe), rowIdCircuit));
        }
Ejemplo n.º 5
0
        // Creates LedMatrix wrapper
        private LedMatrix CreateItem(
            // Fields of LedMatrix table
            Guid LedMatrixId,
            LedMatrixType MatrixType,
            LedMatrixCellShape CellShape,
            int Rows,
            int Columns,
            int Colors,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = LedMatrixId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            LedMatrixData dataLedMatrix = new LedMatrixData()
            {
                LedMatrixId = LedMatrixId,
                MatrixType  = MatrixType,
                CellShape   = CellShape,
                Rows        = Rows,
                Columns     = Columns,
                Colors      = Colors,
                Note        = Note,
            };

            return(this.Create(this.Table.Insert(ref dataLedMatrix), rowIdCircuit));
        }
Ejemplo n.º 6
0
        // Creates Sensor wrapper
        private Sensor CreateItem(
            // Fields of Sensor table
            Guid SensorId,
            SensorType SensorType,
            int BitWidth,
            PinSide PinSide,
            string Notation,
            string Data,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = SensorId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            SensorData dataSensor = new SensorData()
            {
                SensorId   = SensorId,
                SensorType = SensorType,
                BitWidth   = BitWidth,
                PinSide    = PinSide,
                Notation   = Notation,
                Data       = Data,
                Note       = Note,
            };

            return(this.Create(this.Table.Insert(ref dataSensor), rowIdCircuit));
        }
Ejemplo n.º 7
0
        // Creates Constant wrapper
        private Constant CreateItem(
            // Fields of Constant table
            Guid ConstantId,
            int BitWidth,
            int Value,
            PinSide PinSide,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = ConstantId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            ConstantData dataConstant = new ConstantData()
            {
                ConstantId = ConstantId,
                BitWidth   = BitWidth,
                Value      = Value,
                PinSide    = PinSide,
                Note       = Note,
            };

            return(this.Create(this.Table.Insert(ref dataConstant), rowIdCircuit));
        }
Ejemplo n.º 8
0
        // Creates Splitter wrapper
        private Splitter CreateItem(
            // Fields of Splitter table
            Guid SplitterId,
            int BitWidth,
            int PinCount,
            bool Clockwise
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = SplitterId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            SplitterData dataSplitter = new SplitterData()
            {
                SplitterId = SplitterId,
                BitWidth   = BitWidth,
                PinCount   = PinCount,
                Clockwise  = Clockwise,
            };

            return(this.Create(this.Table.Insert(ref dataSplitter), rowIdCircuit));
        }
Ejemplo n.º 9
0
        // Creates CircuitButton wrapper
        private CircuitButton CreateItem(
            // Fields of CircuitButton table
            Guid CircuitButtonId,
            string Notation,
            bool IsToggle,
            PinSide PinSide,
            bool Inverted,
            int Width,
            int Height,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = CircuitButtonId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            CircuitButtonData dataCircuitButton = new CircuitButtonData()
            {
                CircuitButtonId = CircuitButtonId,
                Notation        = Notation,
                IsToggle        = IsToggle,
                PinSide         = PinSide,
                Inverted        = Inverted,
                Width           = Width,
                Height          = Height,
                Note            = Note,
            };

            return(this.Create(this.Table.Insert(ref dataCircuitButton), rowIdCircuit));
        }
Ejemplo n.º 10
0
        // Creates GraphicsArray wrapper
        private GraphicsArray CreateItem(
            // Fields of GraphicsArray table
            Guid GraphicsArrayId,
            bool WriteOn1,
            MemoryOnStart OnStart,
            int DataBitWidth,
            int BitsPerPixel,
            int Width,
            int Height,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = GraphicsArrayId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            GraphicsArrayData dataGraphicsArray = new GraphicsArrayData()
            {
                GraphicsArrayId = GraphicsArrayId,
                WriteOn1        = WriteOn1,
                OnStart         = OnStart,
                DataBitWidth    = DataBitWidth,
                BitsPerPixel    = BitsPerPixel,
                Width           = Width,
                Height          = Height,
                Note            = Note,
            };

            return(this.Create(this.Table.Insert(ref dataGraphicsArray), rowIdCircuit));
        }
Ejemplo n.º 11
0
        // Creates all foreign keys of the table
        public static void CreateForeignKeys(StoreSnapshot store)
        {
            TableSnapshot <DevicePinData> table = (TableSnapshot <DevicePinData>)store.Table("DevicePin");

            table.CreateForeignKey("PK_DevicePin", store.Table("Circuit"), DevicePinData.PinIdField.Field, ForeignKeyAction.Cascade, false);
            table.CreateForeignKey("FK_Circuit_DevicePin", store.Table("Circuit"), DevicePinData.CircuitIdField.Field, ForeignKeyAction.Restrict, false);
        }
Ejemplo n.º 12
0
        // Creates Memory wrapper
        private Memory CreateItem(
            // Fields of Memory table
            Guid MemoryId,
            bool Writable,
            bool WriteOn1,
            MemoryOnStart OnStart,
            int AddressBitWidth,
            int DataBitWidth,
            string Data,
            string Note
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = MemoryId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            MemoryData dataMemory = new MemoryData()
            {
                MemoryId        = MemoryId,
                Writable        = Writable,
                WriteOn1        = WriteOn1,
                OnStart         = OnStart,
                AddressBitWidth = AddressBitWidth,
                DataBitWidth    = DataBitWidth,
                Data            = Data,
                Note            = Note,
            };

            return(this.Create(this.Table.Insert(ref dataMemory), rowIdCircuit));
        }
Ejemplo n.º 13
0
        // Creates table.
        public static TableSnapshot <MemoryData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <MemoryData> table = new TableSnapshot <MemoryData>(store, "Memory", MemoryData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_Memory", MemoryData.MemoryIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 14
0
        // Creates table.
        public static TableSnapshot <LedMatrixData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <LedMatrixData> table = new TableSnapshot <LedMatrixData>(store, "LedMatrix", LedMatrixData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_LedMatrix", LedMatrixData.LedMatrixIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 15
0
        // Creates table.
        public static TableSnapshot <ProjectData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <ProjectData> table = new TableSnapshot <ProjectData>(store, "Project", ProjectData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_Project", ProjectData.ProjectIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 16
0
        // Creates table.
        public static TableSnapshot <CircuitButtonData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <CircuitButtonData> table = new TableSnapshot <CircuitButtonData>(store, "CircuitButton", CircuitButtonData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_CircuitButton", CircuitButtonData.CircuitButtonIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 17
0
        // Creates table.
        public static TableSnapshot <GraphicsArrayData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <GraphicsArrayData> table = new TableSnapshot <GraphicsArrayData>(store, "GraphicsArray", GraphicsArrayData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_GraphicsArray", GraphicsArrayData.GraphicsArrayIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 18
0
        // Creates table.
        public static TableSnapshot <SensorData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <SensorData> table = new TableSnapshot <SensorData>(store, "Sensor", SensorData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_Sensor", SensorData.SensorIdField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 19
0
        // Creates table.
        public static TableSnapshot <CollapsedCategoryData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <CollapsedCategoryData> table = new TableSnapshot <CollapsedCategoryData>(store, "CollapsedCategory", CollapsedCategoryData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_CollapsedCategory", CollapsedCategoryData.NameField.Field, true);
            // Return created table
            return(table);
        }
Ejemplo n.º 20
0
        // Creates table.
        public static TableSnapshot <LogicalCircuitData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <LogicalCircuitData> table = new TableSnapshot <LogicalCircuitData>(store, "LogicalCircuit", LogicalCircuitData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_LogicalCircuit", LogicalCircuitData.LogicalCircuitIdField.Field, true);
            table.MakeUnique("AK_LogicalCircuit_Name", LogicalCircuitData.NameField.Field, false);
            // Return created table
            return(table);
        }
Ejemplo n.º 21
0
        // Creates table.
        public static TableSnapshot <WireData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <WireData> table = new TableSnapshot <WireData>(store, "Wire", WireData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_Wire", WireData.WireIdField.Field, true);
            table.CreateIndex("IX_LogicalCircuit_Wire", WireData.LogicalCircuitIdField.Field);
            // Return created table
            return(table);
        }
Ejemplo n.º 22
0
        // Creates table.
        public static TableSnapshot <CircuitProbeData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <CircuitProbeData> table = new TableSnapshot <CircuitProbeData>(store, "CircuitProbe", CircuitProbeData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_CircuitProbe", CircuitProbeData.CircuitProbeIdField.Field, true);
            table.MakeUnique("AK_CircuitProbe_Name", CircuitProbeData.NameField.Field, false);
            // Return created table
            return(table);
        }
Ejemplo n.º 23
0
        // Creates table.
        public static TableSnapshot <DevicePinData> CreateTable(StoreSnapshot store)
        {
            TableSnapshot <DevicePinData> table = new TableSnapshot <DevicePinData>(store, "DevicePin", DevicePinData.fields);

            // Create all but foreign keys of the table
            table.MakeUnique("PK_DevicePin", DevicePinData.PinIdField.Field, true);
            table.MakeUnique("AK_DevicePinName", DevicePinData.CircuitIdField.Field, DevicePinData.NameField.Field);
            table.CreateIndex("IX_Circuit_DevicePin", DevicePinData.CircuitIdField.Field);
            // Return created table
            return(table);
        }
Ejemplo n.º 24
0
 private static bool Equal <T>(TableSnapshot <T> x, TableSnapshot <T> y) where T : struct
 {
     return(ProjectTester.EqualCount(x, y) && x.Zip(y, (RowId xr, RowId yr) => {
         T xd, yd;
         x.GetData(xr, out xd);
         y.GetData(yr, out yd);
         foreach (IField <T> field in x.Fields)
         {
             if (field.Compare(ref xd, ref yd) != 0)
             {
                 return false;
             }
         }
         return true;
     }).All(r => r));
 }
        public RecordLoader(XmlNameTable nameTable, TableSnapshot <TRecord> table, Action <RowId> register)
        {
            Debug.Assert(nameTable != null);
            Debug.Assert(register != null);

            this.table       = table;
            this.register    = register;
            this.serializers = new Dictionary <string, IFieldSerializer <TRecord> >(XmlHelper.AtomComparer);
            foreach (IField <TRecord> field in this.table.Fields)
            {
                if (field is IFieldSerializer <TRecord> serializer)
                {
                    string fieldName = nameTable.Add(field.Name);
                    this.serializers.Add(fieldName, serializer);
                }
            }
        }
Ejemplo n.º 26
0
        internal CircuitProbe FindOrCreate(RowId rowId)
        {
            Debug.Assert(!rowId.IsEmpty && !this.Table.IsDeleted(rowId), "Bad RowId");
            CircuitProbe item;

            if ((item = this.Find(rowId)) != null)
            {
                Debug.Assert(!item.IsDeleted(), "Deleted item should not be present in the dictionary");
                return(item);
            }
            Guid primaryKeyValue = this.Table.GetField(rowId, CircuitProbeData.CircuitProbeIdField.Field);


            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");

            return(this.Create(rowId, tableCircuit.Find(CircuitData.CircuitIdField.Field, primaryKeyValue)));
        }
 // Saves the table
 private static void SaveRecords <TRecord>(XmlWriter writer, TableSnapshot <TRecord> table) where TRecord : struct
 {
     foreach (RowId rowId in table.Rows)
     {
         TRecord data;
         table.GetData(rowId, out data);
         writer.WriteStartElement(table.Name, CircuitProject.PersistenceNamespace);
         foreach (IField <TRecord> field in table.Fields)
         {
             if (field is IFieldSerializer <TRecord> serializer && serializer.NeedToSave(ref data))
             {
                 writer.WriteStartElement(field.Name, CircuitProject.PersistenceNamespace);
                 writer.WriteString(serializer.GetTextValue(ref data));
                 writer.WriteEndElement();
             }
         }
         writer.WriteEndElement();
     }
 }
Ejemplo n.º 28
0
        // Creates Gate wrapper
        private Gate CreateItem(
            // Fields of Gate table
            Guid GateId
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = GateId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            GateData dataGate = new GateData()
            {
                GateId = GateId,
            };

            return(this.Create(this.Table.Insert(ref dataGate), rowIdCircuit));
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Initialize hasMapped dictionary with tableName
        /// To determinate which record has been mapped
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="sourceDatabase"></param>
        /// <param name="destinationDatabase"></param>
        protected void Initialize(string tableName, DatabaseSnapshot sourceSnapshot, DatabaseSnapshot destSnapshot, DatabaseSnapshot outputSnapshot)
        {
            //TableSnapshot sourceTable = sourceSnapshot.GetTableSnapshot(tableName);
            TableSnapshot destTable = destSnapshot.GetTableSnapshot(tableName);

            ////
            //// Get common record from source table and destTable
            //// Then try to save to database
            //TableSnapshot commonTable = TableSnapshot.GetCommonRecord(sourceTable, destTable);
            //if (commonTable.IsEmpty == false)
            //{
            //    this._listTableToCheck.Add(tableName);
            //}
            if (destTable.IsEmpty == false)
            {
                this._listTableToCheck.Add(tableName);
            }

            //
            // Add
            outputSnapshot.Add(destTable);
            LogService.Log.Info("Saved snapshot of table : " + tableName);
        }
Ejemplo n.º 30
0
        // Creates DevicePin wrapper
        private DevicePin CreateItem(
            // Fields of DevicePin table
            Guid PinId,
            Circuit Circuit,
            int BitWidth,
            PinType PinType,
            PinSide PinSide,
            bool Inverted,
            string Name,
            string Note,
            string JamNotation
            // Fields of Circuit table

            )
        {
            TableSnapshot <CircuitData> tableCircuit = (TableSnapshot <CircuitData>) this.CircuitProject.Table("Circuit");
            CircuitData dataCircuit = new CircuitData()
            {
                CircuitId = PinId
            };
            RowId rowIdCircuit = tableCircuit.Insert(ref dataCircuit);

            DevicePinData dataDevicePin = new DevicePinData()
            {
                PinId       = PinId,
                CircuitId   = (Circuit != null) ? Circuit.CircuitId : DevicePinData.CircuitIdField.Field.DefaultValue,
                BitWidth    = BitWidth,
                PinType     = PinType,
                PinSide     = PinSide,
                Inverted    = Inverted,
                Name        = Name,
                Note        = Note,
                JamNotation = JamNotation,
            };

            return(this.Create(this.Table.Insert(ref dataDevicePin), rowIdCircuit));
        }