# File 'doclib/msgpack/core_ext.rb', line 48
+
+defto_msgpack(packer=nil)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/CNAME b/CNAME
new file mode 100644
index 00000000..962ebf1a
--- /dev/null
+++ b/CNAME
@@ -0,0 +1 @@
+ruby.msgpack.org
diff --git a/ChangeLog b/ChangeLog
deleted file mode 100644
index 5f173f2a..00000000
--- a/ChangeLog
+++ /dev/null
@@ -1,368 +0,0 @@
-2025-02-06 1.8.0
-
-* Numerous small optimizations.
-* Added `key_cache` option to `Unpacker`.
-
-2024-11-11 1.7.5
-
-* Rerelease 1.7.4 with fixed java package.
-
-2024-11-11 1.7.4
-
-* Fixed a potental memory leak when recursive unpacker raise.
-
-2024-10-03 1.7.3
-
-* Limit initial containers pre-allocation to `SHRT_MAX` (32k) entries.
-
-2023-07-18 1.7.2:
-
-* Fix a potential GC bug when packing data using recursive extensions and buffers containing over 512KkiB of data (See #341).
-* Fix a regression where feeding an empty string to an Unpacker would be considered like the end of the buffer.
-
-2023-05-19 1.7.1:
-
-* Fix JRuby 9.4 compatibility.
-* Fix compilation on older compilers (gcc 4.x).
-* Fix an infinite recursion issue when registering a Symbol type with a `nil` packer.
-
-2023-03-29 1.7.0:
-
-* Fix a possible double-free issue when GC triggers inside `_msgpack_rmem_alloc2`.
-* `Unpacker#feed` now always directly read in provided strings instead of copying content in its buffer.
-* `Unpacker#feed` is now an alias of `Unpacker#feed_reference`.
-* Implement `Factory::Pool#unpacker` and `Factory::Pool#packer` to allow for more precise serialization.
-* Require Ruby 2.5+.
-
-2023-03-03 1.6.1:
-
-* Undefine `#clone` and `#dup` on `MessagePack::Buffer`, `MessagePack::Packer` and `MessagePack::Unpacker`.
- These methods were never intended, and using them could cause leaks or crashes or worse.
-* Fix a possible GC crash when GC trigger inside `MessagePack::Buffer.new` (#314).
-
-2022-09-30 1.6.0:
-
-* Fix a potential use-after-free bug in Buffer_free when accessing a packer or unpacker buffer.
-* `old-style-definition` compilation warnings.
-* Restore zero-copy buffer feed when provided a Ruby string. This was accidentally broken in 1.5.4.
-* Provide implementations for `ObjectSpace.memsize`. Message pack objects now properly report their size to Ruby.
-* Fix an endianess bug on Windows platform.
-
-2022-08-23 1.5.6:
-
-* No actual code change, just re-release the `java` version properly.
-
-2022-08-22 1.5.5:
-
-* Fix a segfault when GC triggers inside a recursive extension.
-
-2022-07-25 1.5.4:
-
-* Fix a segfault when deserializing empty symbol (`:""`).
-* Improve compilation flags to not strip debug symbols.
-
-2022-05-30 version 1.5.3:
-
-* Fix deduplication of empty strings when using the `freeze: true` option.
-* Use `rb_hash_new_capa` when available (Ruby 3.2) for improved performance when parsing large hashes.
-
-2022-05-27 version 1.5.2:
-
-* Fix bug about unpacking ext type objects with the recursive option
-
-2022-04-07 version 1.5.1:
-
-* Fix bug about packing/unpacking ext type objects with the recursive option
-
-2022-04-06 version 1.5.0:
-
-* Add recursive option on Factory#register_type to operate Packer/Unpacker manually
-* Add oversized_integer_extension option on Factory#register_type to pack/unpack bigint using ext types
-* Add Factory#pool method and Factory::Pool class to provide pooled Packer and Unpacker instances
-
-2022-02-15 version 1.4.5:
-
-* Fix to create UTF-8 Symbol keys when symbolize_keys: true
-* Fix to assume Symbols as US-ASCII or UTF-8
-* Optimize Packer/Unpacker initialization
-* Optimize extension class lookup
-* Rename Packer#clear as Packer#reset (#clear is still available as an alias)
-
-2022-01-22 version 1.4.4:
-
-* Specify the build option --platform=8 for older Java platforms
-
-2022-01-20 version 1.4.3:
-
-* Optimize serialization/deserialization of Symbols
-* Support registering ext types for objects of subclasses of primitive types (like Hash)
-* Add optimized_symbols_parsing option to Factory#register_type on MRI implementation
-* Optimize to deduplicate Hash keys on JRuby
-* Support JRuby 9.3 (and drop 9.1)
-
-2021-02-01 version 1.4.2:
-
-* Add the required Ruby version (>= 2.4) to avoid compilation errors on older Ruby runtimes
-* Drop the support of old Ruby versions explicitly (1.8, 1.9, 2.0, 2.1, 2.2, 2.3)
-
-2021-01-27 version 1.4.1:
-
-* Bugfix about the wrong string encoding longer than 256 bytes (#200)
-
-2021-01-27 version 1.4.0:
-
-* Introduce the optimization to use frozen/deduped keys for map objects
-* Stop releasing fat gem (pre-built binaries) for mswin32 arch environments
-
-2020-02-05 version 1.3.3:
-
-* Hotfix release for Windows environments: 1.3.2 missed including binaries
-
-2020-02-04 version 1.3.2:
-
-* Add Ruby 2.7.0 binary in gem releases for Windows
-
-2019-08-05 version 1.3.1:
-
-* Fix timestamp ext type bug about timestamps with seconds larger than 32bit int (after 2106-02-07 06:28:16 UTC)
-
-2019-06-20 verison 1.3.0:
-
-* Add timestamp ext type (id:-1) support
-
-2019-04-19 version 1.2.10:
-
-* Optimze MessagePack.unpack not to copy source string
-
-2019-03-13 version 1.2.9:
-
-* Hotfix release only for JRuby: 1.2.8-java was built incorrectly
-
-2019-03-11 version 1.2.8:
-
-* Fix a regression that MessagePack#unpack raises error if IO is assigned as the (only) argument
-* Improve compatibility that MessagePack#pack returns nil if IO is assigned as 2nd argument
-
-2019-03-01 version 1.2.7:
-
-* Add Packer#write_bin and Packer#write_bin_header methods
-
-2019-01-08 verison 1.2.6:
-
-* Update Ruby version 2.6 dependency (especially for Windows environment)
-* (version 1.2.4 and 1.2.5 were also releases for updated Ruby versions)
-
-2018-03-02 version 1.2.3:
-
-* Add Ruby 2.5.0 binary in gem releases for Windows
-
-2018-01-11 version 1.2.2:
-
-* Fix bug to occur SEGV occasionally (depends on GC timing) when exttype is used
-* Fix bug to encode an ext type with wrong type id if superclass is also registered as ext type
-
-2017-12-08 version 1.2.1:
-
-* Hotfix release only for JRuby: 1.2.0-java was built in incorrect way
-
-2017-12-07 version 1.2.0:
-
-* Add MessagePack::Factory#dump and MessagePack::Factory#load as convenient methods
- like MessagePack.dump and MessagePack.load
-* Fix bug to accept MessagePack::Factory#register_type after #freeze
-
-2017-02-28 version 1.1.0:
-
-* Fix the extension type handling to accept modules in addition to classes
-
-2017-01-24 version 1.0.3:
-
-* Support Ruby 2.4
-
-2016-10-17 version 1.0.2:
-
-* Bump version up to release newer version to fix broken gem release for JRuby
-
-2016-10-17 version 1.0.1:
-
-* Fix a bug to crash at packer when ext type is registered for superclass of packed object
-* Fix JRuby implementation about inconsistent API of Unpacker constructor
-
-2016-07-08 version 1.0.0:
-
-* Fix to be able to pack Symbol with ext types
-* Fix for MRI 2.4 (Integer unification)
-
-2016-05-10 version 0.7.6:
-
-* Fix bug to raise IndexOutOfBoundsException for Bignum value with small int in JRuby
-
-2016-04-06 version 0.7.5:
-
-* Improved support for i386/armel/armhf environments
-* Fix bug for negative ext type id and some architectures (arm*)
-
-2016-01-08 version 0.7.4:
-
-* Improved compatibility of Packer between CRuby and JRuby about argument IO-ish object values.
-
-2016-01-07 version 0.7.3:
-
-* Add Packer#write_float32 method to pack floating point numbers into FLOAT of messagepack.
-
-2016-01-06 version 0.7.2:
-
-* Improved compatibility of Unpacker between CRuby and JRuby to accept stream-like object
- by checking respond_to(:read) in addition to class check
-
-2015-11-20 version 0.7.1:
-
-* Fixed bug to pack/unpack ext type objects larger than 256bytes incorrectly.
-
-2015-10-24 version 0.7.0:
-
-* Add extension types support.
-* Fix to share almost all test cases between CRuby and JRuby implementations.
-* Fixed JRuby implementation to raise UnknownExtTypeError for unregistered ext type ids
- instead to generate MessagePack::ExtensionValue instances.
- (Specify `allow_unknown_ext: true` as unpacker option for v0.6.x behavior.)
-
-2015-07-22 version 0.6.2:
-
-* Fix release workflow: Ruby 2.1 and 2.2 are supported for Windows (2.0 is omitted)
-* Fix to encode symbols along its encoding
-* Fix segmentation fault in minor case
-
-2015-07-01 version 0.6.1:
-
-* Added :compatibility_mode option to Packer#initialize. Default is false. If it
- is set to true, str8 format and bin format family will not be used.
-
-2015-05-26 version 0.6.0:
-
-* Added support for Binary types
-* Fixed to encode/decode between Binary types and ASCII-8BIT Ruby String objects
-
-2015-05-21 version 0.5.12:
-
-* Added support for JRuby 9K.
-* Added a benchmarking suite.
-* Fixed a bug in the handling of options given to MessagePack.unpack in JRuby.
-
-
-2015-02-04 version 0.5.11:
-
-* Fixed Encoding::CompatibilityError error when serializing a long string
- longer than write_reference_threshold (5KB by default) and whose encoding
- is not ASCII-8BIT.
-* Fix read_(map|array)_header (@funny-falcon++).
-* Internally, rename msgpack_unpacker_{init,reset,destroy} functions
- so that we can load msgpack-c in the same process (@miihael++)
-
-
-2015-01-09 version 0.5.10:
-
-* Merged msgpack-jruby by @iconara. JRuby can run `require 'msgpack'` to use
- msgpack-jruby.
-
-
-2014-10-05 version 0.5.9:
-
-* Fixed Unpacker#read_map_header and #read_array_header
-* Added support for Symbol GC added since MRI 2.2.0
-
-
-2013-12-14 version 0.5.8:
-
-* Fixed compatibility with Ruby 2.1.0
-* Added :symbolize_keys option to MessagePack.load and Unpacker#initialize
-
-
-2013-10-12 version 0.5.7:
-
-* Added deserialization support for the new MessagePack spec
-
-
-2013-09-23 version 0.5.6:
-
-* Fixed "can't modify frozen String" exception in Unpacker with ruby 2.1.0-dev
-* Getting work with Ruby v2.0 on Windows (Thank you @thegreendroid)
-* Fixed EOFError handling in Unpacker
-
-
-2013-05-12 version 0.5.5:
-
-* Fixed SEGV problem in to_msgpack
-* Fixed a possible race condition in MessagePack.load when it loads data from IO
-* mingw32 package includes binary for ruby-2.0.0
-
-
-2013-03-15 version 0.5.4:
-
-* Added missing MessagePack::Unpacker#reset method
-
-
-2013-02-14 version 0.5.3:
-
-* Fixed segfault problem on Buffer#clear (reuse rmem internal fragment optimization)
-* Fixed segfault problem on Buffer (rmem free code)
-
-
-2013-02-07 version 0.5.2:
-
-* Fixed invalid pack/unpack on 32bit architecture such as Win32
-* Disable rmem on Rubinius because rmem is not thread safe
-
-
-2012-12-23 version 0.5.1:
-
-* Fixed compile error with Rubinius 2.0.0-dev
-* Optimized msgpack_packer_write_hash for Rubinius
-
-
-2012-12-20 version 0.5.0:
-
-* Rewrote all code and improved performance significantly
-* Added MessagePack::Buffer class
-* Added MessagePack::Packer class
-* Added Packer#buffer and Unpacker#buffer accessors which return MessagePack::Buffer
-* Added Packer#write_{array,map}_header and Unpacker#read_{array,map}_header methods
-* Added Packer#write_nil and Unpacker#skip_nil methods
-* Added Packer#write -> #pack alias and Unpacker#read method
-* Added exception classes - UnpackError, MalformedFormatError, StackError and TypeError
-* Added MessagePack.dup -> .pack and MessagePack.load -> .unpack aliases
-* Added Packer#empty?, #size and #clear methods
-* Added Packer#write_to(io) method to flush serialized data to IO efficiently
-* Added Unpacker#skip method to skip an object efficiently
-* Removed obsoleted Unpacker#fill, #execute, #execute_limit, #finished? and #data methods
-* Removed obsoleted Unapcker#stream and #stream= methods. Use unpacker.buffer.io instead
-
-
-2012-05-05 version 0.4.7:
-
-* Fixed serialization of double values on ARM OABI architectures
-* Fixed byteorder problem on big-endian platforms
-* Don't use MRI internals in the Ruby extension for Rubinius
-* Detect whether st.h is present and don't use RUBY_VM as the condition for
- Rubinius
-
-2011-08-08 version 0.4.6:
-
-* Fixed compile error problem on Mac OS X Lion
-
-2011-05-09 version 0.4.5:
-
-* Improves compatibility with JRuby
-
-2010-11-28 version 0.4.4:
-
-* Adds Unpacker#feed_each method
-* Improves compatibility with Rubinius
-* Improves compatibility with ruby-1.8.5
-* Encodings of String instances to UTF-8 on Ruby 1.9
-
-2010-06-29 version 0.4.3:
-
-* Adds MessagePack::VERSION constant
-* Fixes SEGV problem caused by GC bug at MessagePack_Unpacker_mark
-
diff --git a/FalseClass.html b/FalseClass.html
new file mode 100644
index 00000000..aecd67db
--- /dev/null
+++ b/FalseClass.html
@@ -0,0 +1,219 @@
+
+
+
+
+
+
+ Class: FalseClass
+
+ — Documentation by YARD 0.9.37
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'doclib/msgpack/core_ext.rb', line 88
+
+defto_msgpack(packer=nil)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index f433b1a5..00000000
--- a/LICENSE
+++ /dev/null
@@ -1,177 +0,0 @@
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
diff --git a/MessagePack.html b/MessagePack.html
new file mode 100644
index 00000000..ec490c8b
--- /dev/null
+++ b/MessagePack.html
@@ -0,0 +1,962 @@
+
+
+
+
+
+
+ Module: MessagePack
+
+ — Documentation by YARD 0.9.37
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
An instance of Factory class. DefaultFactory is also used by global pack/unpack methods such as MessagePack.dump/load, Hash#to_msgpack, and other to_msgpack methods.
+
+
Calling DefaultFactory.register_type lets you add an extension type globally.
io must respond to readpartial(length, [,string]) or read(string) method and write(string) or append(string) method.
+
+
Supported options:
+
+
:io_buffer_size buffer size to read data from the internal IO. (default: 32768)
+
+
:read_reference_threshold the threshold size to enable zero-copy deserialize optimization. Read strings longer than this threshold will refer the original string instead of copying it. (default: 256) (supported in MRI only)
+
+
:write_reference_threshold the threshold size to enable zero-copy serialize optimization. The buffer refers written strings longer than this threshold instead of copying it. (default: 524288) (supported in MRI only)
Consumes n bytes from the head of the buffer and returns consumed data. If the size of the buffer is less than n, it reads all of data in the buffer.
+
+
If n is 0, it does nothing and returns an empty string. If the optional buffer argument is given, the content of the string will be replaced with the consumed data.
Consumes n bytes from the head of the buffer and returns consumed data. If the size of the buffer is less than n, it does nothing and raises EOFError.
+
+
If n is 0, it does nothing and returns an empty string. If the optional buffer argument is given, the content of the string will be replaced with the consumed data.
# File 'doclib/msgpack/buffer.rb', line 110
+
+defread_all(n,buffer=nil)
+end
+
+
+
+
+
+
+
+
+ #size ⇒ Object
+
+
+
+
+
+
+
+
+
Returns byte size of the buffer.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+
+
+
+
+
+
+
nil
+
+
+
+
+
+
+
+
+
+
+
+
+41
+42
+
+
+
# File 'doclib/msgpack/buffer.rb', line 41
+
+defsize
+end
+
+
+
+
+
+
+
+
+ #skip(n) ⇒ Integer
+
+
+
+
+
+
+
+
+
Consumes n bytes from the head of the buffer. If the size of the buffer is less than n, it skips all of data in the buffer and returns integer less than n.
+
+
If n is 0, it does nothing and returns 0.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ n
+
+
+ (Integer)
+
+
+
+ —
+
+
byte size to skip
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+ —
+
+
byte size actually skipped
+
+
+
+
+
+
+
+
+
+
+
+
+122
+123
+
+
+
# File 'doclib/msgpack/buffer.rb', line 122
+
+defskip(n)
+end
Consumes n bytes from the head of the buffer. If the size of the buffer is less than n, it does nothing and raises EOFError. If n is 0, it does nothing.
# File 'doclib/msgpack/buffer.rb', line 59
+
+defwrite(data)
+end
+
+
+
+
+
+
+
+
+ #write_to(io) ⇒ Integer
+
+
+
+
+
+
+
+
+
Writes all of data in the internal buffer into the given IO. This method consumes and removes data from the internal buffer. io must respond to write(data) method.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ io
+
+
+ (IO)
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+ —
+
+
byte size of written data
+
+
+
+
+
+
+
+
+
+
+
+
+189
+190
+
+
+
# File 'doclib/msgpack/buffer.rb', line 189
+
+defwrite_to(io)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/MessagePack/ExtensionValue.html b/MessagePack/ExtensionValue.html
new file mode 100644
index 00000000..7905fdca
--- /dev/null
+++ b/MessagePack/ExtensionValue.html
@@ -0,0 +1,321 @@
+
+
+
+
+
+
+ Class: MessagePack::ExtensionValue
+
+ — Documentation by YARD 0.9.37
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
MessagePack::ExtensionValue is a struct to represent unknown ext type object. Its contents are accessed by type and payload (messagepack bytes representation) methods. And it is extended to add to_msgpack object.
Deserializes an object from the string or io and returns it.
+
+
If there’re not enough data to deserialize one object, this method raises EOFError. If data format is invalid, this method raises MessagePack::MalformedFormatError. If the object nests too deeply, this method raises MessagePack::StackError.
Creates a MessagePack::PooledFactory instance of the given size.
+
+
PooledFactory keeps Packer and Unpacker instance in a pool for improved performance. Note that the size defines how many instances are kept in cache, not the maximum of instances that can be created. If the pool limit is reached, a new instance is created anyway.
Register a type and Class to be registered for packer and/or unpacker. If options are not specified, factory will use :to_msgpack_ext for packer, and :from_msgpack_ext for unpacker.
+
+
Supported options:
+
+
:packer specify symbol or proc object for packer
+
+
:unpacker specify symbol or proc object for unpacker
+
+
:optimized_symbols_parsing specify true to use the optimized symbols parsing (not supported on JRuby now)
+
+
recursive specify true to receive the packer or unpacker as argument to generate the extension body manually.
# File 'doclib/msgpack/factory.rb', line 139
+
+defdump(object)
+end
+
+
+
+
+
+
+
+
+ #load(data) ⇒ Object
+
+
+
+
+
+
+
+
+
Deserializes an object from the string or io and returns it.
+
+
If there’re not enough data to deserialize one object, this method raises EOFError. If data format is invalid, this method raises MessagePack::MalformedFormatError. If the object nests too deeply, this method raises MessagePack::StackError.
Register a new ext type to serialize it. This method should be called with one of method name or block, which returns bytes(ASCII-8BIT String) representation of object to be serialized.
Write a header of a binary string whose size is n. Useful if you want to append large binary data without loading it into memory at once. For example, MessagePack::Packer.new(io).write_bin_header(12).flush io.write(‘chunk1’) io.write(‘chunk2’) is the same as write(‘chunk1chunk2’.encode(Encoding::BINARY)).
Serializes value as 32-bit single precision float into internal buffer. value will be approximated with the nearest possible single precision float, thus being potentially lossy. However, the serialized string will only take up 5 bytes instead of 9 bytes compared to directly serializing a 64-bit double precision Ruby Float.
# File 'doclib/msgpack/packer.rb', line 115
+
+defwrite_map_header(n)
+end
+
+
+
+
+
+
+
+
+ #write_nil ⇒ Object
+
+
+
+
+
+
+
+
+
Serializes a nil object. Same as write(nil).
+
+
+
+
+
+
+
+
+
+
+
+
+
+91
+92
+
+
+
# File 'doclib/msgpack/packer.rb', line 91
+
+defwrite_nil
+end
+
+
+
+
+
+
+
+
+ #write_to(io) ⇒ Integer
+
+
+
+
+
+
+
+
+
Writes all of data in the internal buffer into the given IO. Same as buffer.write_to(io). This method consumes and removes data from the internal buffer. io must respond to write(data) method.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ io
+
+
+ (IO)
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+ —
+
+
byte size of written data
+
+
+
+
+
+
+
+
+
+
+
+
+216
+217
+
+
+
# File 'doclib/msgpack/packer.rb', line 216
+
+defwrite_to(io)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/MessagePack/StackError.html b/MessagePack/StackError.html
new file mode 100644
index 00000000..ed27ad94
--- /dev/null
+++ b/MessagePack/StackError.html
@@ -0,0 +1,132 @@
+
+
+
+
+
+
+ Exception: MessagePack::StackError
+
+ — Documentation by YARD 0.9.37
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
:symbolize_keys deserialize keys of Hash objects as Symbol instead of String
+
+
:freeze freeze the deserialized objects. Can allow string deduplication and some allocation elision.
+
+
:key_cache Enable caching of map keys, this can improve performance significantly if the same map keys are frequently encountered, but also degrade performance if that’s not the case.
+
+
:allow_unknown_ext allow to deserialize ext type object with unknown type id as ExtensionValue instance. Otherwise (by default), unpacker throws UnknownExtTypeError.
# File 'doclib/msgpack/unpacker.rb', line 173
+
+deffeed_each(data,&block)
+end
+
+
+
+
+
+
+
+
+ #read ⇒ Object
+
+
+
+ Also known as:
+ unpack
+
+
+
+
+
+
+
+
Deserializes an object from the io or internal buffer and returns it.
+
+
This method reads data from io into the internal buffer and deserializes an object from the buffer. It repeats reading data from the io until enough data is available to deserialize at least one object. After deserializing one object, unused data is left in the internal buffer.
+
+
If there’re not enough data to deserialize one object, this method raises EOFError. If data format is invalid, this method raises MessagePack::MalformedFormatError. If the object nests too deeply, this method raises MessagePack::StackError.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+ —
+
+
deserialized object
+
+
+
+
+
+
+
+
+
+
+
+
+88
+89
+
+
+
# File 'doclib/msgpack/unpacker.rb', line 88
+
+defread
+end
+
+
+
+
+
+
+
+
+ #read_array_header ⇒ Integer
+
+
+
+
+
+
+
+
+
Read a header of an array and returns its size. It converts a serialized array into a stream of elements.
+
+
If the serialized object is not an array, it raises MessagePack::UnexpectedTypeError. If there’re not enough data, this method raises EOFError.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+ —
+
+
size of the array
+
+
+
+
+
+
+
+
+
+
+
+
+124
+125
+
+
+
# File 'doclib/msgpack/unpacker.rb', line 124
+
+defread_array_header
+end
+
+
+
+
+
+
+
+
+ #read_map_header ⇒ Integer
+
+
+
+
+
+
+
+
+
Reads a header of an map and returns its size. It converts a serialized map into a stream of key-value pairs.
+
+
If the serialized object is not a map, it raises MessagePack::UnexpectedTypeError. If there’re not enough data, this method raises EOFError.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+ —
+
+
size of the map
+
+
+
+
+
+
+
+
+
+
+
+
+136
+137
+
+
+
# File 'doclib/msgpack/unpacker.rb', line 136
+
+defread_map_header
+end
Register a new ext type to deserialize it. This method should be called with Class and its class method name, or block, which returns a instance object.
# File 'doclib/msgpack/core_ext.rb', line 8
+
+defto_msgpack(packer=nil)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/README.md b/README.md
deleted file mode 100644
index 6a7b72d5..00000000
--- a/README.md
+++ /dev/null
@@ -1,302 +0,0 @@
-# MessagePack
-
-[MessagePack](http://msgpack.org) is an efficient binary serialization format.
-It lets you exchange data among multiple languages like JSON but it's faster and smaller.
-For example, small integers (like flags or error code) are encoded into a single byte,
-and typical short strings only require an extra byte in addition to the strings themselves.
-
-If you ever wished to use JSON for convenience (storing an image with metadata) but could
-not for technical reasons (binary data, size, speed...), MessagePack is a perfect replacement.
-
-```ruby
-require 'msgpack'
-msg = [1,2,3].to_msgpack #=> "\x93\x01\x02\x03"
-MessagePack.unpack(msg) #=> [1,2,3]
-```
-
-Add msgpack to your Gemfile to install with Bundler:
-
-```ruby
-# Gemfile
-gem 'msgpack'
-```
-
-Or, use RubyGems to install:
-
- gem install msgpack
-
-Or, build msgpack-ruby and install from a checked-out msgpack-ruby repository:
-
- bundle
- rake
- gem install --local pkg/msgpack
-
-
-## Use cases
-
-* Create REST API returing MessagePack using Rails + [RABL](https://github.com/nesquena/rabl)
-* Store objects efficiently serialized by msgpack on memcached or Redis
- * In fact Redis supports msgpack in [EVAL-scripts](https://redis.io/docs/latest/commands/eval/)
-* Upload data in efficient format from mobile devices such as smartphones
- * MessagePack works on iPhone/iPad and Android. See also [Objective-C](https://github.com/msgpack/msgpack-objectivec) and [Java](https://github.com/msgpack/msgpack-java) implementations
-* Design a portable protocol to communicate with embedded devices
- * Check also [Fluentd](https://www.fluentd.org) which is a log collector which uses msgpack for the log format (they say it uses JSON but actually it's msgpack, which is compatible with JSON)
-* Exchange objects between software components written in different languages
- * You'll need a flexible but efficient format so that components exchange objects while keeping compatibility
-
-## Portability
-
-MessagePack for Ruby should run on x86, ARM, PowerPC, SPARC and other CPU architectures.
-
-And it works with MRI (CRuby) and Rubinius.
-Patches to improve portability are highly welcomed.
-
-
-## Serializing objects
-
-Use `MessagePack.pack` or `to_msgpack`:
-
-```ruby
-require 'msgpack'
-msg = MessagePack.pack(obj) # or
-msg = obj.to_msgpack
-File.binwrite('mydata.msgpack', msg)
-```
-
-### Streaming serialization
-
-Packer provides advanced API to serialize objects in streaming style:
-
-```ruby
-# serialize a 2-element array [e1, e2]
-pk = MessagePack::Packer.new(io)
-pk.write_array_header(2).write(e1).write(e2).flush
-```
-
-See [API reference](http://ruby.msgpack.org/MessagePack/Packer.html) for details.
-
-## Deserializing objects
-
-Use `MessagePack.unpack`:
-
-```ruby
-require 'msgpack'
-msg = File.binread('mydata.msgpack')
-obj = MessagePack.unpack(msg)
-```
-
-### Streaming deserialization
-
-Unpacker provides advanced API to deserialize objects in streaming style:
-
-```ruby
-# deserialize objects from an IO
-u = MessagePack::Unpacker.new(io)
-u.each do |obj|
- # ...
-end
-```
-
-or event-driven style which works well with EventMachine:
-
-```ruby
-# event-driven deserialization
-def on_read(data)
- @u ||= MessagePack::Unpacker.new
- @u.feed_each(data) {|obj|
- # ...
- }
-end
-```
-
-See [API reference](http://ruby.msgpack.org/MessagePack/Unpacker.html) for details.
-
-## Serializing and deserializing symbols
-
-By default, symbols are serialized as strings:
-
-```ruby
-packed = :symbol.to_msgpack # => "\xA6symbol"
-MessagePack.unpack(packed) # => "symbol"
-```
-
-This can be customized by registering an extension type for them:
-
-```ruby
-MessagePack::DefaultFactory.register_type(0x00, Symbol)
-
-# symbols now survive round trips
-packed = :symbol.to_msgpack # => "\xc7\x06\x00symbol"
-MessagePack.unpack(packed) # => :symbol
-```
-
-The extension type for symbols is configurable like any other extension type.
-For example, to customize how symbols are packed you can just redefine
-Symbol#to_msgpack_ext. Doing this gives you an option to prevent symbols from
-being serialized altogether by throwing an exception:
-
-```ruby
-class Symbol
- def to_msgpack_ext
- raise "Serialization of symbols prohibited"
- end
-end
-
-MessagePack::DefaultFactory.register_type(0x00, Symbol)
-
-[1, :symbol, 'string'].to_msgpack # => RuntimeError: Serialization of symbols prohibited
-```
-
-## Serializing and deserializing Time instances
-
-There are the timestamp extension type in MessagePack,
-but it is not registered by default.
-
-To map Ruby's Time to MessagePack's timestamp for the default factory:
-
-```ruby
-MessagePack::DefaultFactory.register_type(
- MessagePack::Timestamp::TYPE, # or just -1
- Time,
- packer: MessagePack::Time::Packer,
- unpacker: MessagePack::Time::Unpacker
-)
-```
-
-See [API reference](http://ruby.msgpack.org/) for details.
-
-## Extension Types
-
-Packer and Unpacker support [Extension types of MessagePack](https://github.com/msgpack/msgpack/blob/master/spec.md#types-extension-type).
-
-```ruby
-# register how to serialize custom class at first
-pk = MessagePack::Packer.new(io)
-pk.register_type(0x01, MyClass1, :to_msgpack_ext) # equal to pk.register_type(0x01, MyClass)
-pk.register_type(0x02, MyClass2){|obj| obj.how_to_serialize() } # blocks also available
-
-# almost same API for unpacker
-uk = MessagePack::Unpacker.new()
-uk.register_type(0x01, MyClass1, :from_msgpack_ext)
-uk.register_type(0x02){|data| MyClass2.create_from_serialized_data(data) }
-```
-
-`MessagePack::Factory` is to create packer and unpacker which have same extension types.
-
-```ruby
-factory = MessagePack::Factory.new
-factory.register_type(0x01, MyClass1) # same with next line
-factory.register_type(0x01, MyClass1, packer: :to_msgpack_ext, unpacker: :from_msgpack_ext)
-pk = factory.packer(options_for_packer)
-uk = factory.unpacker(options_for_unpacker)
-```
-
-For `MessagePack.pack` and `MessagePack.unpack`, default packer/unpacker refer `MessagePack::DefaultFactory`. Call `MessagePack::DefaultFactory.register_type` to enable types process globally.
-
-```ruby
-MessagePack::DefaultFactory.register_type(0x03, MyClass3)
-MessagePack.unpack(data_with_ext_typeid_03) #=> MyClass3 instance
-```
-
-Alternatively, extension types can call the packer or unpacker recursively to generate the extension data:
-
-```ruby
-Point = Struct.new(:x, :y)
-factory = MessagePack::Factory.new
-factory.register_type(
- 0x01,
- Point,
- packer: ->(point, packer) {
- packer.write(point.x)
- packer.write(point.y)
- },
- unpacker: ->(unpacker) {
- x = unpacker.read
- y = unpacker.read
- Point.new(x, y)
- },
- recursive: true,
-)
-factory.load(factory.dump(Point.new(12, 34))) # => #
-```
-
-## Pooling
-
-Creating `Packer` and `Unpacker` objects is expensive. For best performance it is preferable to re-use these objects.
-
-`MessagePack::Factory#pool` makes that easier:
-
-```ruby
-factory = MessagePack::Factory.new
-factory.register_type(
- 0x01,
- Point,
- packer: ->(point, packer) {
- packer.write(point.x)
- packer.write(point.y)
- },
- unpacker: ->(unpacker) {
- x = unpacker.read
- y = unpacker.read
- Point.new(x, y)
- },
- recursive: true,
-)
-pool = factory.pool(5) # The pool size should match the number of threads expected to use the factory concurrently.
-
-pool.load(pool.dump(Point.new(12, 34))) # => #
-```
-
-## Buffer API
-
-MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.
-
-This [MessagePack::Buffer](http://ruby.msgpack.org/MessagePack/Buffer.html) is backed with a fixed-length shared memory pool which is very fast for small data (<= 4KB),
-and has zero-copy capability which significantly affects performance to handle large binary data.
-
-## How to build and run tests
-
-Before building msgpack, you need to install bundler and dependencies.
-
- gem install bundler
- bundle install
-
-Then, you can run the tasks as follows:
-
-### Build
-
- bundle exec rake build
-
-### Run tests
-
- bundle exec rake spec
-
-### Generating docs
-
- bundle exec rake doc
-
-## How to build -java rubygems
-
-To build -java gems for JRuby, run:
-
- rake build:java
-
-If this directory has Gemfile.lock (generated with MRI), remove it beforehand.
-
-## Updating documents
-
-Online documentation (https://ruby.msgpack.org) is generated from the gh-pages branch.
-To update documents in gh-pages branch:
-
- bundle exec rake doc
- git checkout gh-pages
- cp -a doc/* ./
-
-## Copyright
-
-* Author
- * Sadayuki Furuhashi
-* Copyright
- * Copyright (c) 2008-2015 Sadayuki Furuhashi
-* License
- * Apache License, Version 2.0
diff --git a/Rakefile b/Rakefile
index 979f8c95..815897d3 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,82 +1,23 @@
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
require 'fileutils'
-require 'rspec/core'
-require 'rspec/core/rake_task'
-require 'yard'
-if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('2.6.0')
- require 'ruby_memcheck'
- require 'ruby_memcheck/rspec/rake_task'
-
- RubyMemcheck.config(binary_name: 'msgpack')
-end
-
-task :spec => :compile
-
-desc 'Run RSpec code examples and measure coverage'
-task :coverage do |t|
- ENV['SIMPLE_COV'] = '1'
- Rake::Task["spec"].invoke
-end
-
-desc 'Generate YARD document'
-YARD::Rake::YardocTask.new(:doc) do |t|
- t.files = ['lib/msgpack/version.rb','doclib/**/*.rb']
- t.options = []
- t.options << '--debug' << '--verbose' if $trace
-end
-
-spec = eval File.read("msgpack.gemspec")
-
-if RUBY_PLATFORM =~ /java/
- require 'rake/javaextensiontask'
-
- Rake::JavaExtensionTask.new('msgpack', spec) do |ext|
- ext.ext_dir = 'ext/java'
- jruby_home = RbConfig::CONFIG['prefix']
- jars = ["#{jruby_home}/lib/jruby.jar"]
- ext.classpath = jars.map { |x| File.expand_path(x) }.join(':')
- ext.lib_dir = File.join(*['lib', 'msgpack', ENV['FAT_DIR']].compact)
- ext.release = '8'
- end
-else
- require 'rake/extensiontask'
-
- Rake::ExtensionTask.new('msgpack', spec) do |ext|
- ext.ext_dir = 'ext/msgpack'
- ext.cross_compile = true
- ext.lib_dir = File.join(*['lib', 'msgpack', ENV['FAT_DIR']].compact)
- # cross_platform names are of MRI's platform name
- ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+task :update do
+ if File.directory?("msgpack-ruby")
+ Dir.glob("msgpack-ruby/*", &FileUtils.method(:rm_rf))
+ Dir.chdir("msgpack-ruby") do
+ sh "git checkout ."
+ end
+ else
+ sh "git clone git://github.com/msgpack/msgpack-ruby.git"
end
-end
-test_pattern = case
- when RUBY_PLATFORM =~ /java/ then 'spec/{,jruby/}*_spec.rb'
- when RUBY_ENGINE =~ /rbx/ then 'spec/*_spec.rb'
- else 'spec/{,cruby/}*_spec.rb' # MRI
- end
-spec_config = lambda do |t|
- t.rspec_opts = ["-c", "-f progress"]
- t.rspec_opts << "-Ilib"
- t.pattern = test_pattern
- t.verbose = true
-end
-RSpec::Core::RakeTask.new(:spec, &spec_config)
-if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('2.6.0')
- namespace :spec do
- RubyMemcheck::RSpec::RakeTask.new(valgrind: :compile, &spec_config)
+ Dir.chdir("msgpack-ruby") do
+ sh "git checkout master"
+ sh "git pull"
+ sh "rake doc"
end
-end
-namespace :build do
- desc 'Build gem for JRuby after cleaning'
- task :java => [:clean, :spec, :build]
+ FileUtils.cp_r Dir.glob("msgpack-ruby/doc/*"), '.'
end
-CLEAN.include('lib/msgpack/msgpack.*')
+task :default => :update
-task :default => [:spec, :build, :doc]
diff --git a/String.html b/String.html
new file mode 100644
index 00000000..208e8529
--- /dev/null
+++ b/String.html
@@ -0,0 +1,219 @@
+
+
+
+
+
+
+ Class: String
+
+ — Documentation by YARD 0.9.37
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
MessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON but it’s faster and smaller. For example, small integers (like flags or error code) are encoded into a single byte, and typical short strings only require an extra byte in addition to the strings themselves.
+
+
If you ever wished to use JSON for convenience (storing an image with metadata) but could not for technical reasons (binary data, size, speed…), MessagePack is a perfect replacement.
Upload data in efficient format from mobile devices such as smartphones
+
+
MessagePack works on iPhone/iPad and Android. See also Objective-C and Java implementations
+
+
Design a portable protocol to communicate with embedded devices
+
+
Check also Fluentd which is a log collector which uses msgpack for the log format (they say it uses JSON but actually it’s msgpack, which is compatible with JSON)
+
+
Exchange objects between software components written in different languages
+
+
You’ll need a flexible but efficient format so that components exchange objects while keeping compatibility
+
+
+
Portability
+
+
MessagePack for Ruby should run on x86, ARM, PowerPC, SPARC and other CPU architectures.
+
+
And it works with MRI (CRuby) and Rubinius. Patches to improve portability are highly welcomed.
+
+
Serializing objects
+
+
Use MessagePack.pack or to_msgpack:
+
+
require'msgpack'
+msg=MessagePack.pack(obj)# or
+msg=obj.to_msgpack
+File.binwrite('mydata.msgpack',msg)
+
+
+
Streaming serialization
+
+
Packer provides advanced API to serialize objects in streaming style:
+
+
# serialize a 2-element array [e1, e2]
+pk=MessagePack::Packer.new(io)
+pk.write_array_header(2).write(e1).write(e2).flush
+
The extension type for symbols is configurable like any other extension type. For example, to customize how symbols are packed you can just redefine Symbol#to_msgpack_ext. Doing this gives you an option to prevent symbols from being serialized altogether by throwing an exception:
+
+
classSymbol
+ defto_msgpack_ext
+ raise"Serialization of symbols prohibited"
+ end
+end
+
+MessagePack::DefaultFactory.register_type(0x00,Symbol)
+
+[1,:symbol,'string'].to_msgpack# => RuntimeError: Serialization of symbols prohibited
+
+
+
Serializing and deserializing Time instances
+
+
There are the timestamp extension type in MessagePack, but it is not registered by default.
+
+
To map Ruby’s Time to MessagePack’s timestamp for the default factory:
# register how to serialize custom class at first
+pk=MessagePack::Packer.new(io)
+pk.register_type(0x01,MyClass1,:to_msgpack_ext)# equal to pk.register_type(0x01, MyClass)
+pk.register_type(0x02,MyClass2){|obj|obj.how_to_serialize()}# blocks also available
+
+# almost same API for unpacker
+uk=MessagePack::Unpacker.new()
+uk.register_type(0x01,MyClass1,:from_msgpack_ext)
+uk.register_type(0x02){|data|MyClass2.create_from_serialized_data(data)}
+
+
+
MessagePack::Factory is to create packer and unpacker which have same extension types.
+
+
factory=MessagePack::Factory.new
+factory.register_type(0x01,MyClass1)# same with next line
+factory.register_type(0x01,MyClass1,packer::to_msgpack_ext,unpacker::from_msgpack_ext)
+pk=factory.packer(options_for_packer)
+uk=factory.unpacker(options_for_unpacker)
+
+
+
For MessagePack.pack and MessagePack.unpack, default packer/unpacker refer MessagePack::DefaultFactory. Call MessagePack::DefaultFactory.register_type to enable types process globally.
Creating Packer and Unpacker objects is expensive. For best performance it is preferable to re-use these objects.
+
+
MessagePack::Factory#pool makes that easier:
+
+
factory=MessagePack::Factory.new
+factory.register_type(
+ 0x01,
+ Point,
+ packer:->(point,packer){
+ packer.write(point.x)
+ packer.write(point.y)
+ },
+ unpacker:->(unpacker){
+ x=unpacker.read
+ y=unpacker.read
+ Point.new(x,y)
+ },
+ recursive:true,
+)
+pool=factory.pool(5)# The pool size should match the number of threads expected to use the factory concurrently.
+
+pool.load(pool.dump(Point.new(12,34)))# => #<struct Point x=12, y=34>
+
+
+
Buffer API
+
+
MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.
+
+
This MessagePack::Buffer is backed with a fixed-length shared memory pool which is very fast for small data (<= 4KB), and has zero-copy capability which significantly affects performance to handle large binary data.
+
+
How to build and run tests
+
+
Before building msgpack, you need to install bundler and dependencies.
+
+
geminstallbundler
+bundleinstall
+
+
+
Then, you can run the tasks as follows:
+
+
Build
+
+
bundleexecrakebuild
+
+
+
Run tests
+
+
bundleexecrakespec
+
+
+
Generating docs
+
+
bundleexecrakedoc
+
+
+
How to build -java rubygems
+
+
To build -java gems for JRuby, run:
+
+
rakebuild:java
+
+
+
If this directory has Gemfile.lock (generated with MRI), remove it beforehand.
+
+
Updating documents
+
+
Online documentation (ruby.msgpack.org) is generated from the gh-pages branch. To update documents in gh-pages branch:
MessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON but it’s faster and smaller. For example, small integers (like flags or error code) are encoded into a single byte, and typical short strings only require an extra byte in addition to the strings themselves.
+
+
If you ever wished to use JSON for convenience (storing an image with metadata) but could not for technical reasons (binary data, size, speed…), MessagePack is a perfect replacement.
Upload data in efficient format from mobile devices such as smartphones
+
+
MessagePack works on iPhone/iPad and Android. See also Objective-C and Java implementations
+
+
Design a portable protocol to communicate with embedded devices
+
+
Check also Fluentd which is a log collector which uses msgpack for the log format (they say it uses JSON but actually it’s msgpack, which is compatible with JSON)
+
+
Exchange objects between software components written in different languages
+
+
You’ll need a flexible but efficient format so that components exchange objects while keeping compatibility
+
+
+
Portability
+
+
MessagePack for Ruby should run on x86, ARM, PowerPC, SPARC and other CPU architectures.
+
+
And it works with MRI (CRuby) and Rubinius. Patches to improve portability are highly welcomed.
+
+
Serializing objects
+
+
Use MessagePack.pack or to_msgpack:
+
+
require'msgpack'
+msg=MessagePack.pack(obj)# or
+msg=obj.to_msgpack
+File.binwrite('mydata.msgpack',msg)
+
+
+
Streaming serialization
+
+
Packer provides advanced API to serialize objects in streaming style:
+
+
# serialize a 2-element array [e1, e2]
+pk=MessagePack::Packer.new(io)
+pk.write_array_header(2).write(e1).write(e2).flush
+
The extension type for symbols is configurable like any other extension type. For example, to customize how symbols are packed you can just redefine Symbol#to_msgpack_ext. Doing this gives you an option to prevent symbols from being serialized altogether by throwing an exception:
+
+
classSymbol
+ defto_msgpack_ext
+ raise"Serialization of symbols prohibited"
+ end
+end
+
+MessagePack::DefaultFactory.register_type(0x00,Symbol)
+
+[1,:symbol,'string'].to_msgpack# => RuntimeError: Serialization of symbols prohibited
+
+
+
Serializing and deserializing Time instances
+
+
There are the timestamp extension type in MessagePack, but it is not registered by default.
+
+
To map Ruby’s Time to MessagePack’s timestamp for the default factory:
# register how to serialize custom class at first
+pk=MessagePack::Packer.new(io)
+pk.register_type(0x01,MyClass1,:to_msgpack_ext)# equal to pk.register_type(0x01, MyClass)
+pk.register_type(0x02,MyClass2){|obj|obj.how_to_serialize()}# blocks also available
+
+# almost same API for unpacker
+uk=MessagePack::Unpacker.new()
+uk.register_type(0x01,MyClass1,:from_msgpack_ext)
+uk.register_type(0x02){|data|MyClass2.create_from_serialized_data(data)}
+
+
+
MessagePack::Factory is to create packer and unpacker which have same extension types.
+
+
factory=MessagePack::Factory.new
+factory.register_type(0x01,MyClass1)# same with next line
+factory.register_type(0x01,MyClass1,packer::to_msgpack_ext,unpacker::from_msgpack_ext)
+pk=factory.packer(options_for_packer)
+uk=factory.unpacker(options_for_unpacker)
+
+
+
For MessagePack.pack and MessagePack.unpack, default packer/unpacker refer MessagePack::DefaultFactory. Call MessagePack::DefaultFactory.register_type to enable types process globally.
Creating Packer and Unpacker objects is expensive. For best performance it is preferable to re-use these objects.
+
+
MessagePack::Factory#pool makes that easier:
+
+
factory=MessagePack::Factory.new
+factory.register_type(
+ 0x01,
+ Point,
+ packer:->(point,packer){
+ packer.write(point.x)
+ packer.write(point.y)
+ },
+ unpacker:->(unpacker){
+ x=unpacker.read
+ y=unpacker.read
+ Point.new(x,y)
+ },
+ recursive:true,
+)
+pool=factory.pool(5)# The pool size should match the number of threads expected to use the factory concurrently.
+
+pool.load(pool.dump(Point.new(12,34)))# => #<struct Point x=12, y=34>
+
+
+
Buffer API
+
+
MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.
+
+
This MessagePack::Buffer is backed with a fixed-length shared memory pool which is very fast for small data (<= 4KB), and has zero-copy capability which significantly affects performance to handle large binary data.
+
+
How to build and run tests
+
+
Before building msgpack, you need to install bundler and dependencies.
+
+
geminstallbundler
+bundleinstall
+
+
+
Then, you can run the tasks as follows:
+
+
Build
+
+
bundleexecrakebuild
+
+
+
Run tests
+
+
bundleexecrakespec
+
+
+
Generating docs
+
+
bundleexecrakedoc
+
+
+
How to build -java rubygems
+
+
To build -java gems for JRuby, run:
+
+
rakebuild:java
+
+
+
If this directory has Gemfile.lock (generated with MRI), remove it beforehand.
+
+
Updating documents
+
+
Online documentation (ruby.msgpack.org) is generated from the gh-pages branch. To update documents in gh-pages branch: