TaskImpl.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.ganttproject.task |
 |
 |
GanttProject |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LINE_COMMENT | Number of line comments |  |
| DECL_COMMENTS | Comments in declarations | |
| FUNCTIONS | Number of function declarations | |
| RETURNS | Number of return points from functions | |
| CYCLOMATIC | Cyclomatic complexity | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| BLOCKS | Number of blocks | |
| EXITS | Procedure exits | |
| LOC | Lines of code | |
| SIZE | Size of the file in bytes | |
| ELOC | Effective lines of code | |
| OPERATORS | Number of operators | |
| LOGICAL_LINES | Number of statements | |
| PROGRAM_LENGTH | Halstead program length | |
| LINES | Number of lines in the source file | |
| PARAMS | Number of formal parameter declarations | |
| COMPARISONS | Number of comparison operators | |
| EXEC_COMMENTS | Comments in executable code | |
| OPERANDS | Number of operands | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0171 | JAVA0171 Unused local variable | |
| JAVA0137 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0096 | JAVA0096 Field in nested class hides outer field | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0144 | JAVA0144 Line exceeds maximum M characters | |
| COMMENTS | Comment lines | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0068 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0177 | JAVA0177 Variable declaration missing initializer | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0032 | JAVA0032 Switch statement missing default | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0285 | JAVA0285 Dereference of potentially null variable | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0265 | JAVA0265 Use of Throwable.printStackTrace() | |
| LOOPS | Number of loops | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0267 | JAVA0267 Use of System.err | |
| JAVA0130 | JAVA0130 Non-static method does not use instance fields | |
| DOC_COMMENT | Number of javadoc comment lines | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
package net.sourceforge.ganttproject.task;
import java.awt.Color;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.lang.Long;
import java.math.BigDecimal;
import net.sourceforge.ganttproject.GanttCalendar;
import net.sourceforge.ganttproject.GanttTaskRelationship;
import net.sourceforge.ganttproject.calendar.AlwaysWorkingTimeCalendarImpl;
import net.sourceforge.ganttproject.calendar.GPCalendar;
import net.sourceforge.ganttproject.calendar.GPCalendarActivity;
import net.sourceforge.ganttproject.shape.ShapePaint;
import net.sourceforge.ganttproject.task.algorithm.AlgorithmCollection;
import net.sourceforge.ganttproject.task.dependency.TaskDependencyException;
import net.sourceforge.ganttproject.task.dependency.TaskDependencySlice;
import net.sourceforge.ganttproject.task.dependency.TaskDependencySliceAsDependant;
import net.sourceforge.ganttproject.task.dependency.TaskDependencySliceAsDependee;
import net.sourceforge.ganttproject.task.dependency.TaskDependencySliceImpl;
import net.sourceforge.ganttproject.task.hierarchy.TaskHierarchyItem;
//import net.sourceforge.ganttproject.time.TimeInterval;
import net.sourceforge.ganttproject.time.TimeInterval;
import net.sourceforge.ganttproject.time.TimeUnit;
/**
* Created by IntelliJ IDEA.
*
* @author bard Date: 31.01.2004
*/
public class TaskImpl implements Task {
private int myID;
private final TaskManagerImpl myManager;
private String myName;
// Added LaboPM
private TaskPrice myPrice = new TaskPrice(this);
private String myWebLink = new String("http://");
private boolean isMilestone;
boolean isProjectTask;
private int myPriority;
private GanttCalendar myStart;
private GanttCalendar myEnd;
private GanttCalendar myThird;
private int myThirdDateConstraint;
private int myCompletionPercentage;
private TaskLength myLength;
private List myActivities = new ArrayList();
// private boolean isStartFixed;
// private boolean isFinishFixed;
private boolean bExpand;
// private final TaskDependencyCollection myDependencies = new
// TaskDependencyCollectionImpl();
private ResourceAssignmentCollectionImpl myAssignments;
private TaskDependencySlice myDependencySlice;
private TaskDependencySlice myDependencySliceAsDependant;
private TaskDependencySlice myDependencySliceAsDependee;
private boolean myEventsEnabled;
private final TaskHierarchyItem myTaskHierarchyItem;
private ShapePaint myShape;
private Color myColor;
private String myNotes;
private MutatorImpl myMutator;
private final CustomColumnsValues customValues;
private boolean critical;
private TaskCategory taskCategory;
public final static int NONE = 0;
public final static int EARLIESTBEGIN = 1;
protected TaskImpl(TaskManager taskManager, int taskID) {
myManager = (TaskManagerImpl) taskManager;
if (taskID == -1) {
myID = myManager.getMaxID();
myManager.increaseMaxID();
} else {
if (myManager.getTask(taskID) != null) {
throw new IllegalArgumentException("There is a task with ID="
+ taskID + " already");
}
myID = taskID;
}
myAssignments = new ResourceAssignmentCollectionImpl(this, myManager
.getConfig().getResourceManager());
myDependencySlice = new TaskDependencySliceImpl(this, myManager
.getDependencyCollection());
myDependencySliceAsDependant = new TaskDependencySliceAsDependant(this,
myManager.getDependencyCollection());
myDependencySliceAsDependee = new TaskDependencySliceAsDependee(this,
myManager.getDependencyCollection());
myPriority = 1;
myTaskHierarchyItem = myManager.getHierarchyManager().createItem(this);
myNotes = "";
bExpand = true;
myColor = null;
customValues = new CustomColumnsValues();
}
protected TaskImpl(TaskImpl copy, boolean isUnplugged) {
myManager = copy.myManager;
if (!isUnplugged) {
myTaskHierarchyItem = myManager.getHierarchyManager().createItem(
this);
} else {
myTaskHierarchyItem = null;
}
myAssignments = new ResourceAssignmentCollectionImpl(this, myManager
.getConfig().getResourceManager());
myAssignments.importData(copy.getAssignmentCollection());
myID = copy.myID;
myName = copy.myName;
myWebLink = copy.myWebLink;
isMilestone = copy.isMilestone;
isProjectTask = copy.isProjectTask;
myPriority = copy.myPriority;
myStart = copy.myStart;
myEnd = copy.myEnd;
myThird = copy.myThird;
myThirdDateConstraint = copy.myThirdDateConstraint;
myCompletionPercentage = copy.myCompletionPercentage;
myLength = copy.myLength;
myShape = copy.myShape;
myColor = copy.myColor;
myNotes = copy.myNotes;
bExpand = copy.bExpand;
//
myDependencySlice = new TaskDependencySliceImpl(this, myManager
.getDependencyCollection());
myDependencySliceAsDependant = new TaskDependencySliceAsDependant(this,
myManager.getDependencyCollection());
myDependencySliceAsDependee = new TaskDependencySliceAsDependee(this,
myManager.getDependencyCollection());
customValues = (CustomColumnsValues) copy.getCustomValues().clone();
recalculateActivities();
}
public Task unpluggedClone() {
TaskImpl result = new TaskImpl(this, true) {
public boolean isSupertask() {
return false;
}
};
return result;
}
public TaskMutator createMutator() {
if (myMutator != null) {
throw new RuntimeException("Two mutators have been requested for task="+getName(),
myException);
}
myMutator = new MutatorImpl();
myException = new Exception();
return myMutator;
}
// public TaskMutator createMutatorFixingDuration() {
// if (myMutator != null) {
// throw new RuntimeException("Two mutators have been requested for task="+getName(),
// myException);
// }
// myMutator = new MutatorImpl() {
// @Override
// public void setStart(GanttCalendar start) {
// super.setStart(start);
// TaskImpl.this.myEnd = null;
// }
//
// @Override
// public void setEnd(GanttCalendar end) {
// final Date newEndDate = end.getTime();
// final Date newStartDate = shiftDate(newEndDate, getDuration().getTimeUnit(), -getDuration().getLength(), myManager.getCalendar());
// setStart(new GanttCalendar(newStartDate));
// }
//
// };
// myException = new Exception();
// return myMutator;
// }
private Exception myException;
// main properties
public int getTaskID() {
return myID;
}
public String getName() {
return myName;
}
public String getWebLink() {
return myWebLink;
}
public boolean isMilestone() {
return isMilestone;
}
public int getPriority() {
return myPriority;
}
/**
* Returns the price
* Added LaboPM
*/
public TaskPrice getPrice() {
if (isSupertask())
return nestedPriceSum();
return myPrice;
}
/**
* Returns the sum of nested tasks prices.
* @return
*/
private TaskPrice nestedPriceSum()
{
BigDecimal sum = BigDecimal.valueOf(0);
for(Task nt : myManager.getTaskHierarchy().getNestedTasks(this))
sum = sum.add(nt.getPrice().getPrice());
TaskPrice ret = new TaskPrice(null);
ret.setIsAuto(false);
ret.setPrice(sum);
return ret;
}
public TaskCategory getTaskCategory(){
return this.taskCategory;
}
public void setTaskCategory(TaskCategory category){
this.taskCategory = category;
}
public GanttCalendar getStart() {
if (myMutator != null
&& myMutator.myIsolationLevel == TaskMutator.READ_UNCOMMITED) {
return myMutator.getStart();
} else {
return myStart;
}
}
public GanttCalendar getEnd() {
if (isMilestone()) {
return getStart();
}
GanttCalendar result = null;
if (myMutator != null
&& myMutator.myIsolationLevel == TaskMutator.READ_UNCOMMITED) {
result = myMutator.getEnd();
}
if (result==null) {
if (myEnd == null) {
myEnd = calculateEnd(getStart(), getDuration());
}
result = myEnd;
}
return result;
}
GanttCalendar calculateEnd(GanttCalendar start, TaskLength duration) {
GanttCalendar result = start.Clone();
Date newEnd = shiftDate(result.getTime(), duration.getTimeUnit(), duration.getLength());
result.setTime(newEnd);
return result;
}
public GanttCalendar getThird() {
if (myMutator != null
&& myMutator.myIsolationLevel == TaskMutator.READ_UNCOMMITED) {
return myMutator.getThird();
} else {
return myThird;
}
}
public int getThirdDateConstraint() {
return myThirdDateConstraint;
}
public TaskActivity[] getActivities() {
List activities = myMutator == null ? null : myMutator.getActivities();
if (activities == null) {
activities = myActivities;
}
return (TaskActivity[]) activities.toArray(new TaskActivity[activities
.size()]);
}
public TaskLength getDuration() {
if (isMilestone()) {
return myManager.getZeroLength();
}
return (myMutator != null && myMutator.myIsolationLevel == TaskMutator.READ_UNCOMMITED) ? myMutator
.getDuration()
: myLength;
}
public int getCompletionPercentage() {
return (myMutator != null && myMutator.myIsolationLevel == TaskMutator.READ_UNCOMMITED) ? myMutator
.getCompletionPercentage()
: myCompletionPercentage;
}
public boolean getExpand() {
return bExpand;
}
public ShapePaint getShape() {
return myShape;
}
public Color getColor() {
Color result = null;
if(this.taskCategory != null){
result = this.taskCategory.getColor();
}
if (result == null) {
if (isMilestone() || getNestedTasks().length > 0) {
result = Color.BLACK;
} else {
result = myManager.getConfig().getDefaultColor();
}
}
return result;
}
public String getNotes() {
return myNotes;
}
public GanttTaskRelationship[] getPredecessors() {
return new GanttTaskRelationship[0]; // To change body of implemented
// methods use Options | File
// Templates.
}
public GanttTaskRelationship[] getSuccessors() {
return new GanttTaskRelationship[0]; // To change body of implemented
// methods use Options | File
// Templates.
}
public ResourceAssignment[] getAssignments() {
return myAssignments.getAssignments();
}
public ResourceAssignmentCollection getAssignmentCollection() {
return myAssignments;
}
//
public Task getSupertask() {
TaskHierarchyItem container = myTaskHierarchyItem.getContainerItem();
return container.getTask();
}
public Task[] getNestedTasks() {
TaskHierarchyItem[] nestedItems = myTaskHierarchyItem.getNestedItems();
Task[] result = new Task[nestedItems.length];
for (int i = 0; i < nestedItems.length; i++) {
result[i] = nestedItems[i].getTask();
}
return result;
}
public void move(Task targetSupertask) {
move(targetSupertask, 0);
}
public void move(Task targetSupertask, int childIndex) {
TaskImpl supertaskImpl = (TaskImpl) targetSupertask;
TaskHierarchyItem targetItem = supertaskImpl.myTaskHierarchyItem;
myTaskHierarchyItem.delete();
targetItem.addNestedItem(myTaskHierarchyItem, childIndex);
myManager.onTaskMoved(this);
}
public void delete() {
getDependencies().clear();
getAssignmentCollection().clear();
}
public TaskDependencySlice getDependencies() {
return myDependencySlice;
}
public TaskDependencySlice getDependenciesAsDependant() {
return myDependencySliceAsDependant;
}
public TaskDependencySlice getDependenciesAsDependee() {
return myDependencySliceAsDependee;
}
public TaskManager getManager() {
return myManager;
}
// TODO: remove this hack. ID must never be changed
protected void setTaskIDHack(int taskID) {
myID = taskID;
}
private static interface EventSender {
void enable();
void fireEvent();
}
private class ProgressEventSender implements EventSender {
private boolean myEnabled;
public void fireEvent() {
if (myEnabled) {
myManager.fireTaskProgressChanged(TaskImpl.this);
}
myEnabled = false;
}
public void enable() {
myEnabled = true;
}
}
private class PropertiesEventSender implements EventSender {
private boolean myEnabled;
public void fireEvent() {
if (myEnabled) {
myManager.fireTaskPropertiesChanged(TaskImpl.this);
}
myEnabled = false;
}
public void enable() {
myEnabled = true;
}
}
private static class FieldChange {
String myFieldName;
Object myFieldValue;
Object myOldValue;
EventSender myEventSender;
void setValue(Object newValue) {
myFieldValue = newValue;
myEventSender.enable();
}
public void setOldValue(Object oldValue) {
myOldValue = oldValue;
}
}
private static class DurationChange extends FieldChange {
Date getCachedDate(int length) {
if (myDates == null) {
return null;
}
int index = length - myMinLength;
if (index < 0 || index >= myDates.size()) {
return null;
}
return (Date) myDates.get(index);
}
void cacheDate(Date date, int length) {
if (myDates == null) {
myDates = new ArrayList();
}
int index = length - myMinLength;
while (index <= -1) {
myDates.add(0, null);
index++;
}
while (index > myDates.size()) {
myDates.add(null);
}
if (index == -1) {
myDates.add(0, date);
} else if (index == myDates.size()) {
myDates.add(date);
} else {
myDates.set(index, date);
}
}
private int myMinLength = 0;
private List myDates;
}
private class MutatorImpl implements TaskMutator {
private EventSender myPropertiesEventSender = new PropertiesEventSender();
private EventSender myProgressEventSender = new ProgressEventSender();
private FieldChange myCompletionPercentageChange;
private FieldChange myStartChange;
private FieldChange myEndChange;
private FieldChange myThirdChange;
private DurationChange myDurationChange;
private List myActivities;
private final List<Runnable> myCommands = new ArrayList<Runnable>();
private int myIsolationLevel;
public void rollback() {
TaskImpl.this.myMutator = null;
}
public void commit() {
try {
boolean fireChanges = false;
if (myStartChange != null) {
GanttCalendar start = getStart();
TaskImpl.this.setStart(start);
}
if (myDurationChange != null) {
TaskLength duration = getDuration();
TaskImpl.this.setDuration(duration);
myEndChange = null;
}
if (myCompletionPercentageChange != null) {
int newValue = getCompletionPercentage();
TaskImpl.this.setCompletionPercentage(newValue);
}
if (myEndChange != null) {
GanttCalendar end = getEnd();
if (end.getTime().compareTo(TaskImpl.this.getStart().getTime())>0) {
TaskImpl.this.setEnd(end);
}
}
if (myThirdChange != null) {
GanttCalendar third = getThird();
TaskImpl.this.setThirdDate(third);
}
for (int i = 0; i < myCommands.size(); i++) {
Runnable next = (Runnable) myCommands.get(i);
next.run();
}
myCommands.clear();
myPropertiesEventSender.fireEvent();
myProgressEventSender.fireEvent();
} finally {
TaskImpl.this.myMutator = null;
}
if (myStartChange!=null && TaskImpl.this.isSupertask()) {
TaskImpl.this.adjustNestedTasks();
}
if ((myStartChange!=null || myEndChange!=null || myDurationChange!=null) && areEventsEnabled()) {
GanttCalendar oldStart = (GanttCalendar) (myStartChange==null ? TaskImpl.this.getStart() : myStartChange.myOldValue);
GanttCalendar oldEnd = (GanttCalendar) (myEndChange==null ? TaskImpl.this.getEnd() : myEndChange.myOldValue);
myManager.fireTaskScheduleChanged(TaskImpl.this, oldStart, oldEnd);
}
}
public GanttCalendar getThird() {
return myThirdChange == null ? TaskImpl.this.myThird
: (GanttCalendar) myThirdChange.myFieldValue;
}
public List getActivities() {
if (myActivities == null && (myStartChange != null)
|| (myDurationChange != null)) {
myActivities = new ArrayList();
TaskImpl.this.recalculateActivities(myActivities, getStart()
.getTime(), TaskImpl.this.getEnd().getTime());
}
return myActivities;
}
/**
* Set the price
* Added LaboPM
*/
public void setCost(final TaskPrice price)
{
myCommands.add(new Runnable() {
public void run() {
price.setTask(TaskImpl.this);
TaskImpl.this.setCost(price);
}
});
}
public void setName(final String name) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setName(name);
}
});
}
public void setProjectTask(final boolean projectTask) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setProjectTask(projectTask);
}
});
}
public void setMilestone(final boolean milestone) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setMilestone(milestone);
}
});
}
public void setPriority(final int priority) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setPriority(priority);
}
});
}
public void setStart(final GanttCalendar start) {
assert start!=null;
GanttCalendar currentStart = getStart();
if (currentStart!=null && start.equals(currentStart)) {
return;
}
if (myStartChange == null) {
myStartChange = new FieldChange();
myStartChange.myEventSender = myPropertiesEventSender;
}
myStartChange.setOldValue(TaskImpl.this.myStart);
myStartChange.setValue(start);
myActivities = null;
}
public void setEnd(final GanttCalendar end) {
if (myEndChange == null) {
myEndChange = new FieldChange();
myEndChange.myEventSender = myPropertiesEventSender;
}
myEndChange.setOldValue(TaskImpl.this.myEnd);
myEndChange.setValue(end);
myActivities = null;
}
public void setThird(final GanttCalendar third,
final int thirdDateConstraint) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setThirdDateConstraint(thirdDateConstraint);
}
});
if (myThirdChange == null) {
myThirdChange = new FieldChange();
myThirdChange.myEventSender = myPropertiesEventSender;
}
myThirdChange.setValue(third);
myActivities = null;
}
public void setDuration(final TaskLength length) {
if (myDurationChange == null) {
myDurationChange = new DurationChange();
myDurationChange.myEventSender = myPropertiesEventSender;
myDurationChange.setValue(length);
} else {
TaskLength currentLength = (TaskLength) myDurationChange.myFieldValue;
if (currentLength.getLength() - length.getLength() == 0) {
return;
}
}
myDurationChange.setValue(length);
TaskImpl.this.myEnd = null;
if (myEndChange==null) {
// Date shifted = TaskImpl.this.shiftDate(getStart().getTime(), length
// .getTimeUnit(), length.getLength());
// GanttCalendar newEnd = new GanttCalendar(shifted);
// setEnd(newEnd);
}
else {
assert myStartChange==null : "If both duration and end date are changed then start date must not be";
Date shifted = TaskImpl.this.shiftDate(getEnd().getTime(), length
.getTimeUnit(), -length.getLength());
setStart(new GanttCalendar(shifted));
}
myActivities = null;
}
public void setExpand(final boolean expand) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setExpand(expand);
}
});
}
public void setCompletionPercentage(final int percentage) {
if (myCompletionPercentageChange == null) {
myCompletionPercentageChange = new FieldChange();
myCompletionPercentageChange.myEventSender = myProgressEventSender;
}
myCompletionPercentageChange.setValue(new Integer(percentage));
}
// public void setStartFixed(final boolean isFixed) {
// myCommands.add(new Runnable() {
// public void run() {
// TaskImpl.this.setStartFixed(isFixed);
// }
// });
// }
//
// public void setFinishFixed(final boolean isFixed) {
// myCommands.add(new Runnable() {
// public void run() {
// TaskImpl.this.setFinishFixed(isFixed);
// }
// });
//
// }
public void setCritical(final boolean critical) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setCritical(critical);
}
});
}
public void setShape(final ShapePaint shape) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setShape(shape);
}
});
}
public void setColor(final Color color) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setColor(color);
}
});
}
public void setNotes(final String notes) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.setNotes(notes);
}
});
}
public void addNotes(final String notes) {
myCommands.add(new Runnable() {
public void run() {
TaskImpl.this.addNotes(notes);
}
});
}
public int getCompletionPercentage() {
return myCompletionPercentageChange == null ? TaskImpl.this.myCompletionPercentage
: ((Integer) myCompletionPercentageChange.myFieldValue)
.intValue();
}
GanttCalendar getStart() {
return myStartChange == null ? TaskImpl.this.myStart
: (GanttCalendar) myStartChange.myFieldValue;
}
GanttCalendar getEnd() {
return myEndChange == null ? null
: (GanttCalendar) myEndChange.myFieldValue;
}
TaskLength getDuration() {
return myDurationChange == null ? TaskImpl.this.myLength
: (TaskLength) myDurationChange.myFieldValue;
}
public void shift(float unitCount) {
Task result = getPrecomputedShift(unitCount);
if (result == null) {
result = TaskImpl.this.shift(unitCount);
cachePrecomputedShift(result, unitCount);
}
// System.err.println("[MutatorImpl] shift(): result="+result);
setStart(result.getStart());
setDuration(result.getDuration());
setEnd(result.getEnd());
}
public void shift(TaskLength shift) {
TaskImpl.this.shift(shift);
}
public TimeInterval createRegularTimeInterval() {
return new RegularTimeIntervalImpl();
}
public TimeInterval createFixedDurationTimeInterval() {
return new FixedDurationTimeIntervalImpl();
}
public void setIsolationLevel(int level) {
myIsolationLevel = level;
}
private void cachePrecomputedShift(Task result, float unitCount) {
}
private Task getPrecomputedShift(float unitCount) {
return null;
}
private TaskInfo myTaskInfo;
public TaskInfo getTaskInfo() {
return myTaskInfo;
}
public void setTaskInfo(TaskInfo taskInfo) {
myTaskInfo = taskInfo;
}
private class RegularTimeIntervalImpl implements TimeInterval {
public Date getStartDate() {
return MutatorImpl.this.getStart().getTime();
}
public void setDuration(TimeUnit timeUnit, long duration) {
MutatorImpl.this.setDuration(myManager.createLength(timeUnit, duration));
}
public void setEndDate(Date endDate) {
MutatorImpl.this.setEnd(new GanttCalendar(endDate));
}
public void setStartDate(Date startDate) {
MutatorImpl.this.setStart(new GanttCalendar(startDate));
}
public float getLength(TimeUnit unit) {
return MutatorImpl.this.getDuration().getLength(unit);
}
public long getLength() {
return MutatorImpl.this.getDuration().getLength();
}
public TimeUnit getTimeUnit() {
return MutatorImpl.this.getDuration().getTimeUnit();
}
public float getValue() {
return MutatorImpl.this.getDuration().getValue();
}
}
private class FixedDurationTimeIntervalImpl implements TimeInterval {
public Date getStartDate() {
return MutatorImpl.this.getStart().getTime();
}
public void setDuration(TimeUnit timeUnit, long duration) {
MutatorImpl.this.setDuration(myManager.createLength(timeUnit, duration));
}
public void setEndDate(Date endDate) {
final Date newStartDate = shiftDate(endDate, getDuration().getTimeUnit(), -getDuration().getLength(), myManager.getCalendar());
setStartDate(newStartDate);
}
public void setStartDate(Date startDate) {
MutatorImpl.this.setStart(new GanttCalendar(startDate));
TaskImpl.this.myEnd = null;
}
public float getLength(TimeUnit unit) {
return MutatorImpl.this.getDuration().getLength(unit);
}
public long getLength() {
return MutatorImpl.this.getDuration().getLength();
}
public TimeUnit getTimeUnit() {
return MutatorImpl.this.getDuration().getTimeUnit();
}
public float getValue() {
return MutatorImpl.this.getDuration().getValue();
}
}
}
/**
* Added LaboPM
*/
public void setCost(TaskPrice price)
{
myPrice = price;
}
public void setName(String name) {
myName = name;
}
public void setWebLink(String webLink) {
myWebLink = webLink;
}
public void setMilestone(boolean milestone) {
isMilestone = milestone;
myEnd = null;
recalculateActivities();
}
public void setPriority(int priority) {
myPriority = priority;
}
public void setStart(GanttCalendar start) {
System.err.println("TaskImpl.setStart: "+start);
Date closestWorkingStart = myManager.findClosestWorkingTime(start
.getTime());
start.setTime(closestWorkingStart);
GanttCalendar oldStart = myStart == null ? null : myStart.Clone();
myStart = start;
GanttCalendar oldEnd = getEnd();
//if (myID>=0) {
recalculateActivities();
//}
}
private void adjustNestedTasks() {
try {
assert myManager!=null;
AlgorithmCollection algorithmCollection = myManager.getAlgorithmCollection();
if (algorithmCollection!=null) {
algorithmCollection.getAdjustTaskBoundsAlgorithm().adjustNestedTasks(this);
}
} catch (TaskDependencyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public boolean isSupertask() {
return myManager.getTaskHierarchy().hasNestedTasks(this);
}
public void setEnd(GanttCalendar end) {
GanttCalendar oldFinish = myEnd == null ? null : myEnd.Clone();
myEnd = end;
recalculateActivities();
// System.err.println("we have "+myActivities.size()+" activities");
// if (areEventsEnabled()) {
// myManager.fireTaskScheduleChanged(this, myStart.Clone(), oldFinish);
// }
}
public void setThirdDate(GanttCalendar third) {
GanttCalendar oldThird = myThird == null ? null : myThird.Clone();
myThird = third;
// recalculateActivities();
// if (areEventsEnabled()) {
// myManager.fireTaskScheduleChanged(this, myThird.Clone(), oldThird);
// }
}
public void setThirdDateConstraint(int thirdDateConstraint) {
myThirdDateConstraint = thirdDateConstraint;
}
public void shift(TaskLength shift) {
float unitCount = shift.getLength(myLength.getTimeUnit());
if (unitCount != 0f) {
Task resultTask = shift(unitCount);
GanttCalendar oldStart = myStart;
GanttCalendar oldEnd = myEnd;
myStart = resultTask.getStart();
myLength = resultTask.getDuration();
myEnd = resultTask.getEnd();
if (areEventsEnabled()) {
myManager.fireTaskScheduleChanged(this, oldStart, oldEnd);
}
recalculateActivities();
}
}
public Task shift(float unitCount) {
Task clone = unpluggedClone();
if (unitCount > 0) {
TaskLength length = myManager.createLength(myLength.getTimeUnit(),
unitCount);
// clone.setDuration(length);
Date shiftedDate = shiftDate(myStart.getTime(), length
.getTimeUnit(), length.getLength(), RESTLESS_CALENDAR);
clone.setStart(new GanttCalendar(shiftedDate));
clone.setDuration(myLength);
} else {
Date newStart = shiftDate(clone.getStart().getTime(), clone
.getDuration().getTimeUnit(), (long) unitCount);
clone.setStart(new GanttCalendar(newStart));
clone.setDuration(myLength);
}
return clone;
}
public void setDuration(TaskLength length) {
assert length.getLength()>0;
//GanttCalendar oldFinish = myEnd == null ? null : myEnd.Clone();
myLength = length;
myEnd=null;
// Date newEndDate = shiftDate(myStart.getTime(),
// length.getTimeUnit(), length.getLength());
//myEnd = new GanttCalendar(newEndDate);
// myEnd = myStart.newAdd((int) length.getLength());
recalculateActivities();
// if (areEventsEnabled()) {
// myManager.fireTaskScheduleChanged(this, myStart.Clone(),
// oldFinish);
// }
}
private Date shiftDate(Date input, TimeUnit timeUnit, long length) {
return shiftDate(input, timeUnit, length, myManager.getConfig()
.getCalendar());
}
private Date shiftDate(Date input, TimeUnit timeUnit, long length,
GPCalendar calendar) {
List activities = calendar.getActivities(input, timeUnit, length);
if (activities.isEmpty()) {
throw new RuntimeException("Can't set length=" + length + " start="
+ input);
}
Date result;
if (length >= 0) {
GPCalendarActivity lastActivity = (GPCalendarActivity) activities
.get(activities.size() - 1);
result = lastActivity.getEnd();
} else {
GPCalendarActivity firstActivity = (GPCalendarActivity) activities
.get(0);
result = firstActivity.getStart();
}
return result;
}
public TaskLength translateDuration(TaskLength duration) {
return myManager.createLength(myLength.getTimeUnit(),
translateDurationValue(duration));
}
private float translateDurationValue(TaskLength duration) {
if (myLength.getTimeUnit().equals(duration.getTimeUnit())) {
return duration.getValue();
}
if (myLength.getTimeUnit().isConstructedFrom(duration.getTimeUnit())) {
return duration.getValue()
/ myLength.getTimeUnit().getAtomCount(
duration.getTimeUnit());
}
if (duration.getTimeUnit().isConstructedFrom(myLength.getTimeUnit())) {
return duration.getValue()
* duration.getTimeUnit().getAtomCount(
myLength.getTimeUnit());
}
throw new RuntimeException("Can't transalte duration=" + duration
+ " into units=" + myLength.getTimeUnit());
}
private void recalculateActivities() {
if (myLength == null || myManager == null) {
return;
}
// if (getDuration().getLength()==0) {
// return;
// }
recalculateActivities(myActivities, myStart.getTime(), getEnd().getTime());
int length = 0;
for (int i = 0; i < myActivities.size(); i++) {
TaskActivity next = (TaskActivity) myActivities.get(i);
if (next.getIntensity() > 0) {
length += next.getDuration().getLength(
getDuration().getTimeUnit());
}
}
myLength = getManager().createLength(myLength.getTimeUnit(), length);
}
private void recalculateActivities(List output, Date startDate, Date endDate) {
GPCalendar calendar = myManager.getConfig().getCalendar();
output.clear();
if (isMilestone()) {
output.add(new TaskActivityImpl(this, startDate, endDate));
return;
}
List activities = calendar.getActivities(startDate, endDate, myLength.getTimeUnit());
for (int i = 0; i < activities.size(); i++) {
GPCalendarActivity nextCalendarActivity = (GPCalendarActivity) activities
.get(i);
TaskActivityImpl nextTaskActivity;
if (nextCalendarActivity.isWorkingTime()) {
nextTaskActivity = new TaskActivityImpl(this,
nextCalendarActivity.getStart(), nextCalendarActivity
.getEnd());
} else if (i > 0 && i + 1 < activities.size()) {
nextTaskActivity = new TaskActivityImpl(this,
nextCalendarActivity.getStart(), nextCalendarActivity
.getEnd(), 0);
} else {
continue;
}
output.add(nextTaskActivity);
}
}
public void setCompletionPercentage(int percentage) {
int oldPercentage = myCompletionPercentage;
myCompletionPercentage = percentage;
if (oldPercentage != myCompletionPercentage) {
EventSender progressEventSender = new ProgressEventSender();
progressEventSender.enable();
progressEventSender.fireEvent();
}
}
// public void setStartFixed(boolean isFixed) {
// isStartFixed = isFixed;
// }
// public void setFinishFixed(boolean isFixed) {
// isFinishFixed = isFixed;
// }
public void setShape(ShapePaint shape) {
myShape = shape;
}
public void setColor(Color color) {
myColor = color;
}
public void setNotes(String notes) {
myNotes = notes;
}
public void setExpand(boolean expand) {
bExpand = expand;
}
public void addNotes(String notes) {
myNotes += notes;
}
protected void enableEvents(boolean enabled) {
myEventsEnabled = enabled;
}
protected boolean areEventsEnabled() {
return myEventsEnabled;
}
/**
* Allows to determine, if a special shape is defined for this task.
*
* @return true, if this task has its own shape defined.
*/
public boolean shapeDefined() {
return (myShape != null);
}
/**
* Allows to determine, if a special color is defined for this task.
*
* @return true, if this task has its own color defined.
*/
public boolean colorDefined() {
return (myColor != null);
}
public String toString() {
//return myID + ": " + myStart.getTime() + "-" + myLength;
return getName();
}
public boolean isUnplugged() {
return myTaskHierarchyItem == null;
}
/**
* Returns the CustomColumnValues.
*
* @return The CustomColumnValues.
*/
public CustomColumnsValues getCustomValues() {
return customValues;
}
/**
* @inheritDoc
*/
public void setCritical(boolean critical) {
this.critical = critical;
}
/**
* @inheritDoc
*/
public boolean isCritical() {
return this.critical;
}
// TODO: implementation of this method has no correlation with algorithms
// recalculating schedules,
// doesn't affect subtasks and supertasks. It is necessary to call this
// method explicitly from other
// parts of code to be sure that constraint fulfils
//
// Method GanttCalendar.newAdd() assumes that time unit is day
public void applyThirdDateConstraint() {
TaskLength length = getDuration();
if (getThird() != null)
switch (getThirdDateConstraint()) {
case EARLIESTBEGIN:
// TODO: TIME UNIT (assumption about days)
if (getThird().after(getStart())) {
int difference = getThird().diff(getStart());
GanttCalendar _start = getStart().newAdd(difference);
GanttCalendar _end = getEnd().newAdd(difference);
setEnd(_end);
setStart(_start);
setDuration(length);
}
break;
}
}
private TaskInfo myTaskInfo;
public TaskInfo getTaskInfo() {
return myTaskInfo;
}
public void setTaskInfo(TaskInfo taskInfo) {
myTaskInfo = taskInfo;
}
public boolean isProjectTask() {
return isProjectTask;
}
public void setProjectTask(boolean projectTask) {
isProjectTask = projectTask;
}
// public TimeInterval getTimeInterval() {
// return null;
// }
// public void setTimeInterval(TimeInterval interval){
//
// }
//
// private class TimeIntervalImpl implements TimeInterval {
// private TaskLength myDuration;
// private Date myStartDate;
//
// private TimeIntervalImpl(Date startDate, TaskLength duration) {
// myDuration = duration;
// myStartDate = startDate;
// }
// public TimeInterval changeStartDate(Date date, FixedField fixedField) {
//// switch (fixedField.ordinal()) {
//// case FixedField.DURATION.ordinal():
////
//// }
// return null;
// }
// public Date getStartDate() {
// return myStartDate;
// }
//
// public float getLength(TimeUnit unit) {
// return myDuration.getLength(unit);
// }
//
// public long getLength() {
// return myDuration.getLength();
// }
//
// public TimeUnit getTimeUnit() {
// return myDuration.getTimeUnit();
// }
//
// public float getValue() {
// return myDuration.getValue();
// }
//
// }
private static final GPCalendar RESTLESS_CALENDAR = new AlwaysWorkingTimeCalendarImpl();
}
The table below shows all metrics for TaskImpl.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 226.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 181.00 | Comment lines | |
| COMMENT_DENSITY | 0.24 | Comment density | |
| COMPARISONS | 115.00 | Number of comparison operators | |
| CYCLOMATIC | 246.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 107.00 | Comments in declarations | |
| DOC_COMMENT | 41.00 | Number of javadoc comment lines | |
| ELOC | 743.00 | Effective lines of code | |
| EXEC_COMMENTS | 30.00 | Comments in executable code | |
| EXITS | 145.00 | Procedure exits | |
| FUNCTIONS | 151.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 0.40 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 250.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 1.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 1.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 1.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 2.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 0.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 2.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 1.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 1.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 1.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 2.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 1.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 2.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 2.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 2.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 16.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 1.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 2.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 5.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 3.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 298.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 5.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 3.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 2.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 2.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 1.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 1.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 1.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 1.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 1.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| JAVA0289 | 1.00 | null | |
| LINES | 1357.00 | Number of lines in the source file | |
| LINE_COMMENT | 140.00 | Number of line comments | |
| LOC | 968.00 | Lines of code | |
| LOGICAL_LINES | 448.00 | Number of statements | |
| LOOPS | 6.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 1800.00 | Number of operands | |
| OPERATORS | 3945.00 | Number of operators | |
| PARAMS | 84.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 5745.00 | Halstead program length | |
| PROGRAM_VOCAB | 590.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 166.00 | Number of return points from functions | |
| SIZE | 42688.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 528.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 62.00 | Number of unique operators | |
| WHITESPACE | 208.00 | Number of whitespace lines | |