-Java Operator Overloading

- -

Java-OO is a modular extension (plugin) to Java compilers and IDEs -for (Scala-like) Operator Overloading support. -Works with standard JavaC compiler, Netbeans IDE, Eclipse IDE, IntelliJ IDEA IDE and any build tools.

- -

Example (see other examples at examples/ dir):

- -

import java.math.*;
-import java.util.*;
-public class Test {
-  public static void main(String[] args) {
-    BigInteger a = BigInteger.valueOf(1), // without OO
-               b = 2, // with OO
-
-    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO
-    c2 = -a + b*b + b/a; // with OO
-
-    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO
-      System.out.println("impossible");
-    if (c1<c2 || c1>c2) // with OO
-      System.out.println("impossible");
-
-    HashMap<String, String> map = new HashMap<>();
-    if (!map.containsKey("qwe")) map.put("qwe", map.get("asd")); // without OO
-    if (map["qwe"]==null) map["qwe"] = map["asd"]; // with OO
-  }
-}

- -

-Versions

- -

JavaC/Netbeans: 0.5
-JavaC8:         0.5
-Eclipse:        0.5
-IntelliJ IDEA:  0.5
-

- -

Note plugin versions are independent. If version for X > version for Y then it doesn't mean Y is behind feature wise.

- -

-News

- -

14 July 2016. As a workaround Eclipse plugin works fine on Eclipse 4.4+ if you install Scala IDE plugin first.

- -

2 Feb 2016. IntelliJ IDEA plugin v0.5 released with support of IDEA 15. Requires Java8 to run the plugin.

- -

10 April 2015. IntelliJ IDEA plugin v0.4.1 released with support of IDEA 14.1.

- -

27 January 2015. Eclipse-oo-plugin version 0.5 released with support of reverse binary operator overload.

- -

2 December 2014. New feature: Reverse binary operator overload via operatorRev methods.
-Plugin versions updated:
-JavaC7 & JavaC8: 0.5
-IntelliJ IDEA: 0.4. Support of IDEA 14

- -

31 May 2014. Javac8 plugin version 0.1.1 released. Removed runtime depencendy on nbjavac.

- -

24 May 2014. IntelliJ IDEA plugin v0.3.1 released. Bugfixes for IDEA 13 Ultimate and for type resolution for binary expressions with primitives.

- -

30 April 2014. IJPLA published a paper about Java-OO.

- -

3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released. -It has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.

- -

12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released. -Now operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate. -Fixed javac plugin bug with index-set OO.

- -

3 Jan 2014. JavaC plugin version 0.3 released. -Fixed #10 javac: binary operator adds erroneous cast on 1st operand.

- -

8 Sep 2013. Eclipse plugin version 0.3 released. -Removed copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.

- -

14 May 2013. IntelliJ IDEA IDE plugin v0.2.1 with IDEA Ultimate Edition support.

- -

17 Apr 2013. IntelliJ IDEA IDE plugin v0.2.

- -

26 Nov 2012. Version 0.2 released. New feature: Assignment operator overloading via static #valueOf method.

- -

-Installation

- -

-javac, ant, etc

- -

Just add to classpath: javac-oo-plugin.jar for JDK7 or javac8-oo-plugin.jar for JDK8.

- -

javac -cp javac-oo-plugin.jar <sources>
-

- -

Demo at examples/compile.sh

- -

-Eclipse IDE update site

- -

Click in menu: Help - Install New Software. Enter in Work with field:

- -

http://amelentev.github.io/eclipse.jdt-oo-site/
-

- -

Tested on Eclipse Standard 4.3.2. Should work with older versions too.
-To work on 4.4+ you need to install Scala IDE plugin (or similar plugin with Equanox weaving). You can find it in Help -> Eclipse Marketplace. This is workaround until normal solution will be found. Tested on 4.4 and 4.6.

- -

-Netbeans IDE -

- -

Add javac-oo-plugin.jar as compile or processor library to Netbeans.
Enable "Annotation Processing in Editor": Project Properties -> Build -> Compiling.

- -

Tested on 7.2.1

- -

-IntelliJ IDEA IDE

- -

Install Java Operator Overloading support plugin: File -> Settings -> Plugins -> Browse repositories. Mirror: idea-oo-plugin.jar)
-For Maven projects installation is done. IDEA should setup everything according to pom.xml.
-For other project types:
-
Add javac-oo-plugin.jar as compile or processor library.
Enable Annotation Processing: -Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing -
Make sure you use javac compiler in Settings -> Java Compiler -> Use compiler.
-Tested on IDEA 15.0.3 Community and Ultimate Editions.

- -

-Android project in IDEA 12

- -

Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path

- -

-Android Studio (IDEA 13) / Gradle

- -

add to build.gradle:

- -

repositories {
-    maven { url 'http://amelentev.github.io/mvnrepo/' }
-}
-dependencies {
-    compile 'java-oo:javac-oo-plugin:0.5'
-}
-

- -

-Maven

- -

Look at javac-oo-mvndemo/pom.xml

- -

-Details

- -

Read the paper to learn more. -Supported operators (operator to method name map):

- -

binary:

- -

| OPERATOR | METHOD NAME|
--------------------------
-| +        | add        |
-| -        | subtract   |
-| *        | multiply   |
-| /        | divide     |
-| %        | remainder  |
-| &        | and        |
-| |        | or         |
-| ^        | xor        |
-| <<       | shiftLeft  |
-| >>       | shiftRight |
-

- -

If left operand has no such method then the plugin will try to use 'reverse' method <methodName>Rev on right operand. -So 2*a will be transformed to a.multiplyRev(2) if a has such method.

- -

unary:

- -

| -        | negate     |
-| ~        | not        |
-

- -

comparison:

- -

| <, <=, >, >= | compareTo  | example: `a < b` <=> `a.compareTo(b)<0`
-`==` and `!=` are not overloadable because it will break things
-

- -

index:

- -

| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`
-| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`
-

- -

assignment:

- -

| var = expr | var = VarClass.valueOf(expr) |
-

- -

if expr is not assignable to var and var is an instance of VarClass and expr has type ExprType and there are static method VarClass#valueOf(ExprType)
-then var = expr is transformed to var = VarClass.valueOf(expr). -example:
-BigInteger a = 1 is transformed to BigInteger a = BigInteger.valueOf(1)

