/// <summary> /// Adds a structure to the circuit that tries to guarantee a minimum /// </summary> /// <param name="circuit">The circuit.</param> /// <param name="name">A unique name for the elements.</param> /// <param name="lowest">The lowest node.</param> /// <param name="highest">The highest node.</param> /// <param name="minimum">The minimum between the two.</param> public static void AddMinimum(IEntityCollection circuit, string name, string lowest, string highest, double minimum, double weight = 1e-3) { string i = $"{name}.i"; circuit.Add(new Resistor($"R{name}", highest, lowest, 1.0 / weight)); circuit.Add(new VoltageSource($"V{name}", i, lowest, minimum)); AddRectifyingElement(circuit, $"D{name}", i, highest); }
/// <summary> /// Adds a structure to the circuit that tries to guarantee an offset between two nodes. /// </summary> /// <param name="circuit">The circuit.</param> /// <param name="name">A unique name for the elements.</param> /// <param name="lowest">The lowest node.</param> /// <param name="highest">The highest node.</param> /// <param name="offset">The offset.</param> public static void AddOffset(IEntityCollection circuit, string name, string lowest, string highest, double offset) { // string i = $"{name}.i"; // circuit.Add(new Resistor($"R{name}", i, highest, 1e-6)); // circuit.Add(new VoltageSource($"V{name}", i, lowest, offset)); // Northon equivalent has less unknowns to solve circuit.Add(new Resistor($"R{name}", highest, lowest, 1e-6)); circuit.Add(new CurrentSource($"I{name}", lowest, highest, offset * 1e6)); }
private static void AddControlledMinimum(IEntityCollection ckt, string name, string lowX, string highX, string lowY, string highY, Vector2 direction) { string i = $"{name}.xc"; MinimumConstraint.AddRectifyingElement(ckt, $"D{i}", i, highX); ckt.Add(new VoltageControlledVoltageSource($"E{i}", i, lowX, highY, lowY, direction.X / direction.Y)); i = $"{name}.yc"; MinimumConstraint.AddRectifyingElement(ckt, $"D{i}", i, highY); ckt.Add(new VoltageControlledVoltageSource($"E{i}", i, lowY, highX, lowX, direction.Y / direction.X)); }
internal void SetValue(string name, object value, Type propertyType) { if (EntityCtx.DynamicProperties.IsNotNull()) { IEnumerable <Entity> entities = this[EntityCtx.DynamicProperties.Property.Name] as IEnumerable <Entity>; if (entities.IsNotNull()) { Entity entity = entities.FirstOrDefault(e => e[EntityCtx.DynamicProperties.CodeProperty].IsNotNull() && e[EntityCtx.DynamicProperties.CodeProperty].Equals(name)); if (entity.IsNotNull()) { if (EntityCtx.DynamicProperties.ValuesProperties.ContainsKey(propertyType)) { entity[EntityCtx.DynamicProperties.ValuesProperties[propertyType]] = value; } } else { IEntityCollection collection = entities as IEntityCollection; if (collection.IsNotNull()) { entity = collection.CreateInstance(EntityCtx.DynamicProperties.Property.ReletedEntity.RelatedEntity.EntityType, true, null) as Entity; if (entity.IsNotNull()) { if (EntityCtx.DynamicProperties.ValuesProperties.ContainsKey(propertyType)) { entity[EntityCtx.DynamicProperties.ValuesProperties[propertyType]] = value; } entity[EntityCtx.DynamicProperties.CodeProperty] = name; collection.Add(entity); } } } } } }
public void FillContext(WorksheetContext ctx) { ctx.Context.Entites.ForEach((e) => { Attribute attribute = e.Attributes.FirstOrDefault(a => a.IsTypeOf <Table>()); if (attribute.IsNotNull()) { Table table = attribute.CastToType <Table>(); if (_dataSet.Tables.Contains(table.TableName)) { IEntityCollection collection = e.Entities as IEntityCollection; if (collection.IsNotNull()) { foreach (DataRow row in _dataSet.Tables[table.TableName].Rows) { Entity entity = collection.CreateInstance(e.EntityType, true, new object[] { row }) as Entity; if (entity.IsNotNull()) { collection.Add(entity); } } } } } }); ctx.AcceptChanges(); }
/// <summary> /// Constructor injection. /// </summary> /// <param name="analyticsService">Analytics service.</param> /// <param name="dataContext">Data context.</param> /// <param name="anilibriaApiService">Anilibria restful service.</param> /// <exception cref="ArgumentNullException"></exception> public OnlinePlayerViewModel(IAnalyticsService analyticsService, IDataContext dataContext, IAnilibriaApiService anilibriaApiService) { m_AnalyticsService = analyticsService ?? throw new ArgumentNullException(nameof(analyticsService)); m_AnilibriaApiService = anilibriaApiService ?? throw new ArgumentNullException(nameof(anilibriaApiService)); m_DataContext = dataContext ?? throw new ArgumentNullException(nameof(dataContext)); m_IsSD = true; m_Volume = .8; RestoreSettings(); UpdateVolumeState(m_Volume); CreateCommands(); m_RestoreCollection = m_DataContext.GetCollection <PlayerRestoreEntity> (); m_PlayerRestoreEntity = m_RestoreCollection.FirstOrDefault(); if (m_PlayerRestoreEntity == null) { m_PlayerRestoreEntity = new PlayerRestoreEntity { ReleaseId = -1, VideoId = -1, VideoPosition = 0 }; m_RestoreCollection.Add(m_PlayerRestoreEntity); } m_ReleaseStateCollection = m_DataContext.GetCollection <ReleaseVideoStateEntity> (); m_IsSupportedCompactOverlay = ApplicationView.GetForCurrentView().IsViewModeSupported(ApplicationViewMode.CompactOverlay); }
/// <summary> /// Creates a subcircuit definition with a component in parallel and series. /// </summary> public static void ParallelSeries(IEntityCollection ckt, Func <string, IComponent> factory, string ca, string cb, int m, int n) { for (var j = 0; j < m; j++) { for (var i = 0; i < n; i++) { var clone = factory("entity" + j.ToString() + "_" + i.ToString()); string a, b; if (i == 0) { a = ca; } else { a = "n" + j.ToString() + "_" + (i - 1).ToString(); } if (i == n - 1) { b = cb; } else { b = "n" + j.ToString() + "_" + i.ToString(); } clone.Connect(a, b); ckt.Add(clone); } } }
/// <summary> /// Adds or replaces an entity in the given collection. /// </summary> public static void AddOrReplace <T>(this IEntityCollection <T> collection, T entity) where T : Entities.GTFSEntity { if (!collection.Contains(entity)) { collection.Add(entity); } }
/// <summary> /// Creates an <see cref="IEntity"/> and places it in the given <paramref name="entityCollection"/>. /// </summary> /// <typeparam name="TAllowedType"></typeparam> /// <param name="alias">The alias.</param> /// <param name="name">The name.</param> /// <param name="entityCollection">The entity collection.</param> /// <returns></returns> public static T CreateIn <T>(string alias, string name, IEntityCollection <T> entityCollection) where T : class, IEntity, IReferenceByAlias, new() { var entity = Create <T>(alias, name); entityCollection.Add(entity); return(entity); }
/// <summary> /// Save player restore state. /// </summary> public void SavePlayerRestoreState() { if (SelectedOnlineVideo == null) { return; } var isNotNeedUpdatePosition = m_PlayerRestoreEntity?.ReleaseId == SelectedRelease?.Id && m_PlayerRestoreEntity?.VideoPosition > 0 && Position == 0; m_PlayerRestoreEntity.ReleaseId = SelectedRelease.Id; m_PlayerRestoreEntity.VideoId = SelectedOnlineVideo.Order; if (!isNotNeedUpdatePosition) { m_PlayerRestoreEntity.VideoPosition = Position; } m_RestoreCollection.Update(m_PlayerRestoreEntity); if (m_ReleaseVideoStateEntity == null || m_ReleaseVideoStateEntity.ReleaseId != SelectedRelease.Id) { m_ReleaseVideoStateEntity = m_ReleaseStateCollection.FirstOrDefault(a => a.ReleaseId == SelectedRelease.Id); if (m_ReleaseVideoStateEntity == null) { m_ReleaseVideoStateEntity = new ReleaseVideoStateEntity { ReleaseId = SelectedRelease.Id, VideoStates = new List <VideoStateEntity> () }; m_ReleaseStateCollection.Add(m_ReleaseVideoStateEntity); } } if (m_ReleaseVideoStateEntity.VideoStates == null) { m_ReleaseVideoStateEntity.VideoStates = new List <VideoStateEntity> (); } var videoState = m_ReleaseVideoStateEntity.VideoStates.FirstOrDefault(a => a.Id == SelectedOnlineVideo.Order); if (videoState == null) { m_ReleaseVideoStateEntity.VideoStates.Add( new VideoStateEntity { Id = SelectedOnlineVideo.Order, LastPosition = Position } ); } else { videoState.LastPosition = Position == 0 && videoState.LastPosition > 0 ? videoState.LastPosition : Position; if (!videoState.IsSeen && PositionPercent >= 90 && PositionPercent <= 100) { videoState.IsSeen = true; } } m_ReleaseStateCollection.Update(m_ReleaseVideoStateEntity); }
/// <summary> /// Fills the specified destination collection using data coming from the given source /// and adapting the source data to the destination format using the speficied adapter /// delegate. /// </summary> /// <typeparam name="TSource">The type of the source.</typeparam> /// <typeparam name="TDest">The type of the destination.</typeparam> /// <param name="source">The source data.</param> /// <param name="destination">The destination container.</param> /// <param name="adapter">The adapter.</param> /// <returns> /// The a reference to the supplied destination container to allow fluent interface usage. /// </returns> public static IEntityCollection <TDest> Fill <TSource, TDest>(this IQueryable <TSource> source, IEntityCollection <TDest> destination, Func <TSource, IEntityCollection <TDest>, TDest> adapter) where TDest : class { destination.BeginInit(); source.ForEach(element => destination.Add(adapter(element, destination))); destination.EndInit(); return(destination); }
public static IEntityCollection <T> BulkLoad <T, TSource>(this IEntityCollection <T> list, IEnumerable <TSource> data, Func <TSource, T> adapter) where T : class { list.BeginInit(); foreach (var item in data) { list.Add(adapter(item)); } list.EndInit(true); return(list); }
private static void AddExits(IEntityCollection <ExitPoint> exitPoints, string[] exits) { bool isFirstExit = true; foreach (var exit in exits) { var ep = Entity.Create <ExitPoint>(); ep.Name = exit; ep.IsDefaultExitPoint = isFirstExit; exitPoints.Add(ep); isFirstExit = false; } }
/// <summary> /// Adds the diode model that can be used to define minimum constraints. /// </summary> /// <param name="circuit">The circuit.</param> public static void AddRectifyingModel(IEntityCollection circuit) { if (circuit.Contains(DiodeModelName)) { return; } var model = new VoltageSwitchModel(DiodeModelName); model.Parameters.OnResistance = 1e-6; model.Parameters.OffResistance = 1e9; model.Parameters.Hysteresis = 1e-3; model.Parameters.Threshold = 0.0; circuit.Add(model); }
public DownloadService(IDataContext dataContext) { m_DataContext = dataContext; m_Collection = m_DataContext.GetCollection <DownloadFileEntity> (); m_Entity = m_Collection.FirstOrDefault(); if (m_Entity == null) { m_Entity = new DownloadFileEntity { DownloadingReleases = new List <DownloadReleaseEntity> () }; m_Collection.Add(m_Entity); } m_SpeedTimer.Interval = TimeSpan.FromSeconds(1); m_SpeedTimer.Tick += SpeedTimerTick; }
private ChangesEntity GetChanges(IEntityCollection <ChangesEntity> changesCollection) { var changes = changesCollection.FirstOrDefault(); if (changes == null) { changes = new ChangesEntity { NewOnlineSeries = new Dictionary <long, int> (), NewReleases = new List <long> (), NewTorrents = new Dictionary <long, int> (), NewTorrentSeries = new Dictionary <long, IDictionary <long, string> > () }; changesCollection.Add(changes); } return(changes); }
private void FillReleaseVideoState() { if (m_ReleaseVideoStateEntity == null || m_ReleaseVideoStateEntity.ReleaseId != SelectedRelease.Id) { m_ReleaseVideoStateEntity = m_ReleaseStateCollection.FirstOrDefault(a => a.ReleaseId == SelectedRelease.Id); if (m_ReleaseVideoStateEntity == null) { m_ReleaseVideoStateEntity = new ReleaseVideoStateEntity { ReleaseId = SelectedRelease.Id, VideoStates = new List <VideoStateEntity> () }; m_ReleaseStateCollection.Add(m_ReleaseVideoStateEntity); } } if (m_ReleaseVideoStateEntity.VideoStates == null) { m_ReleaseVideoStateEntity.VideoStates = new List <VideoStateEntity> (); } }
private static void SplitCollectionForInsertUpdateAndDeleteOperations(IEntityCollection entitiesToSave, out IEntityCollection newEntities, out IEntityCollection changedEntities, out IEntityCollection removedEntities) { IDbTable table = entitiesToSave.IDbTable; newEntities = table.NewEntityCollection(); changedEntities = table.NewEntityCollection(); removedEntities = table.NewEntityCollection(); foreach (IEntity entity in entitiesToSave) { switch (entity.EntityState) { case EntityState.New: newEntities.Add(entity); break; case EntityState.OutOfSync: changedEntities.Add(entity); break; case EntityState.PendingDeletion: removedEntities.Add(entity); break; } } }
public void Setup() { entityCollection = new EntityCollection(); entity = new Entity(new VariableCollection()); entityCollection.Add(entity); }
/// <summary> /// Adds an item to the <see cref="ICollection{T}" />. /// </summary> /// <param name="item">The object to add to the <see cref="ICollection{T}" />.</param> public void Add(IEntity item) => _entities.Add(item);
/// <summary> /// Adds an idealized diode. I.e. an element that conducts if <paramref name="from"/> is /// higher than <paramref name="to"/>. /// </summary> /// <remarks> /// This isn't really a diode, but a voltage-controlled switch. But for thinking it helps to look at it /// like a diode. /// </remarks> /// <param name="circuit">The circuit to add the diode to.</param> /// <param name="name">The name of the diode.</param> /// <param name="from">The name of the node where currents flows away.</param> /// <param name="to">The name of the node where current flows into.</param> public static void AddRectifyingElement(IEntityCollection circuit, string name, string from, string to) { AddRectifyingModel(circuit); circuit.Add(new VoltageSwitch(name, from, to, from, to, DiodeModelName)); }