gen-class

(gen-class
	:name "some.package.RefMap"
	:implements [java.util.Map]
	:state "state"
	:init "init"
	:constructors {[] []}
	:prefix "ref-map-")

(defn ref-map-init []
	[[] (ref {})])

(defn ref-map-size [this]
	(let [state (.state this)] (.size @state)))
	
(defn ref-map-isEmpty [this]
	(let [state (.state this)] (.isEmpty @state)))

(defn ref-map-containsKey [this o]
	(let [state (.state this)] (.containsKey @state o)))
	
(defn ref-map-containsValue [this o]
	(let [state (.state this)] (.containsValue @state o)))
	
(defn ref-map-get [this o]
	(let [state (.state this)] (.get @state o)))
	
(defn ref-map-keySet [this]
	(let [state (.state this)] (.keySet @state)))
	
(defn ref-map-values [this]
	(let [state (.state this)] (.values @state)))
	
(defn ref-map-entrySet [this]
	(let [state (.state this)] (.entrySet @state)))
	
(defn ref-map-equals [this o]
	(let [state (.state this)] (.equals @state o)))
	
(defn ref-map-hashCode [this]
	(let [state (.state this)] (.hashCode @state)))
	
(defn ref-map-put [this k v]
	(let [state (.state this)] 
		(dosync (alter state assoc k v)) v))
	
(defn ref-map-putAll [this m]
	(let [state (.state this)]
		(doseq [[k v] (map identity m)] (.put this k v))))
		
(defn ref-map-remove [this o]
	(let [state (.state this) v (get @state o)] 
		(dosync (alter state dissoc o)) v))
	
(defn ref-map-clear [this]
	(let [state (.state this)] 
		(dosync (ref-set state {}))))
	
(defn ref-map-toString [this]
	(let [state (.state this)] (.toString @state)))

;; I found managing state a bit confusing at first.
;; here's a dumb little class with a getter and setter for a "location" field.

(ns com.example )

(gen-class
      :name com.example.Demo
      :state state
      :init init
      :prefix "-"
      :main false
      ;; declare only new methods, not superclass methods
      :methods [[setLocation [String] void]
                [getLocation [] String]])

;; when we are created we can set defaults if we want.
(defn -init []
  "store our fields as a hash"
  [[] (atom {:location "default"})])

;; little functions to safely set the fields.
(defn setfield
  [this key value]
      (swap! (.state this) into {key value}))

(defn getfield
  [this key]
  (@(.state this) key))

;; "this" is just a parameter, not a keyword
(defn -setLocation [this loc]
  (setfield this :location loc))

(defn  -getLocation
  [this]
  (getfield this :location))

;; running it -- you must compile and put output on the classpath
;; create a Demo, check the default value, then set it and check again.
user=> (def ex (com.example.Demo.))
#'user/ex
user=> (.getLocation ex)
"default"
user=> (.setLocation ex "time")
nil
user=> (.getLocation ex)
"time"

;; This example illustrates the syntax intended by the docstring's remark that 
;; "Static methods can be specified with ^{:static true} in the signature's 
;; metadata", and notes a case in which you might not think that you need to use
;; :methods.

;; The docs say, about :methods, "Do not repeat superclass/interface
;; signatures here."  That applies to non-static methods.  If you want to
;; define a static method to hide a static method in the superclass, you
;; are not overriding the superclass method (the behavior is different).
;; You are simply defining a new method with the same name.  In this case,
;; you should add a signature to :methods if you want your function to be
;; visible to Java, with metadata indicating that it is static placed
;; before the signature vector:

(ns 
  ...
  (:gen-class 
    ...
    :methods [[...] ...
              ^{:static true} [name [] java.lang.String]
              [...] ...]
    ...))

(defn -name [] "My name is Foo")

;; Also note that you can replace "^{:static true}" with "^:static".

;; It is possible to attach Java annotations to the class,
;; constructors, and methods 
;; Source: https://github.com/clojure/clojure/blob/8af7e9a92570eb28c58b15481ae9c271d891c028/test/clojure/test_clojure/genclass/examples.clj#L34
(gen-class :name ^{Deprecated {}
                   SuppressWarnings ["Warning1"] ; discarded
                   java.lang.annotation.Target []}
                 clojure.test_clojure.genclass.examples.ExampleAnnotationClass
           :prefix "annot-"
           :methods [[^{Deprecated {}
                        Override {}} ;discarded
                      foo [^{java.lang.annotation.Retention java.lang.annotation.RetentionPolicy/SOURCE
                             java.lang.annotation.Target    [java.lang.annotation.ElementType/TYPE
                                                             java.lang.annotation.ElementType/PARAMETER]}
                           String] void]])

;; Defining a custom constructor which calls a superclass constructor:
(ns my.CustomException
  (:gen-class
   :implements [clojure.lang.IExceptionInfo]
   :extends java.lang.RuntimeException
   :constructors {[String Throwable clojure.lang.IPersistentMap] [String Throwable]} ; mapping of my-constructor -> superclass constuctor
   :init init
   :state state ; name for the var that holds your internal state
   :main false
   :prefix "my-ex-"))

(defn my-ex-init [msg t context]
  ;; first element of vector contains parameters for the superclass constructor
  ;; Second element will be your internal state 
  [[msg t] context]) 

(defn my-ex-getData [this]
  (.state this)) ; accessing the internal state