Converts a class to its representation.

(class-convert “byte”) => Byte/TYPE

(class-convert ’byte :string) => “byte”

(class-convert (Class/forName “[[B”) :string) => “byte[][]”

Lists the class and interface hierarchy for the class

(element/class-hierarchy String) => [java.lang.String java.lang.Object #{java.lang.CharSequence java.lang.constant.ConstantDesc java.lang.constant.Constable java.lang.Comparable java.io.Serializable}]

Lists class information

(element/class-info String) => (contains {:name “java.lang.String” :hash anything :modifiers #{:instance :class :public :final}})

checks if if an element is a constructor

(-> (.getConstructors String) (first) (element/to-element) (element/constructor?)) => true

If x is a class, return x otherwise return the class of x

(context-class String) => String

(context-class "") => String

Allow transparent field access and manipulation to the underlying object.

(def -a- “hello”) (def -*a- (delegate -a-)) (def -world-array- (.getBytes “world”))

(mapv char (-*a- :value)) => \h \e \l \l \o

(-*a- :value -world-array-) (String. ^bytes (-*a- :value)) => “world” -a- => “world”

creates a element from a map

(element {}) => std.object.element.common.Element

checker for the element type

(element? (element {})) => true

checks if an element is a field

(-> (.getFields String) (first) (element/to-element) (element/field?)) => true

creates the object from data

(-> (write/from-data “hello”) seq) => “hello”

accessor with either keyword or array lookup

(access/get (test.Cat. “spike”) :name) => “spike”

accesses the nested object using specifiedb path

(access/get-in (test.Cat. “spike”) :name)

checks if an element is non static

(->> (.getMethods String) (map element/to-element) (filter element/instance?) first) ;;#elemequals :: (java.lang.String, java.lang.Object) -> boolean

gets all keys of an object

(access/keys (test.Cat. “spike”)) => (contains :name)

creates an accessibility layer for map-like objects

(framework/map-like org.eclipse.jgit.revwalk.RevCommit {:tag “commit” :include :commit-time :name :author-ident :full-message})

(framework/map-like org.eclipse.jgit.lib.PersonIdent {:tag “person” :exclude :time-zone})

(framework/map-like org.eclipse.jgit.api.Status {:tag “status” :display (fn m (reduce-kv (fn out k v (if (and (or (instance? java.util.Collection v) (instance? java.util.Map v)) (empty? v)) out (assoc out k v))) {} m))})

clears all meta-read and meta-write definitions for a class

access read attributes

(read/meta-read Pet) => (contains-in {:class test.Pet :methods {:name {:fn fn?} :species {:fn fn?}}})

access read attributes for the exact class

(read/meta-read-exact Object) => nil

checks if read attributes are avaliable

(read/meta-read-exact? Object) => false

access read-attributes with caching

(write/meta-write DogBuilder) => (contains-in {:class test.DogBuilder :empty fn?, :methods {:name {:type java.lang.String, :fn fn?}}})

access write attributes for the exact class

(write/meta-write-exact Object) => nil

checks if write attributes are avaliable

(write/meta-write-exact? Object) => false

checks if an element is a method

(-> (.getMethods String) (first) (element/to-element) (element/method?)) => true

checks if an element is neither public or private

checks if an element is private

(->> (.getDeclaredFields String) (map element/to-element) (filter element/private?) first) ;;#elem[value :: (java.lang.String) | byte[]]

checks if an element is public

(->> (.getMethods String) (map element/to-element) (filter element/public?) first) ;;#elemequals :: (java.lang.String, java.lang.Object) -> boolean

queries the java view of the class declaration

(query-class String #“^c” :name) ;;=> “charAt” “checkBounds” “codePointAt” “codePointBefore” ;; “codePointCount” “compareTo” “compareToIgnoreCase” ;; “concat” “contains” “contentEquals” “copyValueOf”

lists what methods could be applied to a particular instance

(query-hierarchy String :name #“^to”) => “toCharArray” “toLowerCase” “toString” “toUpperCase”

lists what class methods could be applied to a particular instance

(query-instance “abc” :name #“^to”) => “toCharArray” “toLowerCase” “toString” “toUpperCase”

(query-instance String :name #“^to”) => (contains “toString”)

returns fields of an object and base classes (-> (read/read-all-getters Dog) keys) => :class :name :species

creates a getter method that throws an an exception

((read/read-ex :hello) nil) => (throws)

fields of an object from reflection (-> (read/read-fields Dog) keys) => :name :species

returns fields of an object through getter methods (-> (read/read-getters Dog) keys) => :name :species

creates the form for read-getters

(read/read-getters-form Dog) => ’{:name {:type java.lang.String, :fn (clojure.core/fn getName obj(. obj (getName)))}, :species {:type java.lang.String, :fn (clojure.core/fn getSpecies obj(. obj (getSpecies)))}}

sets the fields of an object with a map

(-> (doto (test.Cat. “spike”) (access/set {:name “fluffy”})) (access/get :name)) => (any “fluffy” (throws))

checks if an element is a static one

(->> (.getMethods String) (map element/to-element) (filter element/static?) first) ;;#elemvalueOf :: (int) -> java.lang.String

creates an accessibility layer for string-like objects

(framework/string-like java.io.File {:tag “path” :read (fn ^java.io.File f(.getPath f)) :write (fn ^String path(java.io.File. path))})

(object/to-data (java.io.File. “/home”)) => “/home”

(object/from-data “/home” java.io.File) => java.io.File

;; Enums are automatically string-like

(object/to-data java.lang.Thread$State/NEW) => “NEW”

creates an accessor function

((struct-accessor {:value :data :msg :detail-message :value} :field) (ex-info “hello” {:a 1})) => (contains {:value {:a 1}, :msg bytes?})

creates a struct given an object and a field map

(struct-fields {:depth []} (ex-info “hello” {:a 1})) => (contains {:depth number?})

(struct-fields {:msg :detail-message :value} (ex-info “hello” {:a 1})) => (contains {:msg bytes?})

creates a struct given an object and a getter map

(struct-getters {:value :data :message [] :class {:name []}} (ex-info “hello” {:a 1})) => {:value {:a 1}, :message “hello”, :class {:name “clojure.lang.ExceptionInfo”}}

creates the object from a string or map

(read/to-data “hello”) => “hello”

(read/to-data (write/from-map {:name “hello” :species “dog”} Pet)) => (contains {:name “hello”})

converts a java.reflect object to a std.object.element one

(element/to-element (first (.getMethods String))) ;; #elemequals :: (java.lang.String, java.lang.Object) -> boolean

creates a map from an object

(read/to-map (Cat. “spike”)) => (contains {:name “spike”})

unextend a given class from the object framework

(framework/unextend org.eclipse.jgit.lib.PersonIdent) ;;=>

creates an accessibility layer for vector-like objects

(framework/vector-like org.eclipse.jgit.revwalk.RevWalk {:tag “commits” :read (fn ^org.eclipse.jgit.revwalk.RevWalk walk (->> walk (.iterator) object/to-data))})

write all setters of an object and base classes

(write/write-all-setters Dog) => {}

(keys (write/write-all-setters DogBuilder)) => :name

writes a getter method that throws an an exception

((write/write-ex :hello) nil nil) => (throws)

write fields of an object from reflection

(-> (write/write-fields Dog) keys) => :name :species

write fields of an object through setter methods

(write/write-setters Dog) => {}

(keys (write/write-setters DogBuilder)) => :name

constructs forms for a given object

(write/write-setters-form DogBuilder) => ’{:name {:type java.lang.String, :fn (clojure.core/fn setName obj val (clojure.core/or (. obj (setName val)) obj))}}