RenJuan/TASKPM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ItEr60S08CUAsignacionRecursosLimitantesItEr59S08: Several renames in order to show better its intent.

Browse source 
These clases are no longer just for gaps but for insertions in
general
This commit is contained in:
Óscar González Fernández 2010-06-27 14:40:05 +02:00
parent 6cb3d39329
commit 3330e07a30
5 changed files with 33 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationOnGap.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationAttempt.java
View file

@ -32,21 +32,21 @@ import org.navalplanner.business.planner.entities.SpecificDayAssignment;
import org.navalplanner.business.planner.entities.SpecificResourceAllocation;
import org.navalplanner.business.resources.entities.Resource;
public abstract class AllocationOnGap {
public abstract class AllocationAttempt {
public static AllocationOnGap invalidOn(Gap gap) {
return new InvalidAllocationOnGap(gap);
public static AllocationAttempt invalidOn(Gap gap) {
return new InvalidAllocationAttempt(gap);
}
public static AllocationOnGap validOn(Gap gap, DateAndHour start,
public static AllocationAttempt validOn(Gap gap, DateAndHour start,
DateAndHour endExclusive, int[] assignableHours) {
return new ValidAllocationOnGap(gap, start, endExclusive,
return new ValidAllocationAttempt(gap, start, endExclusive,
assignableHours);
}
private final Gap originalGap;
protected AllocationOnGap(Gap originalGap) {
protected AllocationAttempt(Gap originalGap) {
Validate.notNull(originalGap);
this.originalGap = originalGap;
}
@ -67,11 +67,11 @@ public abstract class AllocationOnGap {
}
}
class InvalidAllocationOnGap extends AllocationOnGap {
class InvalidAllocationAttempt extends AllocationAttempt {
private static final String INVALID_ALLOCATION_ON_GAP = "invalid allocation on gap";
InvalidAllocationOnGap(Gap originalGap) {
InvalidAllocationAttempt(Gap originalGap) {
super(originalGap);
}
@ -97,13 +97,13 @@ class InvalidAllocationOnGap extends AllocationOnGap {
}
}
class ValidAllocationOnGap extends AllocationOnGap {
class ValidAllocationAttempt extends AllocationAttempt {
private final DateAndHour start;
private final DateAndHour end;
private final int[] assignableHours;
public ValidAllocationOnGap(Gap gap, DateAndHour startInclusive,
public ValidAllocationAttempt(Gap gap, DateAndHour startInclusive,
DateAndHour endExclusive, int[] assignableHours) {
super(gap);
Validate.notNull(startInclusive);

18
navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/GapRequirements.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/InsertionRequirements.java
View file

@ -33,7 +33,7 @@ import org.navalplanner.business.resources.entities.Resource;
/**
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class GapRequirements {
public class InsertionRequirements {
private final LimitingResourceQueueElement element;
@ -41,11 +41,11 @@ public class GapRequirements {
private final DateAndHour earliestPossibleEnd;
public static GapRequirements forElement(
public static InsertionRequirements forElement(
LimitingResourceQueueElement element,
List<LimitingResourceQueueDependency> dependenciesAffectingStart,
List<LimitingResourceQueueDependency> dependenciesAffectingEnd) {
return new GapRequirements(element, calculateEarliestPossibleStart(
return new InsertionRequirements(element, calculateEarliestPossibleStart(
element, dependenciesAffectingStart),
calculateEarliestPossibleEnd(element, dependenciesAffectingEnd));
}
@ -80,7 +80,7 @@ public class GapRequirements {
return DateAndHour.from(LocalDate.fromDateFields(date));
}
private GapRequirements(LimitingResourceQueueElement element,
private InsertionRequirements(LimitingResourceQueueElement element,
DateAndHour earliestPossibleStart, DateAndHour earliestPossibleEnd) {
Validate.notNull(element);
Validate.notNull(earliestPossibleStart);
@ -97,10 +97,10 @@ public class GapRequirements {
.isAfter(gapEnd));
}
public AllocationOnGap guessValidity(GapOnQueue gapOnQueue) {
public AllocationAttempt guessValidity(GapOnQueue gapOnQueue) {
Gap gap = gapOnQueue.getGap();
if (!isPotentiallyValid(gap)) {
return AllocationOnGap.invalidOn(gap);
return AllocationAttempt.invalidOn(gap);
}
DateAndHour realStart = DateAndHour.Max(earliestPossibleStart, gap
.getStartTime());
@ -110,7 +110,7 @@ public class GapRequirements {
earliestPossibleEnd, element.getIntentedTotalHours());
int total = sum(hours);
if (total < element.getIntentedTotalHours()) {
return AllocationOnGap.invalidOn(gap);
return AllocationAttempt.invalidOn(gap);
} else if (total == element.getIntentedTotalHours()) {
return validAllocation(gap, realStart, hours);
} else {
@ -123,9 +123,9 @@ public class GapRequirements {
}
private AllocationOnGap validAllocation(Gap gap, DateAndHour realStart,
private AllocationAttempt validAllocation(Gap gap, DateAndHour realStart,
List<Integer> hours) {
return AllocationOnGap.validOn(gap, realStart, calculateEnd(realStart,
return AllocationAttempt.validOn(gap, realStart, calculateEnd(realStart,
hours), asArray(hours));
}

4
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/LimitingResourceQueue.java
View file

@ -29,7 +29,7 @@ import java.util.TreeSet;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.planner.limiting.entities.DateAndHour;
import org.navalplanner.business.planner.limiting.entities.Gap;
import org.navalplanner.business.planner.limiting.entities.GapRequirements;
import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
import org.navalplanner.business.planner.limiting.entities.Gap.GapOnQueue;
@ -105,7 +105,7 @@ public class LimitingResourceQueue extends BaseEntity {
* <code>requirements</code> ordered by start date
*/
public List<GapOnQueue> getGapsPotentiallyValidFor(
GapRequirements requirements) {
InsertionRequirements requirements) {
List<GapOnQueue> result = new ArrayList<GapOnQueue>();
for (GapOnQueue each : getGaps()) {
if (requirements.isPotentiallyValid(each.getGap())) {

14
navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/LimitingResourceQueueModel.java
View file

@ -52,10 +52,10 @@ import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueDAO;
import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueDependencyDAO;
import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueElementDAO;
import org.navalplanner.business.planner.limiting.entities.AllocationOnGap;
import org.navalplanner.business.planner.limiting.entities.AllocationAttempt;
import org.navalplanner.business.planner.limiting.entities.DateAndHour;
import org.navalplanner.business.planner.limiting.entities.Gap;
import org.navalplanner.business.planner.limiting.entities.GapRequirements;
import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceAllocator;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueDependency;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
@ -383,7 +383,7 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
List<LimitingResourceQueueElement> result = new ArrayList<LimitingResourceQueueElement>();
for (LimitingResourceQueueElement each : queuesState
.getInsertionsToBeDoneFor(externalQueueElement)) {
GapRequirements requirements = queuesState.getRequirementsFor(each);
InsertionRequirements requirements = queuesState.getRequirementsFor(each);
boolean inserted = insert(requirements);
if (!inserted) {
break;
@ -393,14 +393,14 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
return result;
}
private boolean insert(GapRequirements requirements) {
private boolean insert(InsertionRequirements requirements) {
List<GapOnQueue> potentiallyValidGapsFor = queuesState
.getPotentiallyValidGapsFor(requirements);
boolean generic = requirements.getElement().isGeneric();
for (GapOnQueue each : potentiallyValidGapsFor) {
for (GapOnQueue eachSubGap : getSubGaps(each, requirements
.getElement(), generic)) {
AllocationOnGap allocation = requirements
AllocationAttempt allocation = requirements
.guessValidity(eachSubGap);
if (allocation.isValid()) {
doAllocation(requirements, allocation, eachSubGap.getOriginQueue());
@ -419,8 +419,8 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
return Collections.singletonList(each);
}
private void doAllocation(GapRequirements requirements,
AllocationOnGap allocation, LimitingResourceQueue queue) {
private void doAllocation(InsertionRequirements requirements,
AllocationAttempt allocation, LimitingResourceQueue queue) {
Resource resource = queue.getResource();
ResourceAllocation<?> resourceAllocation = requirements
.getElement().getResourceAllocation();

10
navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueuesState.java
View file

@ -37,7 +37,7 @@ import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.planner.entities.GenericResourceAllocation;
import org.navalplanner.business.planner.entities.ResourceAllocation;
import org.navalplanner.business.planner.entities.SpecificResourceAllocation;
import org.navalplanner.business.planner.limiting.entities.GapRequirements;
import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueDependency;
import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
import org.navalplanner.business.planner.limiting.entities.Gap.GapOnQueue;
@ -207,12 +207,12 @@ public class QueuesState {
throw new RuntimeException("unexpected type of: " + resourceAllocation);
}
public GapRequirements getRequirementsFor(
public InsertionRequirements getRequirementsFor(
LimitingResourceQueueElement element) {
List<LimitingResourceQueueDependency> dependenciesStart = new ArrayList<LimitingResourceQueueDependency>();
List<LimitingResourceQueueDependency> dependenciesEnd = new ArrayList<LimitingResourceQueueDependency>();
fillIncoming(element, dependenciesStart, dependenciesEnd);
return GapRequirements.forElement(getEquivalent(element),
return InsertionRequirements.forElement(getEquivalent(element),
dependenciesStart, dependenciesEnd);
}
@ -253,7 +253,7 @@ public class QueuesState {
* ordered by start date
*/
public List<GapOnQueue> getPotentiallyValidGapsFor(
GapRequirements requirements) {
InsertionRequirements requirements) {
List<LimitingResourceQueue> assignableQueues = getAssignableQueues(requirements
.getElement());
List<List<GapOnQueue>> allGaps = gapsFor(assignableQueues, requirements);
@ -262,7 +262,7 @@ public class QueuesState {
private List<List<GapOnQueue>> gapsFor(
List<LimitingResourceQueue> assignableQueues,
GapRequirements requirements) {
InsertionRequirements requirements) {
List<List<GapOnQueue>> result = new ArrayList<List<GapOnQueue>>();
for (LimitingResourceQueue each : assignableQueues) {
result.add(each.getGapsPotentiallyValidFor(requirements));