private PurchaseOrderLine[][] GetAllPremutations(IRequirement requirement, IList <Stock> stocks) { var vendors = new PurchaseOrderLine[stocks.Count][]; var maxAvailable = 0; for (int i = 0; i < stocks.Count; i++) { vendors[i] = GetLines(requirement.Quantity, stocks[i]); maxAvailable += stocks[i].Quantity; } if (maxAvailable == 0) { return(new PurchaseOrderLine[0][]); } var premuter = new Premuting <PurchaseOrderLine>(vendors); var result = new List <PurchaseOrderLine[]>(); var target = Math.Min(maxAvailable, requirement.Quantity); premuter.Premute((x, y, z) => { if (IsValidCombination(x, target)) { result.Add(x.Where(y => y.Quantity > 0).ToArray()); } }); return(result.ToArray()); }
public RequirementDeficiency(IRequirement requirement, eDeficiencyStatusEnum status, IAgent waivedBy, DateTime?waivedOn) { Requirement = requirement ?? throw new ArgumentNullException("requirement"); Status = status; WaivedBy = waivedBy; WaivedOn = waivedOn; }
public static IRequirement[] Decomposite(IRequirement requirement, List <IRequirement> requirements = null) { if (requirements == null) { requirements = new List <IRequirement>(); } var wr = requirement as WrappedRequirement; if (wr != null) { Decomposite(wr.innerRequirement, requirements); } else { var cr = requirement as CompositeRequirement; if (cr != null) { foreach (var r in cr.requirements) { Decomposite(r.Value, requirements); } } else { requirements.Add(requirement); } } return(requirements.ToArray()); }
public void EnsureIsMet(IRequirement requirement) { if (!requirement.IsMet()) { requirement.Meet(); } }
/// <summary> /// Constructor /// </summary> /// <param name="colorSettings"> /// The color settings data. /// </param> /// <param name="requirements"> /// The requirement dictionary. /// </param> /// <param name="undoRedoManager"> /// The undo/redo manager. /// </param> /// <param name="undoableFactory"> /// A factory for creating undoable actions. /// </param> /// <param name="alternativeFactory"> /// An Autofac factory for creating alternative requirements. /// </param> /// <param name="alwaysDisplayFactory"> /// An Autofac factory for creating always display dungeon items requirements. /// </param> /// <param name="dungeon"> /// The dungeon whose small keys are to be represented. /// </param> public SmallKeySmallItemVM( IColorSettings colorSettings, IRequirementDictionary requirements, IUndoRedoManager undoRedoManager, IUndoableFactory undoableFactory, AlternativeRequirement.Factory alternativeFactory, AlwaysDisplayDungeonItemsRequirement.Factory alwaysDisplayFactory, IDungeon dungeon) { _colorSettings = colorSettings; _undoRedoManager = undoRedoManager; _undoableFactory = undoableFactory; _item = dungeon.SmallKeyItem; _spacerRequirement = alternativeFactory(new List <IRequirement> { alwaysDisplayFactory(true), requirements[RequirementType.SmallKeyShuffleOn] }); _requirement = dungeon.ID == LocationID.EasternPalace ? requirements[RequirementType.KeyDropShuffleOn] : requirements[RequirementType.NoRequirement]; HandleClick = ReactiveCommand.Create <PointerReleasedEventArgs>(HandleClickImpl); _colorSettings.PropertyChanged += OnColorsChanged; _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; _spacerRequirement.PropertyChanged += OnRequirementChanged; }
public Task(IRequirement parent, ITaskType type) { Parent = parent; Type = type; Siblings = new List <ITask>(); Attachments = new List <IAttachment>(); }
/// <summary> /// Constructor /// </summary> /// <param name="bigKeyLocations"> /// The list of dungeon item IDs that can contain the big key. /// </param> /// <param name="children"> /// The list of child key layouts, if this layout is possible. /// </param> /// <param name="requirement"> /// The requirement for this key layout to be valid. /// </param> public BigKeyLayout( List <DungeonItemID> bigKeyLocations, List <IKeyLayout> children, IRequirement requirement) { _bigKeyLocations = bigKeyLocations; _children = children; _requirement = requirement; }
/// <summary> /// Constructor /// </summary> /// <param name="bigKeyLocations"> /// The list of dungeon item IDs that can contain the big key. /// </param> /// <param name="children"> /// The list of child key layouts, if this layout is possible. /// </param> /// <param name="requirement"> /// The requirement for this key layout to be valid. /// </param> public BigKeyLayout( List <DungeonItemID> bigKeyLocations, List <IKeyLayout> children, IRequirement requirement = null) { _bigKeyLocations = bigKeyLocations ?? throw new ArgumentNullException(nameof(bigKeyLocations)); _children = children ?? throw new ArgumentNullException(nameof(children)); _requirement = requirement ?? RequirementDictionary.Instance[RequirementType.NoRequirement]; }
/// <summary> /// Constructor /// </summary> /// <param name="bossPlacement"> /// The boss section to which the boss belongs. /// </param> public BossSmallItemVM(IBossPlacement bossPlacement) { _bossPlacement = bossPlacement ?? throw new ArgumentNullException(nameof(bossPlacement)); _requirement = RequirementDictionary.Instance[RequirementType.BossShuffleOn]; BossSelect = BossSelectVMFactory.GetBossSelectPopupVM(_bossPlacement); _bossPlacement.PropertyChanged += OnBossChanged; _requirement.PropertyChanged += OnRequirementChanged; }
/// <summary> /// Constructor /// </summary> /// <param name="map"> /// The map identity on which the location is represented. /// </param> /// <param name="x"> /// The X coordinate of the map location. /// </param> /// <param name="y"> /// The Y coordinate of the map location. /// </param> /// <param name="location"> /// The location parent class. /// </param> /// <param name="requirement"> /// The mode requirement for displaying this map location. /// </param> public MapLocation( MapID map, double x, double y, ILocation location, IRequirement requirement) { Map = map; X = x; Y = y; Location = location; Requirement = requirement; }
/// <summary> /// Constructor /// </summary> /// <param name="requirements"> /// The requirement dictionary. /// </param> /// <param name="fromNode"> /// The node from which the connection originates. /// </param> public EntryNodeConnection( IRequirementDictionary requirements, IRequirementNode fromNode) { _fromNode = fromNode; Requirement = requirements[RequirementType.NoRequirement]; _fromNode.PropertyChanged += OnNodeChanged; }
public static IRequirement GetRequirement(int id) { var requirements = GetRequirements(); IRequirement requirement = null; requirement = requirements.Where(x => x.Id == id).ToList().ElementAtOrDefault(0); return(requirement); }
public void ClearDeficiency(IProcessExecutionContext executionContext, IRequirement requirement) { var deficiency = GetCurrentRequirementDeficiency(requirement); if (deficiency.Status != eDeficiencyStatusEnum.Waived) { DataConnector.UpdateDeficiencyRecordStatus(executionContext.DataService, deficiency, eDeficiencyStatusEnum.Cleared); base.Remove(deficiency); } }
/// <summary> /// Constructor /// </summary> /// <param name="imageSourceBase"> /// A string representing the image source base. /// </param> /// <param name="item"> /// An item that is to be represented by this control. /// </param> public SmallKeyLargeItemVM(string imageSourceBase, IItem item) { _item = item ?? throw new ArgumentNullException(nameof(item)); _imageSourceBase = imageSourceBase ?? throw new ArgumentNullException(nameof(imageSourceBase)); _requirement = RequirementDictionary.Instance[RequirementType.GenericKeys]; _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; }
public void AddRequirement(IRequirement <T> requirement) { if (requirementCount >= requirements.Length) { Array.Resize(ref requirements, requirementCount * 2); } requirements[requirementCount] = requirement; requirementCount++; }
public Conditions(IRequirement requirement = null) { if (requirement == null) { Requirement = new Requirement(); return; } Requirement = requirement; }
/// <summary> /// Constructor /// </summary> /// <param name="imageSourceBase"> /// A string representing the base image source. /// </param> /// <param name="item"> /// The item of the key to be represented. /// </param> /// <param name="requirement"> /// The requirement for displaying the control. /// </param> public SmallItemVM(string imageSourceBase, IItem item, IRequirement requirement) { _imageSourceBase = imageSourceBase ?? throw new ArgumentNullException(nameof(imageSourceBase)); _item = item ?? throw new ArgumentNullException(nameof(item)); _requirement = requirement ?? throw new ArgumentNullException(nameof(requirement)); _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; }
/// <summary> /// Constructor /// </summary> /// <param name="location"> /// The location parent class. /// </param> /// <param name="map"> /// The map identity on which the location is represented. /// </param> /// <param name="x"> /// The X coordinate of the map location. /// </param> /// <param name="y"> /// The Y coordinate of the map location. /// </param> /// <param name="requirement"> /// The mode requirement for displaying this map location. /// </param> public MapLocation( LocationID locationID, MapID map, double x, double y, IRequirement requirement = null) { _locationID = locationID; Map = map; X = x; Y = y; Requirement = requirement ?? RequirementDictionary.Instance[RequirementType.NoRequirement]; LocationDictionary.Instance.LocationCreated += OnLocationCreated; }
/// <summary> /// Constructor /// </summary> /// <param name="count"> /// A 32-bit signed integer representing the number of keys that must be contained in the /// list of locations. /// </param> /// <param name="smallKeyLocations"> /// The list of dungeon item IDs that the number of small keys must be contained in. /// </param> /// <param name="bigKeyInLocations"> /// AS boolean representing whether the big key is contained in the list of locations. /// </param> /// <param name="children"> /// The list of child key layouts, if this layout is possible. /// </param> /// <param name="dungeon"> /// The dungeon parent class. /// </param> /// <param name="requirement"> /// The requirement for this key layout to be valid. /// </param> public SmallKeyLayout( IMode mode, int count, List <DungeonItemID> smallKeyLocations, bool bigKeyInLocations, List <IKeyLayout> children, IDungeon dungeon, IRequirement requirement) { _mode = mode; _count = count; _smallKeyLocations = smallKeyLocations; _bigKeyInLocations = bigKeyInLocations; _children = children; _dungeon = dungeon; _requirement = requirement; }
/// <summary> /// Constructor /// </summary> /// <param name="count"> /// A 32-bit signed integer representing the number of keys that must be contained in the /// list of locations. /// </param> /// <param name="smallKeyLocations"> /// The list of dungeon item IDs that the number of small keys must be contained in. /// </param> /// <param name="bigKeyInLocations"> /// AS boolean representing whether the big key is contained in the list of locations. /// </param> /// <param name="children"> /// The list of child key layouts, if this layout is possible. /// </param> /// <param name="dungeon"> /// The dungeon parent class. /// </param> /// <param name="requirement"> /// The requirement for this key layout to be valid. /// </param> public SmallKeyLayout( int count, List <DungeonItemID> smallKeyLocations, bool bigKeyInLocations, List <IKeyLayout> children, IDungeon dungeon, IRequirement requirement = null) { _count = count; _smallKeyLocations = smallKeyLocations ?? throw new ArgumentNullException(nameof(smallKeyLocations)); _bigKeyInLocations = bigKeyInLocations; _children = children ?? throw new ArgumentNullException(nameof(children)); _dungeon = dungeon ?? throw new ArgumentNullException(nameof(dungeon)); _requirement = requirement ?? RequirementDictionary.Instance[RequirementType.NoRequirement]; }
public IModelObject SatisfyRequirement(Guid requirementGuid) { IRequirement tgtRqmt = (IRequirement)m_requirements[requirementGuid]; if (!tgtRqmt.IsMet()) { return((IModelObject)tgtRqmt.Meet()); } else { return(null); } }
public void AddRequirement(IRequirement requirement) { if (requirement == null) { throw new ArgumentException("requirement cannot be null"); } if (_requirements.Any(x => x.Equals(requirement))) { throw new InvalidOperationException("requirement already exists"); } _requirements.Add(requirement); }
/// <summary> /// Combines this instance with an argument into single requirement. /// Performs argument-not-null check and throws ArgumentNullExcpetion if it is so. /// </summary> /// <param name="requirement">Requirement to combine the instance with.</param> /// <returns>Combined requirement instance whose is based on subrequirements evaluations</returns> public ICombinedRequirement <TChecked> Combine(IRequirement <TChecked> requirementToCombine) { if (requirementToCombine == null) { throw new ArgumentNullException(nameof(requirementToCombine)); } var combinedRequirementsList = requirements.ToList(); combinedRequirementsList.Add(requirementToCombine); var combinedRequirement = CreateCombinedRequirement(combinedRequirementsList); return(combinedRequirement); }
/// <summary> /// Constructor /// </summary> /// <param name="requirements"> /// The requirements dictionary. /// </param> /// <param name="undoRedoManager"> /// The undo/redo manager. /// </param> /// <param name="undoableFactory"> /// A factory for creating undoable actions. /// </param> /// <param name="imageSourceBase"> /// A string representing the image source base. /// </param> /// <param name="item"> /// An item that is to be represented by this control. /// </param> public SmallKeyLargeItemVM( IRequirementDictionary requirements, IUndoRedoManager undoRedoManager, IUndoableFactory undoableFactory, IItem item, string imageSourceBase) { _undoRedoManager = undoRedoManager; _undoableFactory = undoableFactory; _item = item; _requirement = requirements[RequirementType.GenericKeys]; _imageSourceBase = imageSourceBase; HandleClick = ReactiveCommand.Create <PointerReleasedEventArgs>(HandleClickImpl); _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; }
public void GetRequirementTest() { IRequirement requirement = Repository.GetRequirement(102); int id = requirement.Id; string name = requirement.Name; int credits = requirement.Credits; int minimumMarks = requirement.MinimumMark; int[] courses = requirement.Courses; Assert.AreEqual(102, id); Assert.AreEqual("Science", name); Assert.AreEqual(1, credits); Assert.AreEqual(50, minimumMarks); Assert.AreEqual(2, courses.ElementAt(0)); }
/// <summary> /// Constructor /// </summary> /// <param name="undoRedoManager"> /// The undo/redo manager. /// </param> /// <param name="undoableFactory"> /// A factory for creating undoable actions. /// </param> /// <param name="imageSourceBase"> /// A string representing the base image source. /// </param> /// <param name="item"> /// The item of the key to be represented. /// </param> /// <param name="requirement"> /// The requirement for displaying the control. /// </param> public SmallItemVM( IUndoRedoManager undoRedoManager, IUndoableFactory undoableFactory, IItem item, IRequirement requirement, string imageSourceBase) { _undoRedoManager = undoRedoManager; _undoableFactory = undoableFactory; _imageSourceBase = imageSourceBase; _item = item; _requirement = requirement; HandleClick = ReactiveCommand.Create <PointerReleasedEventArgs>(HandleClickImpl); _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; }
public List <ITask> Solve(IRequirement requirement) { List <ITask> solutions = new List <ITask> (); foreach (Type taskType in taskTypes) { if ((bool)taskType.GetMethod("Handles").Invoke(null, new IRequirement[1] { requirement })) { solutions.Add((ITask)taskType.GetMethod("CreateTask").Invoke(null, new IRequirement[1] { requirement })); } } return(solutions); }
/// <summary> /// Constructor /// </summary> /// <param name="undoRedoManager"> /// The undo/redo manager. /// </param> /// <param name="undoableFactory"> /// A factory for creating undoable actions. /// </param> /// <param name="dungeon"> /// The dungeon whose big keys are to be represented. /// </param> /// <param name="requirement"> /// The requirement for the control to be visible. /// </param> /// <param name="spacerRequirement"> /// The requirement for the control to take reserve space. /// </param> public BigKeySmallItemVM( IUndoRedoManager undoRedoManager, IUndoableFactory undoableFactory, IDungeon dungeon, IRequirement requirement, IRequirement spacerRequirement) { _undoRedoManager = undoRedoManager; _undoableFactory = undoableFactory; _item = dungeon.BigKeyItem ?? throw new ArgumentOutOfRangeException(nameof(dungeon)); _requirement = requirement; _spacerRequirement = spacerRequirement; HandleClick = ReactiveCommand.Create <PointerReleasedEventArgs>(HandleClickImpl); _item.PropertyChanged += OnItemChanged; _requirement.PropertyChanged += OnRequirementChanged; _spacerRequirement.PropertyChanged += OnRequirementChanged; }
/// <summary> /// Constructor /// </summary> /// <param name="name"> /// A string representing the name of the section. /// </param> /// <param name="bossPlacement"> /// The boss placement of this section. /// </param> /// <param name="prizePlacement"> /// The prize placement of this section. /// </param> /// <param name="autoTrackValue"> /// The section autotrack value. /// </param> /// <param name="requirement"> /// The requirement for this section to be visible. /// </param> /// <param name="alwaysClearable"> /// A boolean representing whether the section is always clearable (used for GT final). /// </param> public PrizeSection( string name, IBossPlacement bossPlacement, IPrizePlacement prizePlacement, IAutoTrackValue?autoTrackValue, IRequirement requirement, bool alwaysClearable = false) : base(name, bossPlacement, requirement) { _alwaysClearable = alwaysClearable; _autoTrackValue = autoTrackValue; PrizePlacement = prizePlacement ?? throw new ArgumentNullException(nameof(prizePlacement)); PropertyChanged += OnPropertyChanged; PrizePlacement.PropertyChanging += OnPrizeChanging; PrizePlacement.PropertyChanged += OnPrizeChanged; if (_autoTrackValue != null) { _autoTrackValue.PropertyChanged += OnAutoTrackValueChanged; } }
/// <summary> /// Constructor /// </summary> /// <param name="condition"> /// The condition for determining which value to use. /// </param> /// <param name="trueValue"> /// The value to be presented, if the condition is met. /// </param> /// <param name="falseValue"> /// The value to be presented, if the condition is not met. /// </param> public AutoTrackConditionalValue( IRequirement condition, IAutoTrackValue?trueValue, IAutoTrackValue?falseValue) { _condition = condition; _trueValue = trueValue; _falseValue = falseValue; _condition.PropertyChanged += OnRequirementChanged; if (_trueValue != null) { _trueValue.PropertyChanged += OnValueChanged; } if (_falseValue != null) { _falseValue.PropertyChanged += OnValueChanged; } }
public void AddRequirement(IRequirement requirement) { _requirements.Add(requirement); _requirements = _requirements.OrderBy(r => r.DeweySequence).ToList(); }
//--------------------------------------------------------------------- void IStandRankingMethod.AddRequirement(IRequirement requirement) { requirements.Add(requirement); }
public void RemoveRequirement(IRequirement requirement) { _requirements.Remove(requirement); }