Add more create methods

Author: patrickfav

CHANGELOG

@@ -1,5 +1,9 @@
 # Releases
 
+## v0.3.1
+
+* better validation and more creation possibilities
+
 ## v0.3.0
 
 * better type hierarchy with read-only and mutable types

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>at.favre.lib</groupId>
     <artifactId>bytes</artifactId>
-    <version>0.3.0</version>
+    <version>0.3.1</version>
     <packaging>jar</packaging>
 
     <name>Bytes Java Primitive Tools</name>

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -749,7 +749,7 @@ public Bytes transform(BytesTransformer transformer) {
      * @return true if not empty and only contains zero byte values
      */
     public boolean validateNotOnlyZeros() {
-        return !validate(BytesValidators.onlyOf((byte) 0));
+        return validate(BytesValidators.notOnlyOf((byte) 0));
     }
 
     /**

src/main/java/at/favre/lib/bytes/BytesValidator.java

@@ -39,7 +39,7 @@ public interface BytesValidator {
      */
     final class Length implements BytesValidator {
         enum Mode {
-            SMALLER_THAN, GREATER_THAN, EXACT
+            SMALLER_OR_EQ_THAN, GREATER_OR_EQ_THAN, EXACT
         }
 
         private final int refLength;
@@ -53,10 +53,10 @@ public Length(int refLength, Mode mode) {
         @Override
         public boolean validate(byte[] byteArrayToValidate) {
             switch (mode) {
-                case GREATER_THAN:
-                    return byteArrayToValidate.length > refLength;
-                case SMALLER_THAN:
-                    return byteArrayToValidate.length < refLength;
+                case GREATER_OR_EQ_THAN:
+                    return byteArrayToValidate.length >= refLength;
+                case SMALLER_OR_EQ_THAN:
+                    return byteArrayToValidate.length <= refLength;
                 default:
                 case EXACT:
                     return byteArrayToValidate.length == refLength;
@@ -69,21 +69,33 @@ public boolean validate(byte[] byteArrayToValidate) {
      * Checks if a byte array contains only the same value
      */
     final class IdenticalContent implements BytesValidator {
-        final byte refByte;
+        private final byte refByte;
 
+        enum Mode {
+            ONLY_OF, NONE_OF, NOT_ONLY_OF
+        }
+
+        private final Mode mode;
 
-        IdenticalContent(byte refByte) {
+        IdenticalContent(byte refByte, Mode mode) {
             this.refByte = refByte;
+            this.mode = mode;
         }
 
         @Override
         public boolean validate(byte[] byteArrayToValidate) {
             for (byte b : byteArrayToValidate) {
-                if (b != refByte) {
+                if (mode == Mode.NONE_OF && b == refByte) {
+                    return false;
+                }
+                if (mode == Mode.ONLY_OF && b != refByte) {
                     return false;
                 }
+                if (mode == Mode.NOT_ONLY_OF && b != refByte) {
+                    return true;
+                }
             }
-            return true;
+            return mode == Mode.NONE_OF || mode == Mode.ONLY_OF;
         }
     }
 }

src/main/java/at/favre/lib/bytes/BytesValidators.java

@@ -32,22 +32,30 @@ private BytesValidators() {
     /**
      * Checks the length of a byte array
      *
-     * @param value to check against
+     * @param byteLength to check against
      * @return true if longer than given value
      */
-    public static BytesValidator longerThan(int value) {
-        return new BytesValidator.Length(value, BytesValidator.Length.Mode.GREATER_THAN);
+    public static BytesValidator atLeast(int byteLength) {
+        return new BytesValidator.Length(byteLength, BytesValidator.Length.Mode.GREATER_OR_EQ_THAN);
     }
 
-    public static BytesValidator shorterThan(int value) {
-        return new BytesValidator.Length(value, BytesValidator.Length.Mode.SMALLER_THAN);
+    public static BytesValidator atMost(int byteLength) {
+        return new BytesValidator.Length(byteLength, BytesValidator.Length.Mode.SMALLER_OR_EQ_THAN);
     }
 
-    public static BytesValidator exactLength(int value) {
-        return new BytesValidator.Length(value, BytesValidator.Length.Mode.EXACT);
+    public static BytesValidator exactLength(int byteLength) {
+        return new BytesValidator.Length(byteLength, BytesValidator.Length.Mode.EXACT);
     }
 
     public static BytesValidator onlyOf(byte value) {
-        return new BytesValidator.IdenticalContent(value);
+        return new BytesValidator.IdenticalContent(value, BytesValidator.IdenticalContent.Mode.ONLY_OF);
+    }
+
+    public static BytesValidator notOnlyOf(byte value) {
+        return new BytesValidator.IdenticalContent(value, BytesValidator.IdenticalContent.Mode.NOT_ONLY_OF);
+    }
+
+    public static BytesValidator noneOf(byte value) {
+        return new BytesValidator.IdenticalContent(value, BytesValidator.IdenticalContent.Mode.NONE_OF);
     }
 }

src/test/java/at/favre/lib/bytes/BytesValidatorTest.java

@@ -36,19 +36,25 @@ public void testOnlyOfValidator() throws Exception {
         assertTrue(Bytes.wrap(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 1}).validateNotOnlyZeros());
         assertTrue(Bytes.random(128).validateNotOnlyZeros());
 
-        assertTrue(Bytes.allocate(0).validate(BytesValidators.onlyOf((byte) 0)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.onlyOf((byte) 0)));
+        assertFalse(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 0)));
+        assertFalse(Bytes.allocate(1).validate(BytesValidators.onlyOf((byte) 1)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 1)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 1)));
+        assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 0, 1}).validate(BytesValidators.notOnlyOf((byte) 1)));
+        assertFalse(Bytes.wrap(new byte[]{1, 1, 1, 1, 1}).validate(BytesValidators.notOnlyOf((byte) 1)));
         assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 1, 1}).validate(BytesValidators.onlyOf((byte) 1)));
     }
 
     @Test
     public void testLengthValidators() throws Exception {
-        assertFalse(Bytes.allocate(0).validate(BytesValidators.longerThan(1)));
-        assertFalse(Bytes.allocate(1).validate(BytesValidators.longerThan(1)));
-        assertTrue(Bytes.allocate(2).validate(BytesValidators.longerThan(1)));
+        assertFalse(Bytes.allocate(0).validate(BytesValidators.atLeast(1)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.atLeast(1)));
+        assertTrue(Bytes.allocate(2).validate(BytesValidators.atLeast(1)));
 
-        assertFalse(Bytes.allocate(2).validate(BytesValidators.shorterThan(1)));
-        assertFalse(Bytes.allocate(1).validate(BytesValidators.shorterThan(1)));
-        assertTrue(Bytes.allocate(0).validate(BytesValidators.shorterThan(1)));
+        assertFalse(Bytes.allocate(2).validate(BytesValidators.atMost(1)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.atMost(1)));
+        assertTrue(Bytes.allocate(0).validate(BytesValidators.atMost(1)));
 
         assertFalse(Bytes.allocate(0).validate(BytesValidators.exactLength(1)));
         assertTrue(Bytes.allocate(1).validate(BytesValidators.exactLength(1)));