Requirement#

What one task needs: Count slots on Task, each for a worker that satisfies every SkillMatch in Matches. Pass a list of requirements to SkillLayer.Slots, which turns each one into Slots. Create one with the constructor and set the other properties in an object initializer.

Declaration#

namespace Plen.Assign;

public sealed class Requirement : IDeepCloneable<Requirement>, IEquatable<Requirement>

Constructors#

Requirement(Id, Id, List<SkillMatch>)#

public Requirement(Id id, Id task, List<SkillMatch> matches)

Creates a requirement for one slot at Units = 1.0 with automatic binding (Count = 1, Assignments = null). It's the only constructor, so new Requirement { … } without arguments doesn't compile.

Properties#

Id#

public required Id Id { get; set; }

The requirement's slot ids become the ids of the assignments that fill them on Task. After those assignments are committed, the id stays tied to that task: reusing it for a requirement on another task throws.

Assignments#

public List<Id>? Assignments { get; set; }

A non-null list replaces automatic binding for this requirement. An assignment whose id is one of this requirement's slot ids keeps its slot. The other listed assignments take the remaining slots in list order, and slots left over stay empty. The list can't hold more entries than Count. Each entry must be an active assignment on Task, and a slot-id assignment of this requirement must be listed. For how binding works across all requirements of a task, see Binding existing assignments.

Methods#

DeepClone#

public Requirement DeepClone()

Returns a copy that shares no list or SkillMatch with this one.

Equals#

public bool Equals(Requirement? other)
public override bool Equals(object? obj)

Value equality over all six properties: lists element by element, double by ==. A null Assignments equals only another null, not []. GetHashCode is consistent with it.

ToString#

public override string ToString()

Returns a readable rendering of all properties, for logging.

SkillMatch#

One condition on a worker's skill: worker value <Op> Value. A skill the worker doesn't list counts as 0, so SkillMatch.NoMore("qa", 0) holds for every worker without the qa skill.

namespace Plen.Assign;

public sealed class SkillMatch : IDeepCloneable<SkillMatch>, IEquatable<SkillMatch>
{
    public required Id Skill { get; set; }
    public SkillOp Op { get; set; }
    public double Value { get; set; }

    public static SkillMatch AtLeast(Id skill, double value);
    public static SkillMatch NoMore(Id skill, double value);
    public static SkillMatch Equal(Id skill, double value);
}

The class has a parameterless constructor, so new SkillMatch { Skill = "backend" } gives worker value >= 1. DeepClone, Equals (all three properties, double by ==), GetHashCode and ToString work as on Requirement.

SkillOp#

The comparison a SkillMatch applies. All three are inclusive.

namespace Plen.Assign;

public enum SkillOp { AtLeast, NoMore, Equal }

Errors#

Requirements are validated by SkillLayer.Slots. It throws InputException with Kind = InputErrorKind.Validation and one of these paths for requirement i:

Example#

Two half-time slots for workers with backend grade 1 or higher:

using Plen;
using Plen.Assign;

var monday = Moment.FromYmdHm(2026, 8, 10, 8, 0) ?? throw new InvalidOperationException("invalid date");

var project = new Project();
project.Solve(new ProjectData
{
    Tasks = [new TaskData("api") { StartDate = monday, Duration = 2 }],
    Resources = [new ResourceData { Id = "ann" }, new ResourceData { Id = "bob" }, new ResourceData { Id = "cat" }],
}, new SolveOptions());

var pool = new Pool
{
    Workers =
    [
        new Worker { Resource = "ann", Skills = [new Skill { Id = "backend", Value = 2 }] },
        new Worker { Resource = "bob", Skills = [new Skill { Id = "backend" }] },
        new Worker { Resource = "cat" },
    ],
};

var requirement = new Requirement("be", "api", [SkillMatch.AtLeast("backend", 1)])
{
    Count = 2,
    Units = 0.5,
};

foreach (var slot in SkillLayer.Slots(project, pool, [requirement]))
{
    Console.WriteLine($"{slot.Id}: allowed [{string.Join(", ", slot.Allowed)}], value {slot.Value}");
}

Output:

be#1: allowed [ann, bob], value 0.5
be#2: allowed [ann, bob], value 0.5

Related#

• SkillLayer.Slots - the call that turns requirements into slots
• Pool - the workers the matches are checked against
• Slot - what each requirement produces
• Project.SuggestAssignments - fills the slots
• Skills and requirements - stating what each task needs