Add validators

Author: patrickfav

CHANGELOG

@@ -2,6 +2,9 @@
 
 ## v0.3.0
 
+* better type hierarchy with read-only and mutable types
+* add validator feature
+
 ## v0.2.0
 
 initial version

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

@@ -690,6 +690,32 @@ public Bytes transform(BytesTransformer transformer) {
         return factory.wrap(transformer.transform(internalArray(), isMutable()), byteOrder);
     }
 
+    /* VALIDATORS ***************************************************************************************************/
+
+    /**
+     * Checks the content of each byte for 0 values
+     *
+     * @return true if not empty and only contains zero byte values
+     */
+    public boolean validateNotOnlyZeros() {
+        return !validate(BytesValidators.onlyOf((byte) 0));
+    }
+
+    /**
+     * Applies all given validators and returns true if all of them return true
+     *
+     * @param bytesValidators array of validators to check against the byte array
+     * @return true if all validators return true
+     */
+    public boolean validate(BytesValidator... bytesValidators) {
+        Objects.requireNonNull(bytesValidators);
+        boolean valid = true;
+        for (BytesValidator bytesValidator : bytesValidators) {
+            valid &= bytesValidator.validate(internalArray());
+        }
+        return valid;
+    }
+
     /* ATTRIBUTES ************************************************************************************************/
 
     /**

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

@@ -0,0 +1,68 @@
+package at.favre.lib.bytes;
+
+/**
+ * Interface for validating byte arrays
+ */
+public interface BytesValidator {
+
+    /**
+     * Validates given byte array
+     *
+     * @param byteArrayToValidate array, must not be altered, only read
+     * @return true if validation is successful, false otherwise
+     */
+    boolean validate(byte[] byteArrayToValidate);
+
+    /**
+     * Validates for specific array length
+     */
+    final class Length implements BytesValidator {
+        enum Mode {
+            SMALLER_THAN, GREATER_THAN, EXACT
+        }
+
+        private final int refLength;
+        private final Mode mode;
+
+        public Length(int refLength, Mode mode) {
+            this.refLength = refLength;
+            this.mode = mode;
+        }
+
+        @Override
+        public boolean validate(byte[] byteArrayToValidate) {
+            switch (mode) {
+                case GREATER_THAN:
+                    return byteArrayToValidate.length > refLength;
+                case SMALLER_THAN:
+                    return byteArrayToValidate.length < refLength;
+                default:
+                case EXACT:
+                    return byteArrayToValidate.length == refLength;
+            }
+        }
+    }
+
+
+    /**
+     * Checks if a byte array contains only the same value
+     */
+    final class IdenticalContent implements BytesValidator {
+        final byte refByte;
+
+
+        IdenticalContent(byte refByte) {
+            this.refByte = refByte;
+        }
+
+        @Override
+        public boolean validate(byte[] byteArrayToValidate) {
+            for (byte b : byteArrayToValidate) {
+                if (b != refByte) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package at.favre.lib.bytes;
+
+/**
+ * Util and easy access for {@link BytesValidators}
+ */
+public class BytesValidators {
+    /**
+     * Checks the length of a byte array
+     *
+     * @param value 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 shorterThan(int value) {
+        return new BytesValidator.Length(value, BytesValidator.Length.Mode.SMALLER_THAN);
+    }
+
+    public static BytesValidator exactLength(int value) {
+        return new BytesValidator.Length(value, BytesValidator.Length.Mode.EXACT);
+    }
+
+    public static BytesValidator onlyOf(byte value) {
+        return new BytesValidator.IdenticalContent(value);
+    }
+}

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 Patrick Favre-Bulle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package at.favre.lib.bytes;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class BytesValidatorTest extends ABytesTest {
+
+    @Test
+    public void testOnlyOfValidator() throws Exception {
+        assertFalse(Bytes.allocate(0).validateNotOnlyZeros());
+        assertFalse(Bytes.allocate(2).validateNotOnlyZeros());
+        assertTrue(Bytes.wrap(example_bytes_seven).validateNotOnlyZeros());
+        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.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(2).validate(BytesValidators.shorterThan(1)));
+        assertFalse(Bytes.allocate(1).validate(BytesValidators.shorterThan(1)));
+        assertTrue(Bytes.allocate(0).validate(BytesValidators.shorterThan(1)));
+
+        assertFalse(Bytes.allocate(0).validate(BytesValidators.exactLength(1)));
+        assertTrue(Bytes.allocate(1).validate(BytesValidators.exactLength(1)));
+        assertFalse(Bytes.allocate(2).validate(BytesValidators.exactLength(1)));
+    }
+}