Rename skipAliasedNetworks to includeAliasedNetworks

Author: faktas2

src/main/java/com/maxmind/db/Networks.java

@@ -18,38 +18,38 @@ public final class Networks<T> implements Iterator<DatabaseRecord<T>> {
     private final Reader reader;
     private final Stack<NetworkNode> nodes;
     private NetworkNode lastNode;
-    private final boolean skipAliasedNetworks;
+    private final boolean includeAliasedNetworks;
     private final ByteBuffer buffer; /* Stores the buffer for Next() calls */
     private final Class<T> typeParameterClass;
 
     /**
      * Constructs a Networks instance.
      * @param reader The reader object.
-     * @param skipAliasedNetworks The boolean to skip aliased networks.
+     * @param includeAliasedNetworks The boolean to include aliased networks.
      * @param typeParameterClass The type of data returned by the iterator.
      * @throws ClosedDatabaseException Exception for a closed database.
      */
-    Networks(Reader reader, boolean skipAliasedNetworks, Class<T> typeParameterClass) 
+    Networks(Reader reader, boolean includeAliasedNetworks, Class<T> typeParameterClass) 
         throws ClosedDatabaseException {
-        this(reader, skipAliasedNetworks, new NetworkNode[]{}, typeParameterClass);
+        this(reader, includeAliasedNetworks, new NetworkNode[]{}, typeParameterClass);
     }
 
     /**
      * Constructs a Networks instance.
      * @param reader The reader object.
-     * @param skipAliasedNetworks The boolean to skip aliased networks.
+     * @param includeAliasedNetworks The boolean to include aliased networks.
      * @param nodes The initial nodes array to start Networks iterator with.
      * @param typeParameterClass The type of data returned by the iterator.
      * @throws ClosedDatabaseException Exception for a closed database.
      */
     Networks(
             Reader reader,
-            boolean skipAliasedNetworks,
+            boolean includeAliasedNetworks,
             NetworkNode[] nodes,
             Class<T> typeParameterClass)
         throws ClosedDatabaseException {
         this.reader = reader;
-        this.skipAliasedNetworks = skipAliasedNetworks;
+        this.includeAliasedNetworks = includeAliasedNetworks;
         this.buffer = reader.getBufferHolder().get();
         this.nodes = new Stack<NetworkNode>();
         this.typeParameterClass = typeParameterClass;
@@ -59,7 +59,7 @@ public final class Networks<T> implements Iterator<DatabaseRecord<T>> {
     }
 
     /**
-     * Constructs a Networks instance with skipAliasedNetworks set to false by default.
+     * Constructs a Networks instance with includeAliasedNetworks set to false by default.
      * @param reader The reader object.
      * @param typeParameterClass The type of data returned by the iterator.
      */
@@ -68,11 +68,9 @@ public final class Networks<T> implements Iterator<DatabaseRecord<T>> {
     }
 
     /**
-     * Returns the next DataRecord. You need to set the class using
-     * prepareForClass before calling next. 
-     * For example,
-     *  networks.prepareForClass(Map.Class);
-     *  Map test = networks.next();
+     * Returns the next DataRecord.
+     * @return The next DataRecord.
+     * @throws NetworksIterationException An exception when iterating over the networks.
      */
     @Override
     public DatabaseRecord<T> next() {
@@ -83,11 +81,10 @@ public DatabaseRecord<T> next() {
             byte[] ip = this.lastNode.ip;
             int prefixLength = this.lastNode.prefix;
 
-            // We do this because uses of SkipAliasedNetworks expect the IPv4 networks
-            // to be returned as IPv4 networks. If we are not skipping aliased
-            // networks, then the user will get IPv4 networks from the ::FFFF:0:0/96
-            // network.
-            if (this.skipAliasedNetworks && isInIpv4Subtree(ip)) {
+            // We do this because uses of includeAliasedNetworks will get IPv4 networks
+            // from the ::FFFF:0:0/96. We want to return the IPv4 form of the address
+            // in that case.
+            if (!this.includeAliasedNetworks && isInIpv4Subtree(ip)) {
                 ip = Arrays.copyOfRange(ip, 12, ip.length);
                 prefixLength -= 96;
             }
@@ -117,10 +114,12 @@ private boolean isInIpv4Subtree(byte[] ip) {
         return true;
     }
 
-    /*
-    * Next prepares the next network for reading with the Network method. It
+    /**
+    * hasNext prepares the next network for reading with the Network method. It
     * returns true if there is another network to be processed and false if there
-    * are no more networks or if there is an error.
+    * are no more networks.
+    * @return boolean True if there is another network to be processed.
+    * @throws NetworksIterationException Exception while iterating over the networks.
     */
     @Override
     public boolean hasNext()  {
@@ -131,7 +130,7 @@ public boolean hasNext()  {
             while (node.pointer != this.reader.getMetadata().getNodeCount()) {
                 // This skips IPv4 aliases without hardcoding the networks that the writer
                 // currently aliases.
-                if (this.skipAliasedNetworks && this.reader.getIpv4Start() != 0
+                if (!this.includeAliasedNetworks && this.reader.getIpv4Start() != 0
                         && node.pointer == this.reader.getIpv4Start()
                         && !isInIpv4Subtree(node.ip)) {
                     break;

src/main/java/com/maxmind/db/Reader.java

@@ -201,9 +201,8 @@ record = this.readNode(buffer, record, bit);
     /**
      * Creates a Networks iterator and skips aliased networks.
      * Please note that a MaxMind DB may map IPv4 networks into several locations
-     * in an IPv6 database. This iterator will iterate over all of these locations
-     * separately. To disable skipAliasedNetworks, which iterates over the IPv4 networks 
-     * only once, use the SkipAliasedNetworks parameter.
+     * in an IPv6 database. networks() iterates over the canonical locations and
+     * not the aliases. To include the aliases, you can set includeAliasedNetworks to true.
      * 
      * @param <T> Represents the data type(e.g., Map, HastMap, etc.).
      * @param typeParameterClass The type of data returned by the iterator.
@@ -214,25 +213,25 @@ record = this.readNode(buffer, record, bit);
      */
     public <T> Networks<T> networks(Class<T> typeParameterClass) throws 
         InvalidNetworkException, ClosedDatabaseException, InvalidDatabaseException {
-        return this.networks(true, typeParameterClass);
+        return this.networks(false, typeParameterClass);
     }
 
     /**
      * Creates a Networks iterator.
      * Please note that a MaxMind DB may map IPv4 networks into several locations
      * in an IPv6 database. This iterator will iterate over all of these locations
      * separately. To set the iteration over the IPv4 networks once, use the
-     * SkipAliasedNetworks option.
+     * includeAliasedNetworks option.
      * 
      * @param <T> Represents the data type(e.g., Map, HastMap, etc.).
-     * @param skipAliasedNetworks Enable or disable skipping aliased networks.
+     * @param includeAliasedNetworks Enable including aliased networks.
      * @return Networks The Networks iterator.
      * @throws InvalidNetworkException Exception for using an IPv6 network in ipv4-only database.
      * @throws ClosedDatabaseException Exception for a closed databased.
      * @throws InvalidDatabaseException Exception for an invalid database.
      */
     public <T> Networks<T> networks(
-            boolean skipAliasedNetworks,
+            boolean includeAliasedNetworks,
             Class<T> typeParameterClass) throws
         InvalidNetworkException, ClosedDatabaseException, InvalidDatabaseException {
         try {
@@ -242,9 +241,9 @@ public <T> Networks<T> networks(
             Network ipAllV6 = new Network(ipv6, 0); // Mask 128.
 
             if (this.getMetadata().getIpVersion() == 6) {
-                return this.networksWithin(ipAllV6, skipAliasedNetworks, typeParameterClass);
+                return this.networksWithin(ipAllV6, includeAliasedNetworks, typeParameterClass);
             }
-            return this.networksWithin(ipAllV4, skipAliasedNetworks, typeParameterClass);
+            return this.networksWithin(ipAllV4, includeAliasedNetworks, typeParameterClass);
         } catch (UnknownHostException e) {
             /* This is returned by getByAddress. This should never happen
             as the ipv4 and ipv6 are constants set by us. */
@@ -289,10 +288,10 @@ private int findIpV4StartNode(ByteBuffer buffer)
      * Please note that a MaxMind DB may map IPv4 networks into several locations
      * in an IPv6 database. This iterator will iterate over all of these locations
      * separately. To only iterate over the IPv4 networks once, use the
-     * SkipAliasedNetworks option.
+     * includeAliasedNetworks option.
      * @param <T> Represents the data type(e.g., Map, HastMap, etc.).
      * @param network Specifies the network to be iterated.
-     * @param skipAliasedNetworks Boolean for skipping aliased networks.
+     * @param includeAliasedNetworks Boolean for including aliased networks.
      * @param typeParameterClass The type of data returned by the iterator.
      * @return Networks
      * @throws InvalidNetworkException Exception for using an IPv6 network in ipv4-only database.
@@ -301,7 +300,7 @@ private int findIpV4StartNode(ByteBuffer buffer)
      */
     public <T> Networks<T> networksWithin(
             Network network,
-            boolean skipAliasedNetworks,
+            boolean includeAliasedNetworks,
             Class<T> typeParameterClass)
         throws InvalidNetworkException, ClosedDatabaseException, InvalidDatabaseException {
         InetAddress networkAddress = network.getNetworkAddress();
@@ -313,14 +312,14 @@ public <T> Networks<T> networksWithin(
         int prefixLength = network.getPrefixLength();
 
         if (this.metadata.getIpVersion() == 6 && ipBytes.length == IPV4_LEN) {
-            if (skipAliasedNetworks) {
-                ipBytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                    ipBytes[0], ipBytes[1], ipBytes[2], ipBytes[3] };
-            } else {
+            if (includeAliasedNetworks) {
                 // Convert it to the IP address (in 16-byte from) of the IPv4 address.
                 ipBytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                     -1, -1, // -1 is for 0xff.
                     ipBytes[0], ipBytes[1], ipBytes[2], ipBytes[3]};
+            } else {
+                ipBytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    ipBytes[0], ipBytes[1], ipBytes[2], ipBytes[3] };
             }
             prefixLength += 96;
         }
@@ -329,7 +328,7 @@ public <T> Networks<T> networksWithin(
         int node = traverseResult[0];
         int prefix = traverseResult[1];
 
-        Networks<T> networks = new Networks<T>(this, skipAliasedNetworks,
+        Networks<T> networks = new Networks<T>(this, includeAliasedNetworks,
             new Networks.NetworkNode[]{new Networks.NetworkNode(ipBytes, prefix, node)},
                 typeParameterClass);
 

src/test/java/com/maxmind/db/ReaderTest.java

@@ -336,7 +336,8 @@ public void testNetworksWithin() throws IOException, InvalidNetworkException{
                 InetAddress address = InetAddress.getByName(test.network);
                 Network network = new Network(address, test.prefix);
 
-                Networks networks = reader.networksWithin(network, test.skipAliasedNetworks, Map.class);
+                boolean includeAliasedNetworks = !test.skipAliasedNetworks;
+                Networks networks = reader.networksWithin(network, includeAliasedNetworks, Map.class);
 
                 ArrayList<String> innerIPs  = new ArrayList<String>();
                 while(networks.hasNext()){