Restructure project to use Maven exclusively and bump to v1.0.1-SNAPSHOT

- Remove legacy Ant build system (build.xml, sources/ directory)
- Migrate to Maven-only build with standard directory structure
- Add comprehensive Maven documentation and JAVA_HOME setup for Fedora
- Update pom.xml with exec plugin and bump version to 1.0.1-SNAPSHOT
- Add CLAUDE.md for development guidance
- Update README.md with detailed build/run/clean instructions

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

1 files changed, 0 insertions, 503 deletions

diff --git a/sources/core/VSTask.java b/sources/core/VSTask.java
deleted file mode 100644
index 54d7ff1..0000000
--- a/sources/core/VSTask.java
+++ /dev/null
@@ -1,503 +0,0 @@
-package core;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-
-import events.VSAbstractEvent;
-import events.VSRegisteredEvents;
-import events.implementations.VSProcessCrashEvent;
-import events.implementations.VSProcessRecoverEvent;
-import events.internal.VSAbstractInternalEvent;
-import events.internal.VSMessageReceiveEvent;
-import events.internal.VSProtocolEvent;
-import exceptions.VSEventNotCopyableException;
-import prefs.VSPrefs;
-import protocols.VSAbstractProtocol;
-//import utils.*;
-import serialize.VSNotSerializable;
-import serialize.VSSerializable;
-import serialize.VSSerialize;
-
-/**
- * The class VSTask, an object of this class represents a task to do or done.
- * All tasks are managed by the task manager. There are local and global timed
- * tasks. Local timed tasks are being fullfilled if the process' local time is
- * reached. Global timed tasks are being fullfilled if the simulator's time is
- * reached.
- *
- * @author Paul C. Buetow
- */
-public class VSTask implements Comparable<Object>, VSSerializable {
-    /** The Constant LOCAL. Used for the constructor if it's a local timed
-     * task.
-     */
-    public final static boolean LOCAL = true;
-
-    /** The Constant GLOBAL. Used for the constructor if it's a global timed
-     * task.
-     */
-    public final static boolean GLOBAL = false;
-
-    /** The task time. */
-    private long taskTime;
-
-    /** The event which takes plase if the task time matches. */
-    private VSAbstractEvent event;
-
-    /** The process to run the task at. */
-    private VSInternalProcess process;
-
-    /** The simulator's default prefs. */
-    private VSPrefs prefs;
-
-    /** The task is programmed. The task will be still in the task manager
-     * after reset.
-     */
-    private boolean isProgrammed;
-
-    /** The task is global timed. If set to true, its local timed. */
-    private boolean isGlobalTimed;
-
-    /** The task counter. Needed for the unique task numbers. */
-    private static int taskCounter;
-
-    /** The task number. */
-    private int taskNum;
-
-    /**
-     * Instantiates a new task.
-     *
-     * @param taskTime the task time
-     * @param process the process
-     * @param event the event
-     * @param isLocal the taks is local timed
-     */
-    public VSTask(long taskTime, VSInternalProcess process,
-                  VSAbstractEvent event,
-                  boolean isLocal) {
-        init(taskTime, process, event, isLocal);
-    }
-
-    /**
-     * Instantiates a new task, it's a copy constructor.
-     *
-     * @param task the task to copy
-     */
-    public VSTask(VSTask task) {
-        VSAbstractEvent event = task.getEvent();
-
-        try {
-            // Use the copy of the event object
-            event = event.getCopy();
-
-        } catch (VSEventNotCopyableException e) {
-            // Use the original event object
-        }
-
-        init(task.getTaskTime(),
-             task.getProcess(),
-             event,
-             !task.isGlobalTimed());
-    }
-
-    /**
-     * Instantiates a new task during a deserialization.
-     *
-     * @param serialize the serialize object
-     * @param objectInputStream The input stream
-     */
-    public VSTask(VSSerialize serialize, ObjectInputStream objectInputStream)
-    throws IOException, ClassNotFoundException {
-        deserialize(serialize, objectInputStream);
-    }
-
-    /**
-     * Inits the task
-     *
-     * @param taskTime the task time
-     * @param process the process
-     * @param event the event
-     * @param isLocal the taks is local timed
-     */
-    private void init(long taskTime, VSInternalProcess process,
-                      VSAbstractEvent event, boolean isLocal) {
-        this.process = process;
-        this.taskTime = taskTime > 0 ? taskTime : 0;
-        /* May be not null if called from deserialization */
-        if (this.event == null)
-            this.event = event;
-        this.prefs = process.getPrefs();
-        this.isGlobalTimed = !isLocal;
-        this.taskNum = ++taskCounter;
-    }
-
-    /**
-     * Gets the task num.
-     *
-     * @return the task num
-     */
-    public int getTaskNum() {
-        return taskNum;
-    }
-
-    /**
-     * Sets if the task is programmed.
-     *
-     * @param isProgrammed true, if the task is programmed
-     */
-    public void isProgrammed(boolean isProgrammed) {
-        this.isProgrammed = isProgrammed;
-    }
-
-    /**
-     * Checks if the task is programmed.
-     *
-     * @return true, if the task is programmed
-     */
-    public boolean isProgrammed() {
-        return isProgrammed;
-    }
-
-    /**
-     * Checks if the task is using an "internal event".
-     *
-     * @return true, if the task is using an internal event
-     */
-    public boolean hasInternalEvent() {
-        return event instanceof VSAbstractInternalEvent;
-    }
-
-    /**
-     * Checks if the task should not get serialized.
-     *
-     * @return true, if the task should not get serialized
-     */
-    public boolean hasNotSerializableEvent() {
-        return event instanceof VSNotSerializable;
-    }
-
-    /**
-     * Checks if the task is a message receive event.
-     *
-     * @return true, if it is a message receive event
-     */
-    public boolean hasMessageReceiveEvent() {
-        return event instanceof VSMessageReceiveEvent;
-    }
-
-    /**
-     * Checks if the task is a process recover event.
-     *
-     * @return true, if it is a process recover event
-     */
-    public boolean hasProcessRecoverEvent() {
-        return event instanceof VSProcessRecoverEvent;
-    }
-
-    /**
-     * Checks if the task belongs to the specified protocol object.
-     *
-     * @param protocol the protocol object to check against.
-     *
-     * @return true, if it's a task using the protocol object.
-     */
-    public boolean isProtocol(VSAbstractProtocol protocol) {
-        if (event instanceof VSAbstractProtocol)
-            return ((VSAbstractProtocol) event).equals(protocol);
-
-        return false;
-    }
-
-    /**
-     * Checks if the task's time is over.
-     *
-     * @return true, if it's over
-     */
-    public boolean timeOver() {
-        if (isGlobalTimed)
-            return taskTime < process.getGlobalTime();
-
-        return taskTime < process.getTime();
-    }
-
-    /**
-     * Checks if the task equals to another task.
-     *
-     * @param task the task to compare to
-     *
-     * @return true, if equal (the task nums equal)
-     */
-    public boolean equals(VSTask task) {
-        return taskNum == task.getTaskNum();
-    }
-
-    /**
-     * Checks if the task belongs to the specified process.
-     *
-     * @param process the process to check against
-     *
-     * @return true, if the task is using the process
-     */
-    public boolean isProcess(VSInternalProcess process) {
-        return this.process.equals(process);
-    }
-
-    /**
-     * Checks if the task is global timed.
-     *
-     * @return true, if the taks is global timed
-     */
-    public boolean isGlobalTimed() {
-        return isGlobalTimed;
-    }
-
-    /**
-     * Gets the process.
-     *
-     * @return the process of the event
-     */
-    public VSInternalProcess getProcess() {
-        return process;
-    }
-
-    /**
-     * Runs the task.
-     */
-    public void run() {
-        if (event.getProcess() == null)
-            event.init(process);
-
-        if (!(event instanceof VSMessageReceiveEvent)
-                && !(event instanceof VSAbstractProtocol))
-            process.increaseVectorAndLamportTimeIfAll();
-
-        event.onStart();
-    }
-
-    /**
-     * Gets the task time.
-     *
-     * @return the task time
-     */
-    public long getTaskTime() {
-        return taskTime;
-    }
-
-    /**
-     * Sets the task time.
-     *
-     * @param taskTime the task time
-     */
-    public void setTaskTime(long taskTime) {
-        this.taskTime = taskTime;
-    }
-
-    /**
-     * Sets the process.
-     *
-     * @param process the process
-     */
-    public void setProcess(VSInternalProcess process) {
-        /* Only do it if the process differs */
-        if (!this.process.equals(process)) {
-            this.process = process;
-
-            try {
-                // Use the copy of the event object
-                event  = event.getCopy(process);
-
-            } catch (VSEventNotCopyableException e) {
-                if (event instanceof VSAbstractProtocol) {
-                    String eventShortname = event.getShortname();
-                    event = process.getProtocolObject(event.getClassname());
-                    event.setShortname(eventShortname);
-                } else {
-                    System.out.println(e);
-                }
-            }
-        }
-    }
-
-    /**
-     * Gets the event.
-     *
-     * @return the event
-     */
-    public VSAbstractEvent getEvent() {
-        return event;
-    }
-
-    /*
-    private void log(String message) {
-        process.log(message);
-    }
-    */
-
-    /* (non-Javadoc)
-     * @see java.lang.Object#toString()
-     */
-    public String toString() {
-        StringBuffer buffer = new StringBuffer();
-
-        buffer.append(prefs.getString("lang.task"));
-        buffer.append(" ");
-        buffer.append(getTaskTime());
-        buffer.append(event.toString());
-        buffer.append("; PID: ");
-        buffer.append(process.getProcessID());
-        /*
-        if (isProgrammed()) {
-        	buffer.append("; Programmed");
-        }
-        */
-
-        return buffer.toString();
-    }
-
-    /* (non-Javadoc)
-     * @see java.lang.Comparable#compareTo(java.lang.Object)
-     */
-    public int compareTo(Object object) {
-        if (object instanceof VSTask) {
-            final VSTask task = (VSTask) object;
-
-            if (taskTime < task.getTaskTime())
-                return -1;
-
-            else if (taskTime > task.getTaskTime())
-                return 1;
-
-            VSAbstractEvent event2 = task.getEvent();
-
-            /* If it's a recovering, it should get handled very first */
-            boolean a = event instanceof VSProcessRecoverEvent;
-            boolean b = event2 instanceof VSProcessRecoverEvent;
-
-            if (a && b)
-                return 0;
-
-            if (a)
-                return -1;
-
-            if (b)
-                return 1;
-
-            /* If it's a crash, it should get handled second first */
-            a = event instanceof VSProcessCrashEvent;
-            b = event2 instanceof VSProcessCrashEvent;
-
-            if (a && b)
-                return 0;
-
-            if (a)
-                return -1;
-
-            if (b)
-                return 1;
-
-            /* If it's a VSProtocolEvent, it should get handled third  */
-            a = event instanceof VSProtocolEvent;
-            b = event2 instanceof VSProtocolEvent;
-
-            if (a && b)
-                return 0;
-
-            if (a)
-                return -1;
-
-            if (b)
-                return 1;
-
-            String shortname = event.getShortname();
-            String shortname2 = event2.getShortname();
-
-            /* One of those may be null if an VSAbstractEvent object has not
-               been initialized yet */
-            if (shortname == null || shortname2 == null)
-                return 0;
-
-            return shortname.compareTo(shortname2);
-        }
-
-        return 0;
-    }
-
-    /* (non-Javadoc)
-     * @see serialize.VSSerializable#serialize(serialize.VSSerialize,
-     *	java.io.ObjectOutputStream)
-     */
-    public synchronized void serialize(VSSerialize serialize,
-                                       ObjectOutputStream objectOutputStream)
-    throws IOException {
-        /** For later backwards compatibility, to add more stuff */
-        objectOutputStream.writeObject(Boolean.valueOf(false));
-
-        objectOutputStream.writeObject(Integer.valueOf(process.getProcessNum()));
-
-        if (event.getClassname() == null)
-            event.init(process);
-
-        if (VSSerialize.DEBUG)
-            System.out.println("Serializing: " + event.getClassname());
-
-        objectOutputStream.writeObject(event.getClassname());
-        objectOutputStream.writeObject(Integer.valueOf(event.getID()));
-        event.serialize(serialize, objectOutputStream);
-        objectOutputStream.writeObject(Integer.valueOf(taskNum));
-        objectOutputStream.writeObject(Long.valueOf(taskTime));
-        objectOutputStream.writeObject(Boolean.valueOf(isGlobalTimed));
-        objectOutputStream.writeObject(Boolean.valueOf(isProgrammed));
-
-        /** For later backwards compatibility, to add more stuff */
-        objectOutputStream.writeObject(Boolean.valueOf(false));
-    }
-
-    /* (non-Javadoc)
-     * @see serialize.VSSerializable#deserialize(serialize.VSSerialize,
-     *	java.io.ObjectInputStream)
-     */
-    public synchronized void deserialize(VSSerialize serialize,
-                                         ObjectInputStream objectInputStream)
-    throws IOException, ClassNotFoundException {
-        if (VSSerialize.DEBUG)
-            System.out.println("Deserializing: VSTask");
-
-        /** For later backwards compatibility, to add more stuff */
-        objectInputStream.readObject();
-
-        int processNum = ((Integer) objectInputStream.readObject()).intValue();
-        VSInternalProcess process = (VSInternalProcess)
-                                    serialize.getObject(processNum, "process");
-
-        String eventClassname = (String) objectInputStream.readObject();
-        int eventID = ((Integer) objectInputStream.readObject()).intValue();
-
-        VSAbstractEvent event = null;
-
-        if (serialize.objectExists(eventID, "event")) {
-            event = (VSAbstractEvent) serialize.getObject(eventID, "event");
-
-        } else {
-            event = VSRegisteredEvents.
-                    createEventInstanceByClassname(eventClassname, process);
-
-            serialize.setObject(eventID, "event", event);
-        }
-
-        event.deserialize(serialize, objectInputStream);
-
-        int taskNum = ((Integer) objectInputStream.readObject()).intValue();
-        long taskTime = ((Long) objectInputStream.readObject()).longValue();
-        Boolean isGlobalTimed = (Boolean) objectInputStream.readObject();
-        Boolean isProgrammed = (Boolean) objectInputStream.readObject();
-
-        serialize.setObject(taskNum, "task", this);
-        init(taskTime, process, event, !isGlobalTimed.booleanValue());
-        this.isProgrammed = isProgrammed.booleanValue();
-
-        /** For later backwards compatibility, to add more stuff */
-        objectInputStream.readObject();
-    }
-}
-