Refactoring.

sugar-cubes-library/src/main/java/org/sugarcubes/builder/Builders.java

@@ -2,7 +2,7 @@
 
 import java.util.function.Supplier;
 
-import org.sugarcubes.arg.Arg;
+import org.sugarcubes.check.Args;
 
 /**
  * {@link Builder}s factory.
@@ -21,7 +21,7 @@ public class Builders {
      * @return builder returning {@code value}
      */
     public static <T> Builder<T> of(T value) {
-        Arg.notNull(value, "value must not be null");
+        Args.notNull(value, "value must not be null");
         return () -> value;
     }
 

sugar-cubes-library/src/main/java/org/sugarcubes/check/Args.java

@@ -0,0 +1,26 @@
+package org.sugarcubes.check;
+
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * Arguments validator.
+ *
+ * @author Maxim Butov
+ */
+public class Args {
+
+    public static <T> T check(T arg, Predicate<T> predicate, Supplier<String> message) {
+        return Checks.check(arg, predicate, IllegalArgumentException::new, message);
+    }
+
+    public static <T> T notNull(T arg, Supplier<String> message) {
+        return check(arg, Objects::nonNull, message);
+    }
+
+    public static <T> T notNull(T arg, String format, Object... args) {
+        return notNull(arg, Checks.format(format, args));
+    }
+
+}

sugar-cubes-library/src/main/java/org/sugarcubes/check/Checks.java

@@ -0,0 +1,33 @@
+package org.sugarcubes.check;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * Arguments validator.
+ *
+ * @author Maxim Butov
+ */
+public class Checks {
+
+    public static Supplier<String> format(String format) {
+        return () -> format;
+    }
+
+    public static Supplier<String> format(String format, Object... args) {
+        return () -> String.format(format, args);
+    }
+
+    public static <T> T check(T arg, Predicate<T> predicate, Supplier<RuntimeException> exception) {
+        if (!predicate.test(arg)) {
+            throw exception.get();
+        }
+        return arg;
+    }
+
+    public static <T> T check(T arg, Predicate<T> predicate, Function<String, RuntimeException> error, Supplier<String> message) {
+        return check(arg, predicate, () -> error.apply(message.get()));
+    }
+
+}

sugar-cubes-library/src/main/java/org/sugarcubes/check/States.java

@@ -0,0 +1,26 @@
+package org.sugarcubes.check;
+
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * State validator.
+ *
+ * @author Maxim Butov
+ */
+public class States {
+
+    public static <T> T check(T arg, Predicate<T> predicate, Supplier<String> message) {
+        return Checks.check(arg, predicate, IllegalStateException::new, message);
+    }
+
+    public static <T> T notNull(T arg, Supplier<String> message) {
+        return check(arg, Objects::nonNull, message);
+    }
+
+    public static <T> T notNull(T arg, String format, Object... args) {
+        return notNull(arg, Checks.format(format, args));
+    }
+
+}

sugar-cubes-library/src/main/java/org/sugarcubes/cloner/ReflectionCloner.java

@@ -35,8 +35,8 @@
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import org.sugarcubes.arg.Arg;
 import org.sugarcubes.builder.collection.SetBuilder;
+import org.sugarcubes.check.Args;
 import org.sugarcubes.reflection.XField;
 import org.sugarcubes.reflection.XMethod;
 import org.sugarcubes.reflection.XReflection;
@@ -68,7 +68,7 @@ public ReflectionCloner() {
      */
     public ReflectionCloner(ClonerObjectFactory objectFactory) {
 
-        Arg.notNull(objectFactory, "objectFactory is null");
+        Args.notNull(objectFactory, "objectFactory is null");
         this.objectFactory = objectFactory;
 
         initialize();
@@ -181,7 +181,7 @@ public ReflectionCloner skipFields(Predicate<Field> fieldFilter) {
      */
     public ReflectionCloner skipModifiers(int modifier, int... modifiers) {
         int modifiersToExclude = IntStream.of(modifiers).reduce(modifier, (x, y) -> x | y);
-        return skipFields(field -> XReflection.of(field).isModifier(modifiersToExclude));
+        return skipFields(field -> (field.getModifiers() & modifiersToExclude) != 0);
     }
 
     /**
@@ -323,7 +323,7 @@ private static <X> boolean anyMatch(Stream<Predicate<X>> predicates, X x) {
     }
 
     private static <X> Set<X> asSet(X first, X... others) {
-        Arg.notNull(first, "first argument must be not null");
+        Args.notNull(first, "first argument must be not null");
         return SetBuilder.<X>hashSet().add(first).addAll(others).build();
     }
 

sugar-cubes-library/src/main/java/org/sugarcubes/function/Predicates.java

@@ -0,0 +1,29 @@
+package org.sugarcubes.function;
+
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+/**
+ * todo: document it
+ *
+ * @author Maxim Butov
+ */
+public class Predicates {
+
+    public static <T> Predicate<T> not(Predicate<T> predicate) {
+        return predicate.negate();
+    }
+
+    public static <T> Predicate<T> and(Predicate<T> first, Predicate<T> second, Predicate<T>... rest) {
+        return Stream.of(rest).reduce(first.and(second), Predicate::and);
+    }
+
+    public static <T> Predicate<T> or(Predicate<T> first, Predicate<T> second, Predicate<T>... rest) {
+        return Stream.of(rest).reduce(first.or(second), Predicate::or);
+    }
+
+    public static <T> Predicate<T> xor(Predicate<T> first, Predicate<T> second) {
+        return (T t) -> first.test(t) ^ second.test(t);
+    }
+
+}

sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XClass.java

@@ -5,7 +5,7 @@
 import java.util.stream.Stream;
 import static java.util.Arrays.stream;
 
-import org.sugarcubes.arg.Arg;
+import org.sugarcubes.check.Args;
 import static org.sugarcubes.reflection.XPredicates.withName;
 import static org.sugarcubes.reflection.XPredicates.withNameAndParameterTypes;
 import static org.sugarcubes.reflection.XPredicates.withParameterTypes;
@@ -23,7 +23,7 @@ public class XClass<C> extends XReflectionObjectImpl<Class<C>> implements XAnnot
     private final Class<C> reflectionObject;
 
     XClass(Class<C> reflectionObject) {
-        this.reflectionObject = Arg.notNull(reflectionObject, "Class must not be null");
+        this.reflectionObject = Args.notNull(reflectionObject, "Class must not be null");
     }
 
     @Override

sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XField.java

@@ -3,7 +3,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 
-import org.sugarcubes.arg.Arg;
+import org.sugarcubes.check.Args;
 import static org.sugarcubes.reflection.XReflectionUtils.execute;
 
 /**
@@ -59,14 +59,8 @@ public T put(Object obj, T value) {
         return oldValue;
     }
 
-    public T copy(Object from, Object to) {
-        T value = get(from);
-        set(to, value);
-        return value;
-    }
-
-    public XFieldAccessor<T> getAccessor(Object obj) {
-        return new XFieldAccessorImpl<>(this, obj);
+    public XObjectFieldAccessor<T> getAccessor(Object obj) {
+        return new XObjectFieldAccessorImpl<>(obj, this);
     }
 
     public <X> XField<X> cast() {
@@ -79,7 +73,7 @@ public XField<T> withModifiers(int modifiers) {
     }
 
     public XField<T> withModifier(int modifier, boolean newValue) {
-        Arg.check(modifier, XModifiers::isValidModifier, () -> "Invalid modifier 0x" + Integer.toHexString(modifier));
+        Args.check(modifier, XModifiers::isValidModifier, () -> "Invalid modifier 0x" + Integer.toHexString(modifier));
         int newModifiers = newValue ? modifiers | modifier : modifiers & ~modifier;
         return withModifiers(newModifiers);
     }

sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XObjectFieldAccessor.java

@@ -0,0 +1,24 @@
+package org.sugarcubes.reflection;
+
+/**
+ * @author Maxim Butov
+ */
+public interface XObjectFieldAccessor<T> {
+
+    Object getObject();
+
+    XField<T> getField();
+
+    default T get() {
+        return getField().get(getObject());
+    }
+
+    default void set(T value) {
+        getField().set(getObject(), value);
+    }
+
+    default T put(T value) {
+        return getField().put(getObject(), value);
+    }
+
+}

sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XFieldAccessorImpl.java → sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XObjectFieldAccessorImpl.java

@@ -2,17 +2,19 @@
 
 import java.util.Objects;
 
+import org.sugarcubes.check.Args;
+
 /**
  * @author Maxim Butov
  */
-class XFieldAccessorImpl<T> implements XFieldAccessor<T> {
+class XObjectFieldAccessorImpl<T> implements XObjectFieldAccessor<T> {
 
     private final XField<T> xField;
     private final Object obj;
 
-    XFieldAccessorImpl(XField<T> xField, Object obj) {
-        this.xField = xField;
-        this.obj = obj;
+    XObjectFieldAccessorImpl(Object obj, XField<T> xField) {
+        this.obj = Args.notNull(obj, "obj must not be null");
+        this.xField = Args.notNull(xField, "field must not be null");
     }
 
     @Override
@@ -21,29 +23,19 @@ public XField<T> getField() {
     }
 
     @Override
-    public T get() {
-        return xField.get(obj);
-    }
-
-    @Override
-    public void set(T value) {
-        xField.set(obj, value);
-    }
-
-    @Override
-    public T put(T value) {
-        return xField.put(obj, value);
+    public Object getObject() {
+        return obj;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
-        if (!(obj instanceof XFieldAccessorImpl)) {
+        if (!(obj instanceof XObjectFieldAccessorImpl)) {
             return false;
         }
-        XFieldAccessorImpl that = (XFieldAccessorImpl) obj;
+        XObjectFieldAccessorImpl that = (XObjectFieldAccessorImpl) obj;
         return Objects.equals(xField, that.xField) && Objects.equals(this.obj, that.obj);
     }
 

sugar-cubes-library/src/main/java/org/sugarcubes/reflection/XPredicates.java

@@ -2,7 +2,8 @@
 
 import java.util.function.Predicate;
 
-import org.sugarcubes.arg.Arg;
+import org.sugarcubes.check.Args;
+import static org.sugarcubes.function.Predicates.and;
 
 /**
  * Predicates which simplify filtering of class members.
@@ -12,19 +13,17 @@
 public class XPredicates {
 
     public static <X, R extends XReflectionObject<X>> Predicate<R> withName(String name) {
-        Arg.notNull(name, "name must not be null");
+        Args.notNull(name, "name must not be null");
         return obj -> obj.hasName(name);
     }
 
     public static <T, R extends XExecutable<T>> Predicate<R> withParameterTypes(Class... types) {
-        Arg.notNull(types, "types must not be null");
+        Args.notNull(types, "types must not be null");
         return obj -> obj.hasParameterTypes(types);
     }
 
     public static <T, R extends XMethod<T>> Predicate<R> withNameAndParameterTypes(String name, Class... types) {
-        Predicate<R> predicate1 = withName(name);
-        Predicate<R> predicate2 = withParameterTypes(types);
-        return predicate1.and(predicate2);
+        return and(withName(name), withParameterTypes(types));
     }
 
     public static <X, R extends XReflectionObject<X>> Predicate<R> withReflectionObject(Predicate<X> predicate) {