1 files changed, 82 insertions, 82 deletions
diff --git a/src/main/java/com/iciql/NestedConditions.java b/src/main/java/com/iciql/NestedConditions.java
index 5c92a86..c60645c 100644
--- a/src/main/java/com/iciql/NestedConditions.java
+++ b/src/main/java/com/iciql/NestedConditions.java
@@ -19,114 +19,114 @@ package com.iciql;
 
 public abstract class NestedConditions<T> {
 
-	public static class And<T> extends NestedConditions<T> {
+    public static class And<T> extends NestedConditions<T> {
 
-		public And(Db db, T alias) {
-			super(db, alias);
-		}
+        public And(Db db, T alias) {
+            super(db, alias);
+        }
 
-		protected QueryCondition<T, Boolean> and(boolean x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Boolean> and(boolean x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Byte> and(byte x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Byte> and(byte x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Short> and(short x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Short> and(short x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Integer> and(int x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Integer> and(int x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Long> and(long x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Long> and(long x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Float> and(float x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Float> and(float x) {
+            return where.and(x);
+        }
 
-		protected QueryCondition<T, Double> and(double x) {
-			return where.and(x);
-		}
+        protected QueryCondition<T, Double> and(double x) {
+            return where.and(x);
+        }
 
-		protected <A> QueryCondition<T, A> and(A x) {
-			return where.and(x);
-		}
+        protected <A> QueryCondition<T, A> and(A x) {
+            return where.and(x);
+        }
 
-		protected QueryWhere<T> and(And<T> conditions) {
-			where.andOpen();
-			where.query.addConditionToken(conditions.where.query);
-			return where.close();
-		}
+        protected QueryWhere<T> and(And<T> conditions) {
+            where.andOpen();
+            where.query.addConditionToken(conditions.where.query);
+            return where.close();
+        }
 
-		protected QueryWhere<T> and(Or<T> conditions) {
-			where.andOpen();
-			where.query.addConditionToken(conditions.where.query);
-			return where.close();
-		}
+        protected QueryWhere<T> and(Or<T> conditions) {
+            where.andOpen();
+            where.query.addConditionToken(conditions.where.query);
+            return where.close();
+        }
 
-	}
+    }
 
-	public static class Or<T> extends NestedConditions<T> {
+    public static class Or<T> extends NestedConditions<T> {
 
-		public Or(Db db, T alias) {
-			super(db, alias);
-		}
+        public Or(Db db, T alias) {
+            super(db, alias);
+        }
 
-		protected QueryCondition<T, Boolean> or(boolean x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Boolean> or(boolean x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Byte> or(byte x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Byte> or(byte x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Short> or(short x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Short> or(short x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Integer> or(int x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Integer> or(int x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Long> or(long x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Long> or(long x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Float> or(float x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Float> or(float x) {
+            return where.or(x);
+        }
 
-		protected QueryCondition<T, Double> or(double x) {
-			return where.or(x);
-		}
+        protected QueryCondition<T, Double> or(double x) {
+            return where.or(x);
+        }
 
-		protected <A> QueryCondition<T, A> or(A x) {
-			return where.or(x);
-		}
+        protected <A> QueryCondition<T, A> or(A x) {
+            return where.or(x);
+        }
 
-		protected QueryWhere<T> or(And<T> conditions) {
-			where.orOpen();
-			where.query.addConditionToken(conditions.where.query);
-			return where.close();
-		}
+        protected QueryWhere<T> or(And<T> conditions) {
+            where.orOpen();
+            where.query.addConditionToken(conditions.where.query);
+            return where.close();
+        }
 
-		protected QueryWhere<T> or(Or<T> conditions) {
-			where.orOpen();
-			where.query.addConditionToken(conditions.where.query);
-			return where.close();
-		}
+        protected QueryWhere<T> or(Or<T> conditions) {
+            where.orOpen();
+            where.query.addConditionToken(conditions.where.query);
+            return where.close();
+        }
 
-	}
+    }
 
-	QueryWhere<T> where;
+    QueryWhere<T> where;
 
-	private NestedConditions(Db db, T alias) {
-		where = new QueryWhere<T>(Query.rebuild(db, alias));
-	}
+    private NestedConditions(Db db, T alias) {
+        where = new QueryWhere<T>(Query.rebuild(db, alias));
+    }
 
 }