- -

These methods exists in many java classes (example: BigInteger, BigDecimal) so you can -use operators on them "out of the box". Or you can add these methods to your classes to use OO (see examples/Vector.java).

- -

-Publications

- -

"Java Modular Extension for Operator Overloading", IJPLA, April 2014.

- - - -

import java.math.*;
+import java.math.*;
 import java.util.*;
 public class Test {
     public static void main(String[] args) {
@@ -62,7 +62,7 @@ 
 

 Versions
 
-Javac/Netbeans: 0.2
+Javac/Netbeans: 0.3
 Eclipse:        0.3
 IntelliJ IDEA:  0.2.1
 
@@ -70,6 +70,9 @@ 
 

 News
 
+3 Jan 2014. JavaC plugin version 0.3 released.
+Fixed #10 javac: binary operator adds erroneous cast on 1st operand.
+
 8 Sep 2013. Eclipse plugin version 0.3 released.
 Removed copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.
 
@@ -85,7 +88,7 @@ 
 

 javac, ant, etc
 
-Just add javac-oo-plugin.jar to classpath:
+Just add javac-oo-plugin.jar to classpath:
 
 javac -cp javac-oo-plugin.jar <sources>
 
@@ -107,7 +110,7 @@ 
 
 
 
-Add javac-oo-plugin.jar as compile or processor library to Netbeans.
+Add javac-oo-plugin.jar as compile or processor library to Netbeans.
 Enable "Annotation Processing in Editor": Project Properties -> Build -> Compiling.
 
Tested on 7.2.1
 
@@ -121,7 +124,7 @@ 
 For Maven projects installation is done. IDEA should setup everything according to pom.xml. 

 For other project types: 

 
-Add javac-oo-plugin.jar as compile or processor library.
+Add javac-oo-plugin.jar as compile or processor library.
 Enable Annotation Processing:
 Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing
 
@@ -130,7 +133,7 @@ 

 

 Android project in IDEA 12
 
-Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
+Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
 
 
 Android Studio (IDEA 13) / Gradle
diff --git a/params.json b/params.json
index ad1f833..877289f 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nImplementation of ([Scala-like]) [Operator Overloading] for Java language.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n\tpublic static void main(String[] args) {\r\n\t\tBigInteger  a = BigInteger.valueOf(1), // without OO\r\n\t\t\t\tb = 2, // with OO\r\n\r\n\t\t\t\tc1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n\t\t\t\tc2 = -a + b*b + b/a; // with OO\r\n\r\n\t\tif (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println(\"impossible\"); // without OO\r\n\t\tif (c1c2) System.out.println(\"impossible\"); // with OO\r\n\r\n\t\tHashMap map = new HashMap<>();\r\n\t\tif (!map.containsKey(\"qwe\")) map.put(\"qwe\", \"asd\"); // without OO\r\n\t\tif (map[\"qwe\"]==null) map[\"qwe\"] = \"asd\"; // with OO\r\n\t}\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.2\r\n\tEclipse:        0.3\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Implicit type conversion](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3. Should work with older versions.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.2'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD    |\r\n\t------------------------\r\n\t| +        | add       |\r\n\t| -        | subtract  |\r\n\t| *        | multiply  |\r\n\t| /        | divide    |\r\n\t| %        | remainder |\r\n\t| &        | and       |\r\n\t| |        | or        |\r\n\t| ^        | xor       |\r\n\t| <<       | shiftLeft |\r\n\t| >>       | shiftRight|\r\n\r\nunary:\r\n\r\n\t| - | negate |\r\n\t| ~ | not    |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` is not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nImplicit type conversion:\r\n\r\nif _expression_ has type _ExpressionType_ and there are static method _RequredType RequredType#valueOf(ExpressionType)_
 \r\nthen _expression_ can be assigned to _RequredType_.\r\nexample: 
\r\n`BigInteger a = 1` translates to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.2/javac-oo-plugin-0.2.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nImplementation of ([Scala-like]) [Operator Overloading] for Java language.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n\tpublic static void main(String[] args) {\r\n\t\tBigInteger  a = BigInteger.valueOf(1), // without OO\r\n\t\t\t\tb = 2, // with OO\r\n\r\n\t\t\t\tc1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n\t\t\t\tc2 = -a + b*b + b/a; // with OO\r\n\r\n\t\tif (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println(\"impossible\"); // without OO\r\n\t\tif (c1c2) System.out.println(\"impossible\"); // with OO\r\n\r\n\t\tHashMap map = new HashMap<>();\r\n\t\tif (!map.containsKey(\"qwe\")) map.put(\"qwe\", \"asd\"); // without OO\r\n\t\tif (map[\"qwe\"]==null) map[\"qwe\"] = \"asd\"; // with OO\r\n\t}\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.3\r\n\tEclipse:        0.3\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Implicit type conversion](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3. Should work with older versions.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.2'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD    |\r\n\t------------------------\r\n\t| +        | add       |\r\n\t| -        | subtract  |\r\n\t| *        | multiply  |\r\n\t| /        | divide    |\r\n\t| %        | remainder |\r\n\t| &        | and       |\r\n\t| |        | or        |\r\n\t| ^        | xor       |\r\n\t| <<       | shiftLeft |\r\n\t| >>       | shiftRight|\r\n\r\nunary:\r\n\r\n\t| - | negate |\r\n\t| ~ | not    |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` is not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nImplicit type conversion:\r\n\r\nif _expression_ has type _ExpressionType_ and there are static method _RequredType RequredType#valueOf(ExpressionType)_
 \r\nthen _expression_ can be assigned to _RequredType_.\r\nexample: 
\r\n`BigInteger a = 1` translates to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.3.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
diff --git a/stylesheets/stylesheet.css b/stylesheets/stylesheet.css
index b48c8a8..7a08b01 100644
--- a/stylesheets/stylesheet.css
+++ b/stylesheets/stylesheet.css
@@ -39,9 +39,6 @@ ol, ul {
   list-style: none;
 }
 
-blockquote, q {
-}
-
 table {
   border-collapse: collapse;
   border-spacing: 0;
@@ -121,14 +118,11 @@ a {
   -ms-transition: text-shadow 0.5s ease;
 }
 
-#main_content a:hover {
-  color: #0069ba;
-  text-shadow: #0090ff 0px 0px 2px;
-}
+a:hover, a:focus {text-decoration: underline;}
 
-footer a:hover {
-  color: #43adff;
-  text-shadow: #0090ff 0px 0px 2px;
+footer a {
+  color: #F2F2F2;
+  text-decoration: underline;
 }
 
 em {
@@ -154,6 +148,15 @@ img {
   -ms-box-shadow: 0 0 5px #ebebeb;
 }
 
+p img {
+  display: inline;
+  margin: 0;
+  padding: 0;
+  vertical-align: middle;
+  text-align: center;
+  border: none;
+}
+
 pre, code {
   width: 100%;
   color: #222;
@@ -165,9 +168,6 @@ pre, code {
   border-radius: 2px;
   -moz-border-radius: 2px;
   -webkit-border-radius: 2px;
-
-
-
 }
 
 pre {
@@ -195,16 +195,17 @@ blockquote {
   border-left: 3px solid #bbb;
 }
 
+
 ul, ol, dl {
   margin-bottom: 15px
 }
 
-ul li {
+ul {
   list-style: inside;
   padding-left: 20px;
 }
 
-ol li {
+ol {
   list-style: decimal inside;
   padding-left: 20px;
 }
@@ -253,11 +254,6 @@ form {
   padding: 20px;
 }
 
-img {
-  width: 100%;
-  max-width: 100%;
-}
-
 /*******************************************************************************
 Full-Width Styles
 *******************************************************************************/

From af425578cfb59014180139c964cc3e7353b32e47 Mon Sep 17 00:00:00 2001
From: Artem Melentyev 
Date: Sat, 11 Jan 2014 13:32:39 -0800
Subject: [PATCH 12/32] Create gh-pages branch via GitHub

---
 index.html  | 22 +++++++++++++---------
 params.json |  2 +-
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/index.html b/index.html
index c75431c..1bd8e5d 100644
--- a/index.html
+++ b/index.html
@@ -62,14 +62,18 @@ 
 
 Versions
 
-Javac/Netbeans: 0.3
-Eclipse:        0.3
+Javac/Netbeans: 0.4
+Eclipse:        0.4
 IntelliJ IDEA:  0.2.1
 
 
 
 News
 
+12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.
+Now operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.
+Fixed javac plugin bug with index-set OO.
+
 3 Jan 2014. JavaC plugin version 0.3 released.
 Fixed #10 javac: binary operator adds erroneous cast on 1st operand.
 
@@ -88,7 +92,7 @@ 
 

 javac, ant, etc
 
-Just add javac-oo-plugin.jar to classpath:
+Just add javac-oo-plugin.jar to classpath:
 
 javac -cp javac-oo-plugin.jar <sources>
 
@@ -103,14 +107,14 @@ 
 http://amelentev.github.io/eclipse.jdt-oo-site/
 
 
-Tested on Eclipse Standard 4.3. Should work with older versions.
+Tested on Eclipse Standard 4.3.1. Should work with older versions.
 
 

 Netbeans IDE
 
 
 
-Add javac-oo-plugin.jar as compile or processor library to Netbeans.
+Add javac-oo-plugin.jar as compile or processor library to Netbeans.
 Enable "Annotation Processing in Editor": Project Properties -> Build -> Compiling.
 
Tested on 7.2.1
 
@@ -124,16 +128,16 @@ 
 For Maven projects installation is done. IDEA should setup everything according to pom.xml. 

 For other project types: 

 
-Add javac-oo-plugin.jar as compile or processor library.
+Add javac-oo-plugin.jar as compile or processor library.
 Enable Annotation Processing:
 Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing
 
-Make sure you use javac compiler in Settings -> Compiler -> Use compiler. 

+
Make sure you use javac compiler in Settings -> Java Compiler -> Use compiler. 

 Tested on IDEA 12.1.3 Community and Ultimate Editions.
 

 Android project in IDEA 12
 
-Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
+Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
 
 
 Android Studio (IDEA 13) / Gradle
@@ -144,7 +148,7 @@ 
     maven { url 'http://amelentev.github.io/mvnrepo/' }
 }
 dependencies {
-    compile 'java-oo:javac-oo-plugin:0.2'
+    compile 'java-oo:javac-oo-plugin:0.4'
 }
 
 
diff --git a/params.json b/params.json
index 877289f..b7d2251 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nImplementation of ([Scala-like]) [Operator Overloading] for Java language.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n\tpublic static void main(String[] args) {\r\n\t\tBigInteger  a = BigInteger.valueOf(1), // without OO\r\n\t\t\t\tb = 2, // with OO\r\n\r\n\t\t\t\tc1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n\t\t\t\tc2 = -a + b*b + b/a; // with OO\r\n\r\n\t\tif (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println(\"impossible\"); // without OO\r\n\t\tif (c1c2) System.out.println(\"impossible\"); // with OO\r\n\r\n\t\tHashMap map = new HashMap<>();\r\n\t\tif (!map.containsKey(\"qwe\")) map.put(\"qwe\", \"asd\"); // without OO\r\n\t\tif (map[\"qwe\"]==null) map[\"qwe\"] = \"asd\"; // with OO\r\n\t}\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.3\r\n\tEclipse:        0.3\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Implicit type conversion](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3. Should work with older versions.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.2'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD    |\r\n\t------------------------\r\n\t| +        | add       |\r\n\t| -        | subtract  |\r\n\t| *        | multiply  |\r\n\t| /        | divide    |\r\n\t| %        | remainder |\r\n\t| &        | and       |\r\n\t| |        | or        |\r\n\t| ^        | xor       |\r\n\t| <<       | shiftLeft |\r\n\t| >>       | shiftRight|\r\n\r\nunary:\r\n\r\n\t| - | negate |\r\n\t| ~ | not    |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` is not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nImplicit type conversion:\r\n\r\nif _expression_ has type _ExpressionType_ and there are static method _RequredType RequredType#valueOf(ExpressionType)_
 \r\nthen _expression_ can be assigned to _RequredType_.\r\nexample: 
\r\n`BigInteger a = 1` translates to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.3.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nImplementation of ([Scala-like]) [Operator Overloading] for Java language.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n\tpublic static void main(String[] args) {\r\n\t\tBigInteger  a = BigInteger.valueOf(1), // without OO\r\n\t\t\t\tb = 2, // with OO\r\n\r\n\t\t\t\tc1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n\t\t\t\tc2 = -a + b*b + b/a; // with OO\r\n\r\n\t\tif (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println(\"impossible\"); // without OO\r\n\t\tif (c1c2) System.out.println(\"impossible\"); // with OO\r\n\r\n\t\tHashMap map = new HashMap<>();\r\n\t\tif (!map.containsKey(\"qwe\")) map.put(\"qwe\", \"asd\"); // without OO\r\n\t\tif (map[\"qwe\"]==null) map[\"qwe\"] = \"asd\"; // with OO\r\n\t}\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.4\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Implicit type conversion](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older versions.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD    |\r\n\t------------------------\r\n\t| +        | add       |\r\n\t| -        | subtract  |\r\n\t| *        | multiply  |\r\n\t| /        | divide    |\r\n\t| %        | remainder |\r\n\t| &        | and       |\r\n\t| |        | or        |\r\n\t| ^        | xor       |\r\n\t| <<       | shiftLeft |\r\n\t| >>       | shiftRight|\r\n\r\nunary:\r\n\r\n\t| - | negate |\r\n\t| ~ | not    |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` is not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nImplicit type conversion:\r\n\r\nif _expression_ has type _ExpressionType_ and there are static method _RequredType RequredType#valueOf(ExpressionType)_
 \r\nthen _expression_ can be assigned to _RequredType_.\r\nexample: 
\r\n`BigInteger a = 1` translates to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.4.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file

From 0ec2ebc2816d70e0b8895f206fbce750c5684f85 Mon Sep 17 00:00:00 2001
From: Artem Melentyev 
Date: Sun, 2 Feb 2014 13:39:24 -0800
Subject: [PATCH 13/32] Create gh-pages branch via GitHub

---
 index.html  | 80 ++++++++++++++++++++++++++++-------------------------
 params.json |  2 +-
 2 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/index.html b/index.html
index 1bd8e5d..6c7a668 100644
--- a/index.html
+++ b/index.html
@@ -34,7 +34,8 @@ Java Operator Overloading
         
 Java Operator Overloading
 
-Implementation of (Scala-like) Operator Overloading for Java language.
+
Java-OO is a modular extension (plugin) to Java compilers and IDEs
+for (Scala-like) Operator Overloading support.
 Works with standard JavaC compiler, Netbeans IDE, Eclipse IDE, IntelliJ IDEA IDE and any build tools.
 
 Example (see other examples at examples/ dir):
@@ -42,20 +43,22 @@ 
 import java.math.*;
 import java.util.*;
 public class Test {
-    public static void main(String[] args) {
-        BigInteger  a = BigInteger.valueOf(1), // without OO
-                b = 2, // with OO
-
-                c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO
-                c2 = -a + b*b + b/a; // with OO
-
-        if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println("impossible"); // without OO
-        if (c1<c2 || c1>c2) System.out.println("impossible"); // with OO
-
-        HashMap<String, String> map = new HashMap<>();
-        if (!map.containsKey("qwe")) map.put("qwe", "asd"); // without OO
-        if (map["qwe"]==null) map["qwe"] = "asd"; // with OO
-    }
+  public static void main(String[] args) {
+    BigInteger a = BigInteger.valueOf(1), // without OO
+               b = 2, // with OO
+
+    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO
+    c2 = -a + b*b + b/a; // with OO
+
+    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO
+      System.out.println("impossible");
+    if (c1<c2 || c1>c2) // with OO
+      System.out.println("impossible");
+
+    HashMap<String, String> map = new HashMap<>();
+    if (!map.containsKey("qwe")) map.put("qwe", map.get("asd")); // without OO
+    if (map["qwe"]==null) map["qwe"] = map["asd"]; // with OO
+  }
 }
 
 
@@ -84,7 +87,7 @@ 

 
 17 Apr 2013. IntelliJ IDEA IDE plugin v0.2.
 
-26 Nov 2012. Version 0.2 released. New feature: Implicit type conversion via static #valueOf method.
+26 Nov 2012. Version 0.2 released. New feature: Assignment operator overloading via static #valueOf method.
 
 

 Installation
@@ -107,7 +110,7 @@ 
 http://amelentev.github.io/eclipse.jdt-oo-site/
 
 
-Tested on Eclipse Standard 4.3.1. Should work with older versions.
+Tested on Eclipse Standard 4.3.1. Should work with older/newer versions too.
 
 

 Netbeans IDE
@@ -162,34 +165,34 @@ 

 

 Details
 
-Supported operators (operator to method map):
+Supported operators (operator to method name map):
 
 binary:
 
-| OPERATOR | METHOD    |
-------------------------
-| +        | add       |
-| -        | subtract  |
-| *        | multiply  |
-| /        | divide    |
-| %        | remainder |
-| &        | and       |
-| |        | or        |
-| ^        | xor       |
-| <<       | shiftLeft |
-| >>       | shiftRight|
+| OPERATOR | METHOD NAME|
+-------------------------
+| +        | add        |
+| -        | subtract   |
+| *        | multiply   |
+| /        | divide     |
+| %        | remainder  |
+| &        | and        |
+| |        | or         |
+| ^        | xor        |
+| <<       | shiftLeft  |
+| >>       | shiftRight |
 
 
 unary:
 
-| - | negate |
-| ~ | not    |
+| -        | negate     |
+| ~        | not        |
 
 
 comparison:
 
 | <, <=, >, >= | compareTo  | example: `a < b` <=> `a.compareTo(b)<0`
-`==` and `!=` is not overloadable because it will break things
+`==` and `!=` are not overloadable because it will break things
 
 
 index:
@@ -198,11 +201,14 @@ 
 | []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`
 
 
-Implicit type conversion:
+assignment:
+
+| var = expr | var = VarClass.valueOf(expr) |
+
 
-if expression has type ExpressionType and there are static method RequredType RequredType#valueOf(ExpressionType)
 
-then expression can be assigned to RequredType.
-example: 
BigInteger a = 1 translates to BigInteger a = BigInteger.valueOf(1)
+if expr is not assignable to var and var is an instance of VarClass and expr has type ExprType and there are static method VarClass#valueOf(ExprType) 

+then var = expr is transformed to var = VarClass.valueOf(expr).
+example: 
BigInteger a = 1 is transformed to BigInteger a = BigInteger.valueOf(1)
 
 These methods exists in many java classes (example: BigInteger, BigDecimal) so you can
 use operators on them "out of the box". Or you can add these methods to your classes to use OO (see examples/Vector.java).
diff --git a/params.json b/params.json
index b7d2251..f5b6813 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nImplementation of ([Scala-like]) [Operator Overloading] for Java language.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n\tpublic static void main(String[] args) {\r\n\t\tBigInteger  a = BigInteger.valueOf(1), // without OO\r\n\t\t\t\tb = 2, // with OO\r\n\r\n\t\t\t\tc1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n\t\t\t\tc2 = -a + b*b + b/a; // with OO\r\n\r\n\t\tif (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) System.out.println(\"impossible\"); // without OO\r\n\t\tif (c1c2) System.out.println(\"impossible\"); // with OO\r\n\r\n\t\tHashMap map = new HashMap<>();\r\n\t\tif (!map.containsKey(\"qwe\")) map.put(\"qwe\", \"asd\"); // without OO\r\n\t\tif (map[\"qwe\"]==null) map[\"qwe\"] = \"asd\"; // with OO\r\n\t}\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.4\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Implicit type conversion](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older versions.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD    |\r\n\t------------------------\r\n\t| +        | add       |\r\n\t| -        | subtract  |\r\n\t| *        | multiply  |\r\n\t| /        | divide    |\r\n\t| %        | remainder |\r\n\t| &        | and       |\r\n\t| |        | or        |\r\n\t| ^        | xor       |\r\n\t| <<       | shiftLeft |\r\n\t| >>       | shiftRight|\r\n\r\nunary:\r\n\r\n\t| - | negate |\r\n\t| ~ | not    |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` is not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nImplicit type conversion:\r\n\r\nif _expression_ has type _ExpressionType_ and there are static method _RequredType RequredType#valueOf(ExpressionType)_
 \r\nthen _expression_ can be assigned to _RequredType_.\r\nexample: 
\r\n`BigInteger a = 1` translates to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.4.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nJava-OO is a modular extension (plugin) to Java compilers and IDEs\r\nfor ([Scala-like]) [Operator Overloading] support.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n  public static void main(String[] args) {\r\n    BigInteger a = BigInteger.valueOf(1), // without OO\r\n               b = 2, // with OO\r\n\r\n    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n    c2 = -a + b*b + b/a; // with OO\r\n\r\n    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO\r\n      System.out.println(\"impossible\");\r\n    if (c1c2) // with OO\r\n      System.out.println(\"impossible\");\r\n\r\n    HashMap map = new HashMap<>();\r\n    if (!map.containsKey(\"qwe\")) map.put(\"qwe\", map.get(\"asd\")); // without OO\r\n    if (map[\"qwe\"]==null) map[\"qwe\"] = map[\"asd\"]; // with OO\r\n  }\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.4\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Assignment operator overloading](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older/newer versions too.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method name map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD NAME|\r\n\t-------------------------\r\n\t| +        | add        |\r\n\t| -        | subtract   |\r\n\t| *        | multiply   |\r\n\t| /        | divide     |\r\n\t| %        | remainder  |\r\n\t| &        | and        |\r\n\t| |        | or         |\r\n\t| ^        | xor        |\r\n\t| <<       | shiftLeft  |\r\n\t| >>       | shiftRight |\r\n\r\nunary:\r\n\r\n\t| -        | negate     |\r\n\t| ~        | not        |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` are not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nassignment:\r\n\r\n\t| var = expr | var = VarClass.valueOf(expr) |\r\n\r\nif `expr` is not assignable to `var` and `var` is an instance of `VarClass` and `expr` has type `ExprType` and there are static method `VarClass#valueOf(ExprType)` 
\r\nthen `var = expr` is transformed to `var = VarClass.valueOf(expr)`.\r\nexample: 
\r\n`BigInteger a = 1` is transformed to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.4.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file

From 1384de6c2f621d95ceb33958dd06eecf39c6737c Mon Sep 17 00:00:00 2001
From: Artem Melentyev 
Date: Sun, 2 Feb 2014 15:32:53 -0800
Subject: [PATCH 14/32] Create gh-pages branch via GitHub

---
 index.html  | 14 +++++++++-----
 params.json |  2 +-
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/index.html b/index.html
index 6c7a668..a7af944 100644
--- a/index.html
+++ b/index.html
@@ -65,7 +65,8 @@ 
 
 Versions
 
-Javac/Netbeans: 0.4
+JavaC/Netbeans: 0.4
+JavaC8:         0.1
 Eclipse:        0.4
 IntelliJ IDEA:  0.2.1
 
@@ -73,6 +74,9 @@ 
 

 News
 
+3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.
+It has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.
+
 12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.
 Now operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.
 Fixed javac plugin bug with index-set OO.
@@ -95,7 +99,7 @@ 
 

 javac, ant, etc
 
-Just add javac-oo-plugin.jar to classpath:
+Just add to classpath: javac-oo-plugin.jar for JDK7 or javac8-oo-plugin.jar for JDK8.
 
 javac -cp javac-oo-plugin.jar <sources>
 
@@ -117,7 +121,7 @@ 
 
 
 
-Add javac-oo-plugin.jar as compile or processor library to Netbeans.
+Add javac-oo-plugin.jar as compile or processor library to Netbeans.
 Enable "Annotation Processing in Editor": Project Properties -> Build -> Compiling.
 
Tested on 7.2.1
 
@@ -131,7 +135,7 @@ 
 For Maven projects installation is done. IDEA should setup everything according to pom.xml. 

 For other project types: 

 
-Add javac-oo-plugin.jar as compile or processor library.
+Add javac-oo-plugin.jar as compile or processor library.
 Enable Annotation Processing:
 Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing
 
@@ -140,7 +144,7 @@ 

 

 Android project in IDEA 12
 
-Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
+Add javac-oo-plugin.jar to File - Settings - Compiler - Annotation Processors - Processor path 
 
 
 Android Studio (IDEA 13) / Gradle
diff --git a/params.json b/params.json
index f5b6813..575e42a 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nJava-OO is a modular extension (plugin) to Java compilers and IDEs\r\nfor ([Scala-like]) [Operator Overloading] support.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n  public static void main(String[] args) {\r\n    BigInteger a = BigInteger.valueOf(1), // without OO\r\n               b = 2, // with OO\r\n\r\n    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n    c2 = -a + b*b + b/a; // with OO\r\n\r\n    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO\r\n      System.out.println(\"impossible\");\r\n    if (c1c2) // with OO\r\n      System.out.println(\"impossible\");\r\n\r\n    HashMap map = new HashMap<>();\r\n    if (!map.containsKey(\"qwe\")) map.put(\"qwe\", map.get(\"asd\")); // without OO\r\n    if (map[\"qwe\"]==null) map[\"qwe\"] = map[\"asd\"]; // with OO\r\n  }\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavac/Netbeans: 0.4\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Assignment operator overloading](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add [javac-oo-plugin.jar] to classpath:\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older/newer versions too.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method name map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD NAME|\r\n\t-------------------------\r\n\t| +        | add        |\r\n\t| -        | subtract   |\r\n\t| *        | multiply   |\r\n\t| /        | divide     |\r\n\t| %        | remainder  |\r\n\t| &        | and        |\r\n\t| |        | or         |\r\n\t| ^        | xor        |\r\n\t| <<       | shiftLeft  |\r\n\t| >>       | shiftRight |\r\n\r\nunary:\r\n\r\n\t| -        | negate     |\r\n\t| ~        | not        |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` are not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nassignment:\r\n\r\n\t| var = expr | var = VarClass.valueOf(expr) |\r\n\r\nif `expr` is not assignable to `var` and `var` is an instance of `VarClass` and `expr` has type `ExprType` and there are static method `VarClass#valueOf(ExprType)` 
\r\nthen `var = expr` is transformed to `var = VarClass.valueOf(expr)`.\r\nexample: 
\r\n`BigInteger a = 1` is transformed to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.3/javac-oo-plugin-0.4.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nJava-OO is a modular extension (plugin) to Java compilers and IDEs\r\nfor ([Scala-like]) [Operator Overloading] support.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n  public static void main(String[] args) {\r\n    BigInteger a = BigInteger.valueOf(1), // without OO\r\n               b = 2, // with OO\r\n\r\n    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n    c2 = -a + b*b + b/a; // with OO\r\n\r\n    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO\r\n      System.out.println(\"impossible\");\r\n    if (c1c2) // with OO\r\n      System.out.println(\"impossible\");\r\n\r\n    HashMap map = new HashMap<>();\r\n    if (!map.containsKey(\"qwe\")) map.put(\"qwe\", map.get(\"asd\")); // without OO\r\n    if (map[\"qwe\"]==null) map[\"qwe\"] = map[\"asd\"]; // with OO\r\n  }\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavaC/Netbeans: 0.4\r\n\tJavaC8:         0.1\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.\r\nIt has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.\r\n\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Assignment operator overloading](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add to classpath: [javac-oo-plugin.jar] for JDK7 or [javac8-oo-plugin.jar] for JDK8.\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older/newer versions too.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method name map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD NAME|\r\n\t-------------------------\r\n\t| +        | add        |\r\n\t| -        | subtract   |\r\n\t| *        | multiply   |\r\n\t| /        | divide     |\r\n\t| %        | remainder  |\r\n\t| &        | and        |\r\n\t| |        | or         |\r\n\t| ^        | xor        |\r\n\t| <<       | shiftLeft  |\r\n\t| >>       | shiftRight |\r\n\r\nunary:\r\n\r\n\t| -        | negate     |\r\n\t| ~        | not        |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` are not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nassignment:\r\n\r\n\t| var = expr | var = VarClass.valueOf(expr) |\r\n\r\nif `expr` is not assignable to `var` and `var` is an instance of `VarClass` and `expr` has type `ExprType` and there are static method `VarClass#valueOf(ExprType)` 
\r\nthen `var = expr` is transformed to `var = VarClass.valueOf(expr)`.\r\nexample: 
\r\n`BigInteger a = 1` is transformed to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.4/javac-oo-plugin-0.4.jar\r\n[javac8-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac8-oo-plugin/0.1/javac8-oo-plugin-0.1.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file

From 50e3161fe92adf5960109a90f159d2c8ba8e8edb Mon Sep 17 00:00:00 2001
From: Artem Melentyev 
Date: Thu, 1 May 2014 01:14:52 +0300
Subject: [PATCH 15/32] Create gh-pages branch via GitHub

---
 index.html  | 10 +++++++++-
 params.json |  2 +-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/index.html b/index.html
index a7af944..da34a58 100644
--- a/index.html
+++ b/index.html
@@ -74,6 +74,8 @@ 
 
 News
 
+30 April 2014. IJPLA published a paper about Java-OO.
+
 3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.
 It has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.
 
@@ -169,7 +171,8 @@ 
 

 Details
 
-Supported operators (operator to method name map):
+Read the paper to learn more.
+Supported operators (operator to method name map):
 
 binary:
 
@@ -216,6 +219,11 @@ 
 
 These methods exists in many java classes (example: BigInteger, BigDecimal) so you can
 use operators on them "out of the box". Or you can add these methods to your classes to use OO (see examples/Vector.java).
+
+

+Publications
+
+"Java Modular Extension for Operator Overloading", IJPLA, April 2014.
       
     

 
diff --git a/params.json b/params.json
index 575e42a..520d8b5 100644
--- a/params.json
+++ b/params.json
@@ -1 +1 @@
-{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nJava-OO is a modular extension (plugin) to Java compilers and IDEs\r\nfor ([Scala-like]) [Operator Overloading] support.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n  public static void main(String[] args) {\r\n    BigInteger a = BigInteger.valueOf(1), // without OO\r\n               b = 2, // with OO\r\n\r\n    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n    c2 = -a + b*b + b/a; // with OO\r\n\r\n    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO\r\n      System.out.println(\"impossible\");\r\n    if (c1c2) // with OO\r\n      System.out.println(\"impossible\");\r\n\r\n    HashMap map = new HashMap<>();\r\n    if (!map.containsKey(\"qwe\")) map.put(\"qwe\", map.get(\"asd\")); // without OO\r\n    if (map[\"qwe\"]==null) map[\"qwe\"] = map[\"asd\"]; // with OO\r\n  }\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavaC/Netbeans: 0.4\r\n\tJavaC8:         0.1\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.\r\nIt has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.\r\n\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Assignment operator overloading](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add to classpath: [javac-oo-plugin.jar] for JDK7 or [javac8-oo-plugin.jar] for JDK8.\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older/newer versions too.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nSupported operators (operator to method name map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD NAME|\r\n\t-------------------------\r\n\t| +        | add        |\r\n\t| -        | subtract   |\r\n\t| *        | multiply   |\r\n\t| /        | divide     |\r\n\t| %        | remainder  |\r\n\t| &        | and        |\r\n\t| |        | or         |\r\n\t| ^        | xor        |\r\n\t| <<       | shiftLeft  |\r\n\t| >>       | shiftRight |\r\n\r\nunary:\r\n\r\n\t| -        | negate     |\r\n\t| ~        | not        |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` are not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nassignment:\r\n\r\n\t| var = expr | var = VarClass.valueOf(expr) |\r\n\r\nif `expr` is not assignable to `var` and `var` is an instance of `VarClass` and `expr` has type `ExprType` and there are static method `VarClass#valueOf(ExprType)` 
\r\nthen `var = expr` is transformed to `var = VarClass.valueOf(expr)`.\r\nexample: 
\r\n`BigInteger a = 1` is transformed to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.4/javac-oo-plugin-0.4.jar\r\n[javac8-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac8-oo-plugin/0.1/javac8-oo-plugin-0.1.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file
+{"name":"Java-OO","tagline":"Java Operator Overloading","body":"# Java Operator Overloading #\r\n\r\nJava-OO is a modular extension (plugin) to Java compilers and IDEs\r\nfor ([Scala-like]) [Operator Overloading] support.\r\nWorks with standard JavaC compiler, [Netbeans IDE], [Eclipse IDE], [IntelliJ IDEA] IDE and any build tools.\r\n\r\nExample (see other examples at [examples/](https://github.com/amelentev/java-oo/tree/master/examples) dir):\r\n\r\n```java\r\nimport java.math.*;\r\nimport java.util.*;\r\npublic class Test {\r\n  public static void main(String[] args) {\r\n    BigInteger a = BigInteger.valueOf(1), // without OO\r\n               b = 2, // with OO\r\n\r\n    c1 = a.negate().add(b.multiply(b)).add(b.divide(a)), // without OO\r\n    c2 = -a + b*b + b/a; // with OO\r\n\r\n    if (c1.compareTo(c2)<0 || c1.compareTo(c2)>0) // without OO\r\n      System.out.println(\"impossible\");\r\n    if (c1c2) // with OO\r\n      System.out.println(\"impossible\");\r\n\r\n    HashMap map = new HashMap<>();\r\n    if (!map.containsKey(\"qwe\")) map.put(\"qwe\", map.get(\"asd\")); // without OO\r\n    if (map[\"qwe\"]==null) map[\"qwe\"] = map[\"asd\"]; // with OO\r\n  }\r\n}\r\n```\r\n# Versions #\r\n\r\n\tJavaC/Netbeans: 0.4\r\n\tJavaC8:         0.1\r\n\tEclipse:        0.4\r\n\tIntelliJ IDEA:  0.2.1\r\n\r\n# News #\r\n30 April 2014. [IJPLA] published a [paper] about Java-OO.\r\n\r\n3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.\r\nIt has the same features as JavaC plugin for JDK7 but doesn't work in Netbeans yet.\r\n\r\n12 Jan 2014. JavaC plugin version 0.4 and Eclipse plugin version 0.4 released.\r\nNow operator overloading perform autoboxing/autounboxing primitive to/from wrapper types where appropriate.\r\nFixed [javac plugin bug with index-set OO](https://github.com/amelentev/java-oo/issues/13).\r\n\r\n3 Jan 2014. JavaC plugin version 0.3 released.\r\nFixed [#10 javac: binary operator adds erroneous cast on 1st operand](https://github.com/amelentev/java-oo/issues/10).\r\n\r\n8 Sep 2013. Eclipse plugin version 0.3 released.\r\nRemoved copypasta from Eclipse Compiler. Plugin should be more steady agains compiler changes.\r\n\r\n14 May 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.1 with IDEA Ultimate Edition support.\r\n\r\n17 Apr 2013. [IntelliJ IDEA](#IDEA) IDE plugin v0.2.\r\n\r\n26 Nov 2012. [Version 0.2] released. New feature: [Assignment operator overloading](https://github.com/amelentev/java-oo/issues/4) via static _#valueOf_ method.\r\n[Version 0.2]: https://github.com/amelentev/java-oo/issues?milestone=1&state=closed\r\n\r\n# Installation #\r\n\r\n## javac, ant, etc ##\r\nJust add to classpath: [javac-oo-plugin.jar] for JDK7 or [javac8-oo-plugin.jar] for JDK8.\r\n```\r\njavac -cp javac-oo-plugin.jar \r\n```\r\nDemo at [examples/compile.sh](https://github.com/amelentev/java-oo/blob/master/examples/compile.sh)\r\n\r\n## [Eclipse IDE] update site ##\r\nClick in menu: `Help - Install New Software`. Enter in `Work with` field:\r\n\r\n\thttp://amelentev.github.io/eclipse.jdt-oo-site/\r\n\r\nTested on Eclipse Standard 4.3.1. Should work with older/newer versions too.\r\n\r\n## [Netbeans IDE] ##\r\n1. Add [javac-oo-plugin.jar] as compile or processor library to Netbeans.\r\n2. Enable \"Annotation Processing in Editor\": `Project Properties -> Build -> Compiling`.\r\n\r\nTested on 7.2.1\r\n\r\n\r\n## [IntelliJ IDEA] IDE ##\r\n1. Install [Java Operator Overloading support](http://plugins.jetbrains.com/plugin?pr=&pluginId=7224) plugin: `File -> Settings -> Plugins -> Browse repositories`. Mirror: [idea-oo-plugin.jar]) 
\r\nFor [Maven projects](#maven) installation is done. IDEA should setup everything according to pom.xml. 
\r\nFor other project types: 
\r\n2. Add [javac-oo-plugin.jar] as compile or processor library.\r\n3. Enable Annotation Processing:\r\n`Menu File -> Settings -> Compiler -> Annotation Processing -> Enable annotation processing`\r\n4. Make sure you use `javac` compiler in `Settings -> Java Compiler -> Use compiler`. 
\r\nTested on IDEA 12.1.3 Community and Ultimate Editions.\r\n\r\n### Android project in IDEA 12 ###\r\nAdd [javac-oo-plugin.jar] to `File - Settings - Compiler - Annotation Processors - Processor path` \r\n\r\n### Android Studio (IDEA 13) / Gradle ###\r\nadd to `build.gradle`:\r\n\r\n```\r\nrepositories {\r\n\tmaven { url 'http://amelentev.github.io/mvnrepo/' }\r\n}\r\ndependencies {\r\n\tcompile 'java-oo:javac-oo-plugin:0.4'\r\n}\r\n```\r\n\r\n\r\n## Maven ##\r\nLook at [javac-oo-mvndemo/pom.xml](https://github.com/amelentev/java-oo/blob/master/javac-oo-mvndemo/pom.xml)\r\n\r\n# Details #\r\n\r\nRead the [paper] to learn more.\r\nSupported operators (operator to method name map):\r\n\r\nbinary:\r\n\r\n\t| OPERATOR | METHOD NAME|\r\n\t-------------------------\r\n\t| +        | add        |\r\n\t| -        | subtract   |\r\n\t| *        | multiply   |\r\n\t| /        | divide     |\r\n\t| %        | remainder  |\r\n\t| &        | and        |\r\n\t| |        | or         |\r\n\t| ^        | xor        |\r\n\t| <<       | shiftLeft  |\r\n\t| >>       | shiftRight |\r\n\r\nunary:\r\n\r\n\t| -        | negate     |\r\n\t| ~        | not        |\r\n\r\ncomparison:\r\n\r\n\t| <, <=, >, >= | compareTo\t| example: `a < b` <=> `a.compareTo(b)<0`\r\n\t`==` and `!=` are not overloadable because it will break things\r\n\r\nindex:\r\n\r\n\t| []  | get       | `v = lst[i]` <=> `v = lst.get(i)`\r\n\t| []= | set, put  | `map[s] = v` <=> `map.put(s,v)`,  `lst[i] = v` <=> `lst.set(i,v)`\r\n\r\nassignment:\r\n\r\n\t| var = expr | var = VarClass.valueOf(expr) |\r\n\r\nif `expr` is not assignable to `var` and `var` is an instance of `VarClass` and `expr` has type `ExprType` and there are static method `VarClass#valueOf(ExprType)` 
\r\nthen `var = expr` is transformed to `var = VarClass.valueOf(expr)`.\r\nexample: 
\r\n`BigInteger a = 1` is transformed to `BigInteger a = BigInteger.valueOf(1)`\r\n\r\nThese methods exists in many java classes (example: BigInteger, BigDecimal) so you can\r\nuse operators on them \"out of the box\". Or you can add these methods to your classes to use OO (see [examples/Vector.java](https://github.com/amelentev/java-oo/blob/master/examples/Vector.java)).\r\n\r\n## Publications\r\n[\"Java Modular Extension for Operator Overloading\", IJPLA, April 2014.](https://github.com/amelentev/java-oo/raw/master/doc/ijpla.pdf)\r\n\r\n[Scala-like]: http://www.slideshare.net/joeygibson/operator-overloading-in-scala-2923973\r\n[javac-oo]: https://bitbucket.org/amelentev/javac-oo\r\n[lombok]: http://projectlombok.org/\r\n[lombok-oo]: https://github.com/amelentev/lombok-oo\r\n[Eclipse IDE]: http://eclipse.org/\r\n[Netbeans IDE]: http://www.netbeans.org/\r\n[IntelliJ IDEA]: http://www.jetbrains.com/idea/\r\n[Java Developer Tools]: http://eclipse.org/jdt/\r\n[eclipse-oo]: https://github.com/amelentev/eclipse.jdt-oo\r\n[Operator Overloading]: http://en.wikipedia.org/wiki/Operator_overloading\r\n[AJDT and Equanox Weaving]: http://wiki.eclipse.org/Equinox_Weaving_QuickStart\r\n[PDE]: http://www.eclipse.org/pde/\r\n[maven]: https://maven.apache.org/\r\n\r\n[javac-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac-oo-plugin/0.4/javac-oo-plugin-0.4.jar\r\n[javac8-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/javac8-oo-plugin/0.1/javac8-oo-plugin-0.1.jar\r\n[idea-oo-plugin.jar]: http://amelentev.github.io/mvnrepo/java-oo/idea-oo-plugin/idea-oo-plugin-0.2.1.jar\r\n[IJPLA]: http://airccse.org/journal/ijpla/current2014.html#apr\r\n[paper]: https://github.com/amelentev/java-oo/raw/master/doc/ijpla.pdf","google":"UA-31894853-1","note":"Don't delete this file! It's used internally to help with page regeneration."}
\ No newline at end of file

From 2038c5eacaef897daaf6c1550bd67e06a5739e82 Mon Sep 17 00:00:00 2001
From: Artem Melentyev 
Date: Fri, 23 May 2014 16:22:06 +0300
Subject: [PATCH 16/32] Create gh-pages branch via GitHub

---
 index.html  | 12 ++++++++----
 params.json |  2 +-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/index.html b/index.html
index da34a58..f865de1 100644
--- a/index.html
+++ b/index.html
@@ -68,12 +68,14 @@ 
 JavaC/Netbeans: 0.4
 JavaC8:         0.1
 Eclipse:        0.4
-IntelliJ IDEA:  0.2.1
+IntelliJ IDEA:  0.3
 
 
 
 News
 
+23 May 2014. IntelliJ IDEA plugin v0.3 released. Bugfix for IDEA 13 Ultimate.
+
 30 April 2014. IJPLA published a paper about Java-OO.
 
 3 Feb 2014. New JavaC8 plugin version 0.1 for JDK8 was released.
@@ -109,7 +111,8 @@ 

 Demo at examples/compile.sh
 
 

-Eclipse IDE update site
+
+Eclipse IDE update site

Java Operator Overloading

Installation

Eclipse IDE update site

Netbeans IDE

javac, ant, etc

Maven

Details

Java Operator Overloading

Java Operator Overloading

News

Installation

Eclipse IDE update site

Netbeans IDE

javac, ant, etc

Details

binary:

Details

unary:

comparison:

index:

Implicit type conversion: