New?

.gitignore

@@ -0,0 +1,22 @@
+## Maven specific 
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+
+## Java specific
+*.class
+*.jar
+*.war
+*.ear
+hs_err_pid*
+
+## JetBrains IntelliJ
+/*.iml
+.idea/
+out/
+*.ipr
+*.iws
+

README.md

@@ -1,2 +1,19 @@
-single
+Single
 ======
+
+Traditional Operative Systems have several sources of input: keyboard, mouse, track pad, video camera, microphone etc.
+
+Such a massive amount of different inputs is used to perform several actions from the OS. However, there are some
+people that, for several health reasons, could not easily control such input devices.
+
+We decided to go design an application that could handle the bare minimum input information. Single is going to be
+designed to respond to a single boolean input per time.
+
+The idea is to construct a flexible framework that could host several application, the initial idea is to introduce a
+set of application to improve the life quality of the users:
+ 1) Write, will allowed the user to compose texts using a single input.
+ 2) Play some musics
+ 3) Play a movie
+ 4) Browser internet
+
+In future step will be to integrate the application with the most famous social media.

pom.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.single</groupId>
+    <artifactId>single</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <!-- Platform independent build -->
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <!-- Dependencies versions -->
+        <junit.version>4.11</junit.version>
+        <!-- Plugin versions -->
+        <maven-compiler-plugin.version>3.1</maven-compiler-plugin.version>
+        <maven-compiler-plugin.source>1.7</maven-compiler-plugin.source>
+        <maven-compiler-plugin.target>1.7</maven-compiler-plugin.target>
+    </properties>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven-compiler-plugin.source}</source>
+                    <target>${maven-compiler-plugin.target}</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.17</version>
+                <configuration>
+                    <parallel>methods</parallel>
+                    <threadCount>10</threadCount>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/org/single/core/Axis.java

@@ -0,0 +1,19 @@
+package org.single.core;
+
+public enum Axis {
+    X("X"),
+    Y("Y");
+
+    private String value;
+
+    private Axis(String value){
+        this.value = value;
+    }
+
+    @Override
+    public String toString() {
+        return "Axis{" +
+                "String=" + value +
+                '}';
+    }
+}

src/IntegerDomainError.java → src/main/java/org/single/core/IntegerDomainError.java

@@ -1,9 +1,12 @@
+package org.single.core;
+
+
 public class IntegerDomainError extends RuntimeException {
 
     private final int runtimeValue;
     private final int constraint;
 
-    public IntegerDomainError(String message,int runtimeValue, int constraint){
+    public IntegerDomainError(String message, int runtimeValue, int constraint) {
         super(message);
         this.runtimeValue = runtimeValue;
         this.constraint = constraint;

src/OneDimensionScanner.java → src/main/java/org/single/core/OneDimensionScanner.java

@@ -1,9 +1,12 @@
+package org.single.core;
+
 public class OneDimensionScanner implements Scanner {
 
     private static final int VALUE_Y = 0;
     private final Position maxPosition;
     private Position current;
     private final Position startPosition;
+    private Axis scanningAxis = Axis.X;
 
     public OneDimensionScanner(int numberOfCells,int initialPosition){
         RunTimeChecks.checkGreaterThan(numberOfCells, 0, "Error with the number of cells");
@@ -19,9 +22,7 @@ public OneDimensionScanner(int numberOfCells,int initialPosition){
 
     @Override
     public Position next() {
-        int nextX = current.getX()+1;
-        if (nextX > maxPosition.getX())
-            nextX = 0;
+        int nextX = moveNextOneDimension(current.getX(),maxPosition.getX());
         current = new Position(nextX,current.getY());
         return current;
     }
@@ -49,8 +50,8 @@ public Position getCurrentPosition() {
     }
 
     @Override
-    public Position switchScanningAxis() {
-        return current;
+    public Axis switchScanningAxis() {
+        return scanningAxis;
     }
 
     @Override
@@ -61,4 +62,12 @@ public String toString() {
                 ", startPosition=" + startPosition +
                 '}';
     }
+
+    static int moveNextOneDimension(int current,int maxPosition){
+        int nextX = current+1;
+        if (nextX > maxPosition){
+            nextX = 0;
+        }
+        return nextX;
+    }
 }

src/main/java/org/single/core/Position.java

@@ -0,0 +1,32 @@
+package org.single.core;
+
+
+public class Position {
+
+    private static final int MINIMUM_VALUE = -1;
+    private final int x;
+    private final int y;
+
+    public Position(int x, int y) {
+        RunTimeChecks.checkGreaterThan(x, MINIMUM_VALUE, "Negative value are not allowed for x axis");
+        RunTimeChecks.checkGreaterThan(y, MINIMUM_VALUE, "Negative value are not allowed for y axis");
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    @Override
+    public String toString() {
+        return "Position{" +
+                "x=" + x +
+                ", y=" + y +
+                '}';
+    }
+}

src/main/java/org/single/core/RunTimeChecks.java

@@ -0,0 +1,56 @@
+package org.single.core;
+
+
+public final class RunTimeChecks {
+
+    private RunTimeChecks(){
+    }
+
+    public static void suppressUnusedVariableGitWarning(Object obj) {
+        checkNotNull(obj, "");
+    }
+
+    private static String hereAt(int levelUpInTheStack) {
+        StackTraceElement ste = Thread.currentThread().getStackTrace()[levelUpInTheStack];
+        return ste.toString();
+    }
+
+    public static void checkNotNull(Object toCheck, String message) {
+        final int levelUpInTheStack = 3;
+        if (toCheck == null) {
+            throw new IllegalArgumentException(hereAt(levelUpInTheStack) + " error: " + message);
+        }
+    }
+
+    public static void checkGreaterThan(int runtimeValue, int constraint, String message) {
+        if (runtimeValue <= constraint) {
+            throw new IntegerDomainError(
+                    message.concat(": the runtime value ").concat(String.valueOf(runtimeValue)).
+                            concat(" has to be greater than constraint ").concat(String.valueOf(constraint)),
+                    runtimeValue,
+                    constraint);
+        }
+    }
+
+    public static void checkWithinIntervalInclusive(int runtimeValue, int minValue, int maxValue, String message) {
+        if (minValue > maxValue) {
+            throw new IntegerDomainError(
+                    "Invalid inclusive interval, min value greater than max value", minValue, maxValue);
+        }
+        if (runtimeValue < minValue) {
+            throw new IntegerDomainError(
+                    message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue))
+                            .concat(" is less then ").concat(String.valueOf(minValue)),
+                    runtimeValue,
+                    minValue);
+        }
+        if (runtimeValue > maxValue) {
+            throw new IntegerDomainError(
+                    message.concat("Invalid run time value ").concat(String.valueOf(runtimeValue))
+                            .concat(" is greater then ").concat(String.valueOf(maxValue)),
+                    runtimeValue,
+                    maxValue);
+
+        }
+    }
+}

src/main/java/org/single/core/Scanner.java

@@ -0,0 +1,14 @@
+package org.single.core;
+
+public interface Scanner {
+
+    Position next();
+
+    Position reset();
+
+    void setNewPosition(Position position);
+
+    Position getCurrentPosition();
+
+    Axis switchScanningAxis();
+}