diff --git a/index.html b/index.html index 2f7290c..31dd995 100644 --- a/index.html +++ b/index.html @@ -1,5 +1,6 @@ -Nippy 1.3.0-alpha2 API documentation

Nippy 1.3.0-alpha2 API documentation

Clojure serialization library

taoensso.nippy

Simple, high-performance Clojure serialization library. Adapted from
-Deep-Freeze.

Public variables and functions:

taoensso.nippy.benchmarks

Public variables and functions:
    taoensso.nippy.crypto
    Alpha - subject to change.
+Nippy 2.0.0-alpha1 API documentation
    Nippy 2.0.0-alpha1 API documentation
    Clojure serialization library
    taoensso.nippy
    Simple, high-performance Clojure serialization library. Originally adapted
+from Deep-Freeze.
    Public variables and functions:
    taoensso.nippy.benchmarks
    Public variables and functions:
      taoensso.nippy.compression
      Alpha - subject to change.
+
      Public variables and functions:
      taoensso.nippy.encryption
      Alpha - subject to change.
 Simple no-nonsense crypto with reasonable defaults. Because your Clojure data
-deserves some privacy.
      Public variables and functions:
      taoensso.nippy.utils
      Public variables and functions:
      
\ No newline at end of file
+deserves some privacy.
      Public variables and functions:
      taoensso.nippy.utils
      Public variables and functions:
      
\ No newline at end of file
diff --git a/taoensso.nippy.benchmarks.html b/taoensso.nippy.benchmarks.html
index d019cf9..103bf95 100644
--- a/taoensso.nippy.benchmarks.html
+++ b/taoensso.nippy.benchmarks.html
@@ -1,2 +1,2 @@
 
-taoensso.nippy.benchmarks documentation
      taoensso.nippy.benchmarks documentation
      
\ No newline at end of file
+taoensso.nippy.benchmarks documentation
      taoensso.nippy.benchmarks documentation
      
\ No newline at end of file
diff --git a/taoensso.nippy.compression.html b/taoensso.nippy.compression.html
new file mode 100644
index 0000000..3a1dc97
--- /dev/null
+++ b/taoensso.nippy.compression.html
@@ -0,0 +1,5 @@
+
+taoensso.nippy.compression documentation
      taoensso.nippy.compression documentation
      Alpha - subject to change.
+
      ->DefaultSnappyCompressor
      (->DefaultSnappyCompressor)
      Positional factory function for class taoensso.nippy.compression.DefaultSnappyCompressor.
+
      default-snappy-compressor
      Default org.iq80.snappy.Snappy compressor.
+
      
\ No newline at end of file
diff --git a/taoensso.nippy.encryption.html b/taoensso.nippy.encryption.html
new file mode 100644
index 0000000..7872895
--- /dev/null
+++ b/taoensso.nippy.encryption.html
@@ -0,0 +1,40 @@
+
+taoensso.nippy.encryption documentation
      taoensso.nippy.encryption documentation
      Alpha - subject to change.
+Simple no-nonsense crypto with reasonable defaults. Because your Clojure data
+deserves some privacy.
      ->DefaultAES128Encryptor
      (->DefaultAES128Encryptor key-cache)
      Positional factory function for class taoensso.nippy.encryption.DefaultAES128Encryptor.
+
      default-aes128-encryptor
      Alpha - subject to change.
+Default 128bit AES encryptor with multi-round SHA-512 keygen.
+
+Password form [:salted "my-password"]
+---------------------------------------
+USE CASE: You want more than a small, finite number of passwords (e.g. each
+           item encrypted will use a unique user-provided password).
+
+IMPLEMENTATION: Uses a relatively cheap key hash, but automatically salts
+                every key.
+
+PROS: Each key is independent so would need to be attacked independently.
+CONS: Key caching impossible, so there's an inherent trade-off between
+      encryption/decryption speed and the difficulty of attacking any
+      particular key.
+
+Slower than `aes128-cached`, and easier to attack any particular key - but
+keys are independent.
+
+Password form [:cached "my-password"]
+---------------------------------------
+USE CASE: You want only a small, finite number of passwords (e.g. a limited
+          number of staff/admins, or you'll be using a single password to
+          encrypt many items).
+
+IMPLEMENTATION: Uses a _very_ expensive (but cached) key hash, and no salt.
+
+PROS: Great amortized encryption/decryption speed. Expensive key hash makes
+      attacking any particular key very difficult.
+CONS: Using a small number of keys for many encrypted items means that if any
+      key _is_ somehow compromised, _all_ items encrypted with that key are
+      compromised.
+
+Faster than `aes128-salted`, and harder to attack any particular key - but
+increased danger if a key is somehow compromised.
      map->DefaultAES128Encryptor
      (map->DefaultAES128Encryptor m__5665__auto__)
      Factory function for class taoensso.nippy.encryption.DefaultAES128Encryptor, taking a map of keywords to field values.
+
      
\ No newline at end of file
diff --git a/taoensso.nippy.html b/taoensso.nippy.html
index 777f609..c6f252b 100644
--- a/taoensso.nippy.html
+++ b/taoensso.nippy.html
@@ -1,13 +1,13 @@
 
-taoensso.nippy documentation
      taoensso.nippy documentation
      Simple, high-performance Clojure serialization library. Adapted from
-Deep-Freeze.
      coll-freezer
      macro
      (coll-freezer type id & body)
      Extends Freezable to simple collection types.
-
      coll-thaw!
      (coll-thaw! s)
      Thaws simple collection types.
-
      coll-thaw-kvs!
      (coll-thaw-kvs! s)
      Thaws key-value collection types.
-
      freeze-to-bytes
      (freeze-to-bytes x & {:keys [compress? print-dup? password], :or {compress? true, print-dup? true}})
      Serializes x to a byte array and returns the array.
-
      freeze-to-stream!
      (freeze-to-stream! data-output-stream x)(freeze-to-stream! data-output-stream x print-dup?)
      Serializes x to given output stream.
-
      freezer
      macro
      (freezer type id & body)
      Helper to extend Freezable protocol.
-
      kv-freezer
      macro
      (kv-freezer type id & body)
      Extends Freezable to key-value collection types.
+taoensso.nippy documentation
      taoensso.nippy documentation
      Simple, high-performance Clojure serialization library. Originally adapted
+from Deep-Freeze.
      coll-thaw
      (coll-thaw coll s)
      Thaws simple collection types.
+
      coll-thaw-kvs
      (coll-thaw-kvs coll s)
      Thaws key-value collection types.
+
      freeze
      (freeze x & [{:keys [print-dup? password compressor encryptor legacy-mode?], :or {print-dup? true, compressor compression/default-snappy-compressor, encryptor encryption/default-aes128-encryptor}}])
      Serializes arg (any Clojure data type) to a byte array. Enable
+`:legacy-mode?` flag to produce bytes readable by Nippy < 2.x.
      freeze-to-bytes
      (freeze-to-bytes x & {:keys [print-dup? compress? password], :or {print-dup? true, compress? true}})
      DEPRECATED: Use `freeze` instead.
 
      stress-data
      Reference data used for tests & benchmarks.
-
      thaw-from-bytes
      (thaw-from-bytes ba & {:keys [compressed? read-eval? password], :or {compressed? true, read-eval? false}})
      Deserializes an object from given byte array.
-
      thaw-from-stream!
      (thaw-from-stream! data-input-stream read-eval?)
      Deserializes an object from given input stream.
+
      thaw
      (thaw ba & [{:keys [read-eval? password compressor encryptor legacy-mode? strict?], :or {compressor compression/default-snappy-compressor, encryptor encryption/default-aes128-encryptor}}])
      Deserializes frozen bytes to their original Clojure data type. Enable
+`:legacy-mode?` to read bytes written by Nippy < 2.x.
+
+WARNING: Enabling `:read-eval?` can lead to security vulnerabilities unless
+you are sure you know what you're doing.
      thaw-from-bytes
      (thaw-from-bytes ba & {:keys [read-eval? compressed? password], :or {compressed? true}})
      DEPRECATED: Use `thaw` instead.
 
      
\ No newline at end of file
diff --git a/taoensso.nippy.utils.html b/taoensso.nippy.utils.html
index 65af72a..39650df 100644
--- a/taoensso.nippy.utils.html
+++ b/taoensso.nippy.utils.html
@@ -1,8 +1,8 @@
 
-taoensso.nippy.utils documentation
      taoensso.nippy.utils documentation
      bench
      macro
      (bench num-laps form & {:keys [warmup-laps num-threads as-ms?], :or {as-ms? true}})
      Repeatedly executes form and returns time taken to complete execution.
+taoensso.nippy.utils documentation
      taoensso.nippy.utils documentation
      bench
      macro
      (bench num-laps form & {:keys [warmup-laps num-threads as-ns?]})
      Repeatedly executes form and returns time taken to complete execution.
 
      case-eval
      macro
      (case-eval e & clauses)
      Like `case` but evaluates test constants for their compile-time value.
 
      memoized
      (memoized cache f & args)
      Like `memoize` but takes an explicit cache atom (possibly nil) and
-immediately applies memoized f to given arguments.
      pairs
      (pairs coll)
      Like (partition 2 coll) but faster and returns lazy seq of vector pairs.
+immediately applies memoized f to given arguments.
      repeatedly-into
      (repeatedly-into coll n f)
      Like `repeatedly` but faster and `conj`s items into given collection.
 
      time-ns
      macro
      (time-ns & body)
      Returns number of nanoseconds it takes to execute body.
 
      version-compare
      (version-compare x y)
      Comparator for version strings like x.y.z, etc.
 
      
\ No newline at end of file