public ModifierType[] GetModifiersOn <ModifierType>(IModifiable modifiable) where ModifierType : IModifier { ModifierMap modifiers = FindOrCreateModifierDictionary(modifiable); List <ModifierType> modifierList = FindOrCreateModifierList(modifiers, typeof(ModifierType)) as List <ModifierType>; return(modifierList.ToArray()); }
public override bool SetValue(IModifiable source, string input, out string validationError) { validationError = null; //TODO: Add validations for this. Setter(source, input); return(true); }
/// <summary> /// An immediate identity insert with identity_insert on just for this single entity, unless queued is true. Queued identity insert entities are inserted if nothing given. /// </summary> /// <param name="sqlEntity"></param> public void IdentityInsert(TSqlEntity sqlEntity = null, Boolean queued = false) { if (sqlEntity == null) { FlushIdentityInserts(); return; } // Queue identity insert... IModifiable modifiableEntity = sqlEntity as IModifiable; if (modifiableEntity != null) { modifiableEntity.CreatedDate = NowDateTime; modifiableEntity.ModifiedDate = NowDateTime; } else if (sqlEntity is ICreatable) { ((ICreatable)sqlEntity).CreatedDate = NowDateTime; } var insertColumns = $"{GetIdentityInsertColumns()},{InsertColumns()}"; var insertValues = $"{GetIdentityInsertValues(sqlEntity)},{GetInsertValues(sqlEntity)}"; QueuedIdentityInserts.Append(QueueIdentityInsertColumnsPattern.FormatX(TableName, insertColumns, insertValues)); if (!queued) { FlushIdentityInserts(); } }
public ModifierType[] GetModifiersOn <ModifierType>(IModifiable modifiable) where ModifierType : class, IModifier { ModifierMap modifiers = FindOrCreateModifierDictionary(modifiable); ModifierList modifierList = FindOrCreateModifierList(modifiers, typeof(ModifierType)); return(Convert <ModifierType>(modifierList)); }
public void Unregister(IModifiable source) { _damage.Unregister(source); _interval.Unregister(source); _range.Unregister(source); _attacksPerInterval.Unregister(source); }
public void Modify(IModifiable modifiable) { if (invitee.CanInvite) { modifiable.AddValue("actions", new Action("invite", "/invitations/invite/")); } }
private void Awake() { if (targetComponent) { target = targetComponent; } }
public AccessorInfo(AccessorDeclarationSyntax decl, IModifiable parent) { _modifiers = decl.Modifiers.ParseModifiers() .WithDefaultVisibility(parent.Modifiers.First()); Type = decl.Keyword.ToString().StartsWith("get") ? AccessorType.Getter : AccessorType.Setter; }
/// <summary> /// SaveNewCar method /// </summary> /// <remarks> /// Save the new modified vehicle in file /// </remarks> /// <param name="imb">The new modified vehicle</param> public void SaveNewCar(IModifiable imb) { this.imb = imb; modlist.Add(imb); modlist.ReadFromFile(false); modlist.SaveInFile(false); }
public void Remove(IModifiable modifiable, IModifier modifier) { ModifierMap modifiers = FindOrCreateModifierDictionary(modifiable); List <IModifier> modifierList = FindOrCreateModifierList(modifiers, modifier.ModifierType); modifierList.Remove(modifier); }
/// <summary> /// Appliance of <see cref="IModifiable"/>'s <see cref="IModifier"/>s /// </summary> /// <param name="modifiable"></param> public static void Apply(IModifiable modifiable) { modifiable.DefaultModifier.Apply(modifiable); foreach (var modifier in modifiable.Modifiers) { modifier.Apply(modifiable); } }
/// <summary> /// Final method. /// </summary> /// <remarks> /// The main method of that class that initialize the components in the form. /// </remarks> /// <param name="imb">The modifiable vehicle.</param> public Final(IModifiable imb) { InitializeComponent(); this.FormClosing += ThisForm_FormClosing; //check if the red "X" is pressed ShowAllModifiedVehicles(imb); }
public void Init() { modifier = Substitute.For <IModifier>(); modifiable = Substitute.For <IModifiable>(); modifier.ModifierType.Returns(typeof(IModifier)); activeModifications = new ActiveModifications(); }
/// <summary> /// Sets modified time property. /// </summary> /// <param name="entity">Entity.</param> public static void SetModifiedTime(this IModifiable entity) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } entity.ModifiedTime = SharedLib.InternalDate.Now; }
/// <summary> /// Modify method. /// </summary> /// <remarks> /// The main method of that class that initialize the components in the form. /// </remarks> /// <param name="iVehicle">The selected vehicle from the previos form</param> /// <param name="modList">List with all stock vehicles</param> /// <param name="sName">The name of the user (buyer)</param> /// <param name="cBudget">The budget of the user</param> public Modify(int iVehicle, ModifiableList modList, string sName, Budget cBudget) { InitializeComponent(); this.FormClosing += ThisForm_FormClosing; //check if the red "X" is pressed Debug.WriteLine("ListSize() in Modify: " + modList.ListSize()); // the size of the list in this form imb = modList.GetObjectFromList(iVehicle); this.sName = sName; this.cBudget = cBudget; Modify_Load(); }
public void Initialize(ModifierParameters p, Game game) { Game = game; SourceCard = p.SourceCard; SourceEffect = p.SourceEffect; Owner = p.Owner; X = p.X; InitializeLifetimes(p.IsStatic); Initialize(); }
public virtual void SetValue(object value) { IModifiable modifiable = this.GetModifiable(); if (modifiable == null) { return; } modifiable.SetValue(value); }
/// <inheritdoc /> public override void OnAttach(IModifiable modifiable) { base.OnAttach(modifiable); if (modifiable is ModifiableValue <T> ) { return; } Debug.LogError($"Trying to attach {this} with type {TargetType} to {modifiable} which is incompatible. Expected ModifiableValue<{TargetType}>"); Detach(); }
public virtual void SetValue <TValue>(TValue value) { IModifiable modifiable = this.GetModifiable(); if (modifiable == null) { return; } modifiable.SetValue <TValue>(value); }
ModifierMap FindOrCreateModifierDictionary(IModifiable modifiable) { ModifierMap modifiers; if (!activeModifications.TryGetValue(modifiable, out modifiers)) { modifiers = new ModifierMap(); activeModifications.Add(modifiable, modifiers); } return(modifiers); }
/// <summary> /// Sets the parent then calls <see cref="OnAttach"/> /// </summary> /// <param name="modifiable">the modifiable attached to</param> internal void OnAttach_Internal(IModifiable modifiable) { Debug.Log($"{Duration}"); Parent = modifiable; if (!(Duration > 0)) { return; } Task.Delay(Mathf.RoundToInt(Duration * 1000)).ContinueWith(t => Detach()); }
public IModifier[] GetModifiersOn(IModifiable modifiable) { ModifierMap modifiers = FindOrCreateModifierDictionary(modifiable); List <IModifier> modifierList = new List <IModifier>(); foreach (var modifierTypeList in modifiers) { modifierList.AddRange(modifierTypeList.Value); } return(modifierList.ToArray()); }
// create an instance, bound to the given text box, using the given parser // to set the given property. public TextBinding(TextBox box, Parser <D> parser, string propertyName, IModifiable notify) { Parse = parser; Info = typeof(T).GetProperty(propertyName); if (Info == null) { throw new ArgumentException(string.Format("property {0} not valid", propertyName)); } TextBox = box; box.LostFocus += delegate(object sender, EventArgs args) { SetValue(); }; box.Validating += Validator; NotificationTarget = notify; }
public AdminModifyField(StandardHeldPrompt previous, Client client, IModifiable target, ModifiableParser parser) : base(previous, null, client) { if (target == null) { throw new ArgumentNullException("target"); } if (parser == null) { throw new ArgumentNullException("parser"); } objectToModify = target; fieldParser = parser; }
public ShapeRadioButtonBinding(RadioButton button, int shape, IModifiable toNotify) { Button = button; Shape = shape; NotifyTarget = toNotify; Button.Click += new EventHandler(delegate(object sender, EventArgs args) { if (Line != null && Line.Shape != Shape) { Line.Shape = Shape; NotifyTarget.SetModified(true); } }); }
public override string GetValue(IModifiable source) { ISaveable value = Getter(source); if (value == null) { return("null"); } else { return(value.GetType().Name + " " + value.GetSaveID()); } }
public override bool SetValue(IModifiable source, string input, out string validationError) { //CanBeNull is false, so input should never be null. int value; if (int.TryParse(input, out value)) { Setter(source, value); validationError = null; return(true); } validationError = "Not a valid number."; return(false); }
public void GetModifiersOn_Pass() { Init(); IModifiable modifiable2 = Substitute.For <IModifiable>(); IModifier modifier2 = Substitute.For <IModifier>(); modifier2.ModifierType.Returns(typeof(IModifier)); activeModifications.Add(modifiable, modifier); activeModifications.Add(modifiable2, modifier2); Assert.AreSame(modifier2, activeModifications.GetModifiersOn(modifiable2)[0]); }
/// <summary> /// ShowAllModifiedVehicles method. /// </summary> /// <remarks> /// Save the last modified vehicles in a file and then read all the saved vehicles /// and show them on the screen. /// </remarks> /// <param name="imb"></param> private void ShowAllModifiedVehicles(IModifiable imb) { //save the last modivified vehicle autoshow.SaveNewCar(imb); modlist = autoshow.ShowAll(); //get each object in that list for (int i = 0; i < modlist.ListSize(); i++) { imb = modlist.GetObjectFromList(i); //print the object in textbox. txtHistory.AppendText(imb.ToString()); txtHistory.AppendText(Environment.NewLine); } }
public IEnumerator ResetLifetimeTestPass() { DateTime modificationTime = DateTime.UtcNow; TimeSpan elapsedTime = new TimeSpan(0); float lifetime = 2; IModifiable modifiable = Substitute.For <IModifiable>(); Modifier <IModifiable> simpleModifier = Substitute.For <Modifier <IModifiable> >(); AliveModifier <IModifiable> aliveModifier = new AliveModifier <IModifiable>(simpleModifier, lifetime); //Setup When...Do for modifier simpleModifier. When(modifier => modifier.Modify(modifiable)). Do(modifier => modifiable.OnModificationApplied(simpleModifier)); simpleModifier. When(modifier => modifier.Revert(modifiable)). Do(modifier => modifiable.OnModificationReverted(simpleModifier)); //Setup When...Do for modifiable modifiable. When(spyModifiable => spyModifiable.OnModificationApplied(simpleModifier)). Do(spyModifiable => modificationTime = DateTime.UtcNow); modifiable. When(spyModifiable => spyModifiable.OnModificationReverted(simpleModifier)). Do(spyModifiable => elapsedTime = DateTime.UtcNow.Subtract(modificationTime)); aliveModifier.Modify(modifiable); yield return(new WaitForSeconds(lifetime - 1)); aliveModifier.Reset(); modificationTime = DateTime.UtcNow; yield return(new WaitForSeconds(lifetime - 1)); Assert.Zero(elapsedTime.Seconds); yield return(new WaitForSeconds(lifetime)); Assert.NotZero(elapsedTime.Seconds); Assert.Greater(elapsedTime.TotalSeconds, lifetime); }
/// <summary> /// cmbVehicleType_SelectedIndexChanged method /// </summary> /// <remarks> /// Method that is called everytime when the user choose different type of vehicle. /// It's finding all objects of the selected type and put them in dropdown menu. /// </remarks> /// <param name="sender">A reference to the control/object that raised the event.</param> /// <param name="e">The event data.</param> private void cmbVehicleType_SelectedIndexChanged(object sender, EventArgs e) { Debug.WriteLine("Selected vehicle is: " + Convert.ToString(cmbVehicleType.Text)); // check the selected item cmbVehicleModel.Items.Clear(); //clear the second combobox lblModel.Visible = true; cmbVehicleModel.Visible = true; for (int i = 0; i < modlist.ListSize(); i++) //get each object in that list { imb = modlist.GetObjectFromList(i); string strSelectedType = Convert.ToString(imb.GetType()); // the type of the returned object if (strSelectedType == "VehicleTuning." + cmbVehicleType.Text) //check if the returned object is from the same type as the selected one { cmbVehicleModel.Items.Add(imb.Model.ToString()); iSelectedObject = i; } } }
public AdminSelectModify(StandardHeldPrompt previous, Client client, IModifiable target) : base(previous, null, client) { objectToModify = target; Metadata meta = Metadata.LoadedClasses[target.GetType()]; ModifiableParser[] parsers = meta.GetModifyParsers(); string quit = "Quit"; foreach (ModifiableParser parser in parsers) { string parserName = parser.Name(target); if (parserName.Equals(quit, StringComparison.InvariantCultureIgnoreCase)) { parserName = "Field" + parserName; } AddOption(parser.Description(target), ModifyField, parser, parserName); } AddOption("Finished editing this object.", EndThisPromptOption, null, quit); }
private void SetSourceValue <T>(IModifiable modifier, T value) { if (this.converter == null && typeof(T).Equals(this.sourceProxy.Type)) { modifier.SetValue(value); return; } object safeValue = value; if (this.converter != null) { safeValue = this.converter.ConvertBack(safeValue); } safeValue = this.sourceProxy.Type.ToSafe(safeValue); modifier.SetValue(safeValue); }
public void ModifiableModificationMade_Pass() { IModifiable modifiable = Substitute.For <IModifiable>(); Modifier <IModifiable> modifier = Substitute.For <Modifier <IModifiable> >(); bool isModifiableModified = false; modifiable. When(spyModifiable => spyModifiable.OnModificationApplied(modifier)). Do(spyModifiable => isModifiableModified = true); modifier. When(spyModifier => spyModifier.Modify(modifiable)). Do(spyModifier => modifiable.OnModificationApplied(modifier)); modifier.Modify(modifiable); Assert.IsTrue(isModifiableModified); }
//public virtual Boolean Exists(String filter = "", SqlParameter[] filterParameters = null, String selectColumns = null) //{ // selectColumns = selectColumns ?? SelectAllColumns(); // return SelectQuery(selectColumns, filter, filterParameters, null, new Paging(1)).HasRows; //} public void Insert(TSqlEntity sqlEntity) { if (SaveChangesTransactionally) { Context.BeginTransaction(); } IModifiable modifiableEntity = sqlEntity as IModifiable; if (modifiableEntity != null) { modifiableEntity.CreatedDate = NowDateTime; modifiableEntity.ModifiedDate = NowDateTime; } else if (sqlEntity is ICreatable) { ((ICreatable)sqlEntity).CreatedDate = NowDateTime; } InsertCore(sqlEntity, InsertColumns(), GetInsertValues(sqlEntity)); }
public override bool MouseUpHandler(object sender, ActionEventArgs e) { if (Modiafiable is ISelectable && Modiafiable != null) { try { // ExecuteMoveCommand(); } catch { } ((ISelectable)Modiafiable).IsSelected = false; c1 = null; c2 = null; diff = null; Modiafiable = null; _presenter.NotifyViews(); } return true; }
/// <summary> /// cmbVehicleModel_SelectedIndexChanged method /// </summary> /// <remarks> /// Method that is called everytime when the user choose different model of curent type of vehicle. /// It save the number of the selected method and print it's price. /// </remarks> /// <param name="sender">A reference to the control/object that raised the event.</param> /// <param name="e">The event data.</param> private void cmbVehicleModel_SelectedIndexChanged(object sender, EventArgs e) { for (int i = 0; i < modlist.ListSize(); i++) //get each object in that list { imb = modlist.GetObjectFromList(i); string strSelectedType = Convert.ToString(imb.Model); // the type of the returned object if (strSelectedType == cmbVehicleModel.Text) //check if the returned object is from the same type as the selected one { iSelectedObject = i; Debug.WriteLine("Selected model is: " + imb.Model.ToString()); lblPrice.Text = "The price of this vehicle is: " + imb.Price.ToString(); break; } } }
/// <summary> /// Add method. /// </summary> /// <remarks> /// Add new object of type IModifiable to the list. /// </remarks> /// <param name="mod"> The new vehicle that should be added into the list</param> public void Add(IModifiable mod) { vehicles.Add(mod); }
protected override bool DoObjectSelection(object _object) { if (_object is IModifiable) { if (Modiafiable == null) { Modiafiable = _object as IModifiable; if (_object is ISelectable) ((ISelectable)_object).IsSelected = true; } } return false; }