Option for SkolemUpperBound application and for skolemisation depth (from file pagoda.properties).

7 files changed, 287 insertions, 206 deletions

diff --git a/src/resources/pagoda.properties b/src/resources/pagoda.properties
index e49aa35..07a0eac 100644
--- a/src/resources/pagoda.properties
+++ b/src/resources/pagoda.properties
@@ -1,6 +1,9 @@
 debug=true
 useAlwaysSimpleUpperBound=false
-useSkolemUpperBound=false
+skolemUpperBound=DISABLED
+skolemDepth=1
+#skolemUpperBound=BEFORE_SUMMARISATION
+#skolemUpperBound=AFTER_SUMMARISATION
 toCallHermit=true
 
 statisticsDir=/home/alessandro/Dropbox/Oxford/PAGOdA/statistics
\ No newline at end of file
diff --git a/src/uk/ac/ox/cs/pagoda/Pagoda.java b/src/uk/ac/ox/cs/pagoda/Pagoda.java
index 7d2317d..08b2cba 100644
--- a/src/uk/ac/ox/cs/pagoda/Pagoda.java
+++ b/src/uk/ac/ox/cs/pagoda/Pagoda.java
@@ -143,7 +143,9 @@ public class Pagoda implements Runnable {
         String statisticsFilename = "statistics_" +
                 FilenameUtils.removeExtension(FilenameUtils.getName(properties.getOntologyPath().replaceAll("_", "-")));
         statisticsFilename += "_" + FilenameUtils.removeExtension(FilenameUtils.getName(queryFile).replaceAll("_", "-"));
-        statisticsFilename += "_" + ((properties.getUseSkolemUpperBound()) ? "skolem" : "");
+        statisticsFilename += "_" + ((properties.getSkolemUpperBound() == PagodaProperties.SkolemUpperBoundOptions.DISABLED)
+                ? "" : (properties.getSkolemUpperBound() == PagodaProperties.SkolemUpperBoundOptions.BEFORE_SUMMARISATION)
+                ? "before" : "after");
         statisticsFilename += ".json";
         statisticsFilename = FilenameUtils.concat(properties.getStatisticsDir().toString(),
                                                   statisticsFilename);
@@ -213,9 +215,15 @@ public class Pagoda implements Runnable {
             return this;
         }
 
-        public PagodaBuilder skolem(Boolean isEnabled) {
+        public PagodaBuilder skolem(PagodaProperties.SkolemUpperBoundOptions option) {
             if(instance == null) return null;
-            instance.properties.setUseSkolemUpperBound(isEnabled);
+            instance.properties.setSkolemUpperBound(option);
+            return this;
+        }
+
+        public PagodaBuilder skolemDepth(int depth) {
+            if(instance == null) return null;
+            instance.properties.setSkolemDepth(depth);
             return this;
         }
 
diff --git a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
index d88376f..f702d5c 100644
--- a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
+++ b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
@@ -802,7 +802,7 @@ public class QueryRecord extends Disposable {
         }
 
         public static Gson getInstance() {
-            if(gson == null) {
+            if (gson == null) {
                 gson = new GsonBuilder()
                         .registerTypeAdapter(AnswerTuple.class, new AnswerTuple.AnswerTupleSerializer())
                         .registerTypeAdapter(QueryRecord.class, new QueryRecord.QueryRecordSerializer())
@@ -820,4 +820,5 @@ public class QueryRecord extends Disposable {
 //              }
 
     }
+
 }
diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
index 6b1921c..8e28142 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
@@ -18,6 +18,7 @@ import uk.ac.ox.cs.pagoda.tracking.QueryTracker;
 import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoder;
 import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoderDisjVar1;
 import uk.ac.ox.cs.pagoda.tracking.TrackingRuleEncoderWithGap;
+import uk.ac.ox.cs.pagoda.util.PagodaProperties;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
 import uk.ac.ox.cs.pagoda.util.disposable.DisposedException;
@@ -193,6 +194,11 @@ class MyQueryReasoner extends QueryReasoner {
 //        queryRecord.saveRelevantOntology("/home/alessandro/Desktop/test-relevant-ontology-"+relevantOntologiesCounter+".owl");
 //        relevantOntologiesCounter++;
 
+        if(properties.getSkolemUpperBound() == PagodaProperties.SkolemUpperBoundOptions.BEFORE_SUMMARISATION
+                && querySkolemisedRelevantSubset(relevantOntologySubset, queryRecord)) {
+            return;
+        }
+
         Utility.logInfo(">> Summarisation <<");
         HermitSummaryFilter summarisedChecker = new HermitSummaryFilter(queryRecord, properties.getToCallHermiT());
         if(summarisedChecker.check(queryRecord.getGapAnswers()) == 0) {
@@ -200,8 +206,8 @@ class MyQueryReasoner extends QueryReasoner {
             return;
         }
 
-        if(properties.getUseSkolemUpperBound() &&
-                querySkolemisedRelevantSubset(relevantOntologySubset, queryRecord)) {
+        if(properties.getSkolemUpperBound() == PagodaProperties.SkolemUpperBoundOptions.AFTER_SUMMARISATION
+                && querySkolemisedRelevantSubset(relevantOntologySubset, queryRecord)) {
             summarisedChecker.dispose();
             return;
         }
@@ -390,7 +396,7 @@ class MyQueryReasoner extends QueryReasoner {
         relevantStore.importDataFromABoxOf(relevantSubset);
         String relevantOriginalMarkProgram = OWLHelper.getOriginalMarkProgram(relevantSubset);
 
-        int queryDependentMaxTermDepth = 3; // TODO make it dynamic
+        int queryDependentMaxTermDepth = properties.getSkolemDepth();
         relevantStore.materialise("Mark original individuals", relevantOriginalMarkProgram);
         int materialisationTag = relevantStore.materialiseSkolemly(relevantProgram, null,
                                                                    queryDependentMaxTermDepth);
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
index d694b61..2c8e23d 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
@@ -3,7 +3,6 @@ package uk.ac.ox.cs.pagoda.rules.approximators;
 import org.semanticweb.HermiT.model.*;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageUpperProgram;
 import uk.ac.ox.cs.pagoda.rules.ExistConstantApproximator;
-import uk.ac.ox.cs.pagoda.util.Utility;
 import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
 import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
 
@@ -65,10 +64,8 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima
     private Collection<DLClause> overApprox(DLClause clause, DLClause originalClause, Collection<Tuple<Individual>> violationTuples) {
         ArrayList<DLClause> result = new ArrayList<>();
         for(Tuple<Individual> violationTuple : violationTuples) {
-            if(getMaxDepth(violationTuple) < maxTermDepth) {
+            if(getMaxDepth(violationTuple) < maxTermDepth)
                 result.addAll(getGroundSkolemisation(clause, originalClause, violationTuple));
-                Utility.logDebug("Approximating maximal individual by a constant in rule:" + originalClause);
-            }
             else
                 result.addAll(alternativeApproximator.convert(clause, originalClause, null));
         }
diff --git a/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java b/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java
index 7b68400..18469ff 100644
--- a/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java
+++ b/src/uk/ac/ox/cs/pagoda/util/PagodaProperties.java
@@ -11,198 +11,226 @@ import java.util.Properties;
 
 public class PagodaProperties {
 
-        public static final String CONFIG_FILE = "pagoda.properties";
-        public static final boolean DEFAULT_DEBUG = false;
-        private static final boolean DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
-        private static final boolean DEFAULT_USE_SKOLEM_UPPER_BOUND;
-        private static final boolean DEFAULT_TO_CALL_HERMIT;
-        private static final Path DEFAULT_STATISTICS_DIR;
-
-        public static boolean shellModeDefault = false;
-        private static boolean debug = DEFAULT_DEBUG;
-
-        static {
-                boolean defaultUseAlwaysSimpleUpperBound = false;
-                boolean defaultUseSkolemUpperBound = true;
-                boolean toCallHermit = true;
-                Path defaultStatisticsDir = null;
-
-                try(InputStream in = PagodaProperties.class.getClassLoader().getResourceAsStream(CONFIG_FILE)) {
-                        Properties config = new Properties();
-                        config.load(in);
-                        in.close();
-                        Logger logger = Logger.getLogger("PagodaProperties");
-                        if(config.containsKey("debug")) {
-                                debug = Boolean.parseBoolean(config.getProperty("debug"));
-                                logger.info("Debugging mode is enabled");
-
-                                if(config.containsKey("statisticsDir")) {
-                                        defaultStatisticsDir = Paths.get(config.getProperty("statisticsDir"));
-                                        logger.info("The directory where statistics are saved is: \"" + defaultStatisticsDir + "\"");
-                                }
-                        }
-                        if(config.containsKey("useAlwaysSimpleUpperBound")) {
-                                defaultUseAlwaysSimpleUpperBound =
-                                                Boolean.parseBoolean(config.getProperty("useAlwaysSimpleUpperBound"));
-                                if(defaultUseAlwaysSimpleUpperBound)
-                                        logger.debug("By default the simple upper bound is always used");
-                        }
-                        if(config.containsKey("useSkolemUpperBound")) {
-                                defaultUseSkolemUpperBound = Boolean.parseBoolean(config.getProperty("useSkolemUpperBound"));
-                                if(defaultUseSkolemUpperBound)
-                                        logger.debug("By default the Skolem upper bound is enabled");
-                                else
-                                        logger.debug("By default the Skolem upper bound is disabled");
-                        }
-                        if(config.containsKey("toCallHermit")) {
-                                toCallHermit = Boolean.parseBoolean(config.getProperty("toCallHermit"));
-                                if(toCallHermit)
-                                        logger.debug("By default Hermit is enabled");
-                                else
-                                        logger.debug("By default Hermit is disabled");
-                        }
-
-                } catch(IOException e) {
-                        e.printStackTrace();
-                }
-                DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND = defaultUseAlwaysSimpleUpperBound;
-                DEFAULT_USE_SKOLEM_UPPER_BOUND = defaultUseSkolemUpperBound;
-                DEFAULT_TO_CALL_HERMIT = toCallHermit;
-                DEFAULT_STATISTICS_DIR = defaultStatisticsDir;
-        }
-
-        String dataPath = null;
-        String ontologyPath;
-        String queryPath = null;
-        String answerPath = null;
-        boolean toClassify = true;
-        boolean toCallHermiT = DEFAULT_TO_CALL_HERMIT;
-        boolean shellMode = shellModeDefault;
-        private boolean useAlwaysSimpleUpperBound = DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
-        private boolean useSkolemUpperBound = DEFAULT_USE_SKOLEM_UPPER_BOUND;
-        private Path statisticsDir = DEFAULT_STATISTICS_DIR;
-
-        public PagodaProperties(String path) {
-                java.util.Properties m_properties = new java.util.Properties();
-                InputStream inputStream = null;
-                try {
-                        inputStream = new FileInputStream(path);
-                        m_properties.load(inputStream);
-
-                        setOntologyPath(m_properties.getProperty("ONTOLOGY"));
-                        setDataPath(m_properties.getProperty("DATA"));
-                        setQueryPath(m_properties.getProperty("QUERY"));
-                        setAnswerPath(m_properties.getProperty("ANSWER"));
-                        setToClassify(Boolean.parseBoolean(m_properties.getProperty("TO_CLASSIFY")));
-                        setToCallHermiT(Boolean.parseBoolean(m_properties.getProperty("CALL_HERMIT")));
-
-                } catch (IOException e) {
-                        e.printStackTrace();
-                } finally {
-                        if (inputStream != null)
-                                try {
-                                        inputStream.close();
-                                } catch (IOException e) {
-                                        e.printStackTrace();
-                                }
-                }
-        }
-        public PagodaProperties() {
-        }
-
-        public static boolean isDebuggingMode() {
-                return debug;
-        }
-
-        public static boolean getDefaultUseAlwaysSimpleUpperBound() {
-                return DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
-        }
-
-        public static Path getDefaultStatisticsDir() {
-                return DEFAULT_STATISTICS_DIR;
-        }
-
-        public static boolean getDefaultUseSkolemUpperBound() {
-                return DEFAULT_USE_SKOLEM_UPPER_BOUND;
-        }
-
-        public String getDataPath() {
-                return dataPath;
-        }
-
-        public void setDataPath(String path) {
-                dataPath = path;
-        }
-
-        public String getOntologyPath() {
-                return ontologyPath;
-        }
-
-        public void setOntologyPath(String path) {
-                ontologyPath = path;
-        }
-
-        public String getQueryPath() {
-                return queryPath;
-        }
-
-        public void setQueryPath(String path) {
-                queryPath = path;
-        }
-
-        public String getAnswerPath() {
-                return answerPath;
-        }
-
-        public void setAnswerPath(String path) {
-                answerPath = path;
-        }
-
-        public boolean getToClassify() {
-                return toClassify;
-        }
-
-        public void setToClassify(boolean flag) {
-                toClassify = flag;
-        }
-
-        public boolean getToCallHermiT() {
-                return toCallHermiT;
-        }
-
-        public void setToCallHermiT(boolean flag) {
-                toCallHermiT = flag;
-        }
-
-        public boolean getShellMode() {
-                return shellMode;
-        }
-
-        public void setShellMode(boolean flag) {
-                shellMode = flag;
-        }
-
-        public boolean getUseAlwaysSimpleUpperBound() {
-                return useAlwaysSimpleUpperBound;
-        }
-
-        public void setUseAlwaysSimpleUpperBound(boolean flag) {
-                useAlwaysSimpleUpperBound = flag;
-        }
-
-        public boolean getUseSkolemUpperBound() {
-                return useSkolemUpperBound;
-        }
-
-        public void setUseSkolemUpperBound(boolean flag) {
-                useSkolemUpperBound = flag;
-        }
-
-        public Path getStatisticsDir() {
-                return statisticsDir;
-        }
-
-        public void setStatisticsDir(Path statisticsDir) {
-                this.statisticsDir = statisticsDir;
-        }
+    public enum SkolemUpperBoundOptions {DISABLED, BEFORE_SUMMARISATION, AFTER_SUMMARISATION}
+
+    public static final String CONFIG_FILE = "pagoda.properties";
+    public static final boolean DEFAULT_DEBUG = false;
+    private static final boolean DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
+    private static final SkolemUpperBoundOptions DEFAULT_SKOLEM_UPPER_BOUND;
+    private static final int DEFAULT_SKOLEM_DEPTH;
+    private static final boolean DEFAULT_TO_CALL_HERMIT;
+    private static final Path DEFAULT_STATISTICS_DIR;
+
+    public static boolean shellModeDefault = false;
+    private static boolean debug = DEFAULT_DEBUG;
+
+    static {
+        boolean defaultUseAlwaysSimpleUpperBound = false;
+        SkolemUpperBoundOptions defaultSkolemUpperBound = SkolemUpperBoundOptions.DISABLED;
+        int defaultSkolemDepth = 1;
+        boolean toCallHermit = true;
+        Path defaultStatisticsDir = null;
+
+        try (InputStream in = PagodaProperties.class.getClassLoader().getResourceAsStream(CONFIG_FILE)) {
+            Properties config = new Properties();
+            config.load(in);
+            in.close();
+            Logger logger = Logger.getLogger("PagodaProperties");
+            if (config.containsKey("debug")) {
+                debug = Boolean.parseBoolean(config.getProperty("debug"));
+                logger.info("Debugging mode is enabled");
+
+                if (config.containsKey("statisticsDir")) {
+                    defaultStatisticsDir = Paths.get(config.getProperty("statisticsDir"));
+                    logger.info("The directory where statistics are saved is: \"" + defaultStatisticsDir + "\"");
+                }
+            }
+            if (config.containsKey("useAlwaysSimpleUpperBound")) {
+                defaultUseAlwaysSimpleUpperBound =
+                        Boolean.parseBoolean(config.getProperty("useAlwaysSimpleUpperBound"));
+                if (defaultUseAlwaysSimpleUpperBound)
+                    logger.debug("By default the simple upper bound is always used");
+            }
+            if (config.containsKey("skolemUpperBound")) {
+                defaultSkolemUpperBound = SkolemUpperBoundOptions.valueOf(config.getProperty("skolemUpperBound"));
+                switch (defaultSkolemUpperBound) {
+                    case AFTER_SUMMARISATION:
+                        logger.debug("By default the Skolem upper bound is applied AFTER Summarisation");
+                        break;
+                    case BEFORE_SUMMARISATION:
+                        logger.debug("By default the Skolem upper bound is applied BEFORE Summarisation");
+                        break;
+                    default:
+                        defaultSkolemUpperBound = SkolemUpperBoundOptions.DISABLED;
+                    case DISABLED:
+                        logger.debug("By default the Skolem upper bound is disabled");
+                }
+            }
+            if (config.containsKey("toCallHermit")) {
+                toCallHermit = Boolean.parseBoolean(config.getProperty("toCallHermit"));
+                if (toCallHermit)
+                    logger.debug("By default Hermit is enabled");
+                else
+                    logger.debug("By default Hermit is disabled");
+            }
+            if (config.containsKey("skolemDepth")) {
+                defaultSkolemDepth = Integer.parseInt(config.getProperty("skolemDepth"));
+                logger.debug("By default the max skolemisation depth is " + defaultSkolemDepth);
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND = defaultUseAlwaysSimpleUpperBound;
+        DEFAULT_SKOLEM_UPPER_BOUND = defaultSkolemUpperBound;
+        DEFAULT_TO_CALL_HERMIT = toCallHermit;
+        DEFAULT_STATISTICS_DIR = defaultStatisticsDir;
+        DEFAULT_SKOLEM_DEPTH = defaultSkolemDepth;
+    }
+
+    String dataPath = null;
+    String ontologyPath;
+    String queryPath = null;
+    String answerPath = null;
+    boolean toClassify = true;
+    boolean toCallHermiT = DEFAULT_TO_CALL_HERMIT;
+
+    public int getSkolemDepth() {
+        return skolemDepth;
+    }
+
+    public void setSkolemDepth(int skolemDepth) {
+        this.skolemDepth = skolemDepth;
+    }
+
+    int skolemDepth = DEFAULT_SKOLEM_DEPTH;
+    boolean shellMode = shellModeDefault;
+    private boolean useAlwaysSimpleUpperBound = DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
+    private SkolemUpperBoundOptions skolemUpperBound = DEFAULT_SKOLEM_UPPER_BOUND;
+    private Path statisticsDir = DEFAULT_STATISTICS_DIR;
+
+    public PagodaProperties(String path) {
+        java.util.Properties m_properties = new java.util.Properties();
+        InputStream inputStream = null;
+        try {
+            inputStream = new FileInputStream(path);
+            m_properties.load(inputStream);
+
+            setOntologyPath(m_properties.getProperty("ONTOLOGY"));
+            setDataPath(m_properties.getProperty("DATA"));
+            setQueryPath(m_properties.getProperty("QUERY"));
+            setAnswerPath(m_properties.getProperty("ANSWER"));
+            setToClassify(Boolean.parseBoolean(m_properties.getProperty("TO_CLASSIFY")));
+            setToCallHermiT(Boolean.parseBoolean(m_properties.getProperty("CALL_HERMIT")));
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (inputStream != null)
+                try {
+                    inputStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+    }
+
+    public PagodaProperties() {
+    }
+
+    public static boolean isDebuggingMode() {
+        return debug;
+    }
+
+    public static boolean getDefaultUseAlwaysSimpleUpperBound() {
+        return DEFAULT_USE_ALWAYS_SIMPLE_UPPER_BOUND;
+    }
+
+    public static Path getDefaultStatisticsDir() {
+        return DEFAULT_STATISTICS_DIR;
+    }
+
+    public static SkolemUpperBoundOptions getDefaultSkolemUpperBound() {
+        return DEFAULT_SKOLEM_UPPER_BOUND;
+    }
+
+    public String getDataPath() {
+        return dataPath;
+    }
+
+    public void setDataPath(String path) {
+        dataPath = path;
+    }
+
+    public String getOntologyPath() {
+        return ontologyPath;
+    }
+
+    public void setOntologyPath(String path) {
+        ontologyPath = path;
+    }
+
+    public String getQueryPath() {
+        return queryPath;
+    }
+
+    public void setQueryPath(String path) {
+        queryPath = path;
+    }
+
+    public String getAnswerPath() {
+        return answerPath;
+    }
+
+    public void setAnswerPath(String path) {
+        answerPath = path;
+    }
+
+    public boolean getToClassify() {
+        return toClassify;
+    }
+
+    public void setToClassify(boolean flag) {
+        toClassify = flag;
+    }
+
+    public boolean getToCallHermiT() {
+        return toCallHermiT;
+    }
+
+    public void setToCallHermiT(boolean flag) {
+        toCallHermiT = flag;
+    }
+
+    public boolean getShellMode() {
+        return shellMode;
+    }
+
+    public void setShellMode(boolean flag) {
+        shellMode = flag;
+    }
+
+    public boolean getUseAlwaysSimpleUpperBound() {
+        return useAlwaysSimpleUpperBound;
+    }
+
+    public void setUseAlwaysSimpleUpperBound(boolean flag) {
+        useAlwaysSimpleUpperBound = flag;
+    }
+
+    public SkolemUpperBoundOptions getSkolemUpperBound() {
+        return skolemUpperBound;
+    }
+
+    public void setSkolemUpperBound(SkolemUpperBoundOptions flag) {
+        skolemUpperBound = flag;
+    }
+
+    public Path getStatisticsDir() {
+        return statisticsDir;
+    }
+
+    public void setStatisticsDir(Path statisticsDir) {
+        this.statisticsDir = statisticsDir;
+    }
 }
diff --git a/src/uk/ac/ox/cs/pagoda/util/data_structures/Graph.java b/src/uk/ac/ox/cs/pagoda/util/data_structures/Graph.java
new file mode 100644
index 0000000..4f454df
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/util/data_structures/Graph.java
@@ -0,0 +1,38 @@
+package uk.ac.ox.cs.pagoda.util.data_structures;
+
+import java.util.*;
+
+public class Graph<V> {
+
+    private final boolean isDirected;
+
+    private Map<V, Set<V>> outEdgesOf = new HashMap<>();
+    public Graph(boolean isDirected) {
+        this.isDirected = isDirected;
+    }
+
+    public Graph() {
+        this(false);
+    }
+    public void addNode(V v) {
+        if(!outEdgesOf.containsKey(v))
+            outEdgesOf.put(v, new HashSet<V>());
+    }
+
+    public void addEdge(V v, V u) {
+        addNode(v);
+        addNode(u);
+        outEdgesOf.get(v).add(u);
+
+        if(isDirected)
+            outEdgesOf.get(u).add(v);
+    }
+
+    public Iterator<V> getOutNeighbors(V v) {
+        return outEdgesOf.get(v).iterator();
+    }
+
+    public boolean isDirected() {
+        return isDirected;
+    }
+}