org.redkale.convert.bson

## 类 BsonWriter

- java.lang.Object
- - org.redkale.convert.Writer
  - - org.redkale.convert.bson.BsonWriter

- 直接已知子类:
    BsonByteBufferWriter

      public class BsonWriter
      extends Writer

  详情见: http://www.redkale.org

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `protected int` | `count`
    `protected boolean` | `tiny`

    - ### 从类继承的字段 org.redkale.convert.Writer

      `comma`

  - ### 构造器概要

    构造器
    限定符 | 构造器和说明
    --- | ---
    `` | `BsonWriter()`
    `protected` | `BsonWriter(byte[] bs)`
    `` | `BsonWriter(int size)`

  - ### 方法概要

    所有方法 静态方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `int` | `count()`
    `static ObjectPool<BsonWriter>` | `createPool(int max)`
    `protected int` | `expand(int len)` 扩充指定长度的缓冲区
    `protected boolean` | `recycle()`
    `boolean` | `tiny()` 当tiny=true时， 字符串为空、boolean为false的字段值都会被跳过， 不会输出。
    `BsonWriter` | `tiny(boolean tiny)`
    `byte[]` | `toArray()`
    `java.nio.ByteBuffer[]` | `toBuffers()`
    `java.lang.String` | `toString()`
    `void` | `wirteClassName(java.lang.String clazz)` 写入类名
    `void` | `writeArrayB(int size)` 输出一个数组前的操作
    `void` | `writeArrayE()` 输出一个数组后的操作
    `void` | `writeArrayMark()` 输出数组元素间的间隔符
    `void` | `writeBoolean(boolean value)` 写入一个boolean值
    `void` | `writeByte(byte value)` 写入一个byte值
    `void` | `writeChar(char value)` 写入一个char值
    `void` | `writeDouble(double value)` 写入一个double值
    `void` | `writeFieldName(Attribute attribute)` 输出一个字段名
    `void` | `writeFloat(float value)` 写入一个float值
    `void` | `writeInt(int value)` 写入一个int值
    `void` | `writeLong(long value)` 写入一个long值
    `void` | `writeMapB(int size)` 输出一个Map前的操作
    `void` | `writeMapE()` 输出一个Map后的操作
    `void` | `writeMapMark()` 输出一个Map中key与value间的间隔符
    `void` | `writeNull()` 输出null值
    `void` | `writeObjectB(java.lang.Object obj)` 输出一个对象前的操作 注： 覆盖此方法必须要先调用父方法 super.writeObjectB(obj);
    `void` | `writeObjectE(java.lang.Object obj)` 输出一个对象后的操作
    `void` | `writeShort(short value)` 写入一个short值
    `void` | `writeSmallString(java.lang.String value)` 对于类的字段名、枚举值这些长度一般不超过255且不会出现双字节字符的字符串采用writeSmallString处理, readSmallString用于读取
    `void` | `writeString(java.lang.String value)` 写入一个String值
    `void` | `writeTo(byte... chs)`
    `void` | `writeTo(byte ch)`
    `void` | `writeTo(byte[] chs, int start, int len)`

    - ### 从类继承的方法 org.redkale.convert.Writer

      `writeObjectField, writeObjectNull`

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### 字段详细资料

    - #### count

          protected int count

    - #### tiny

          protected boolean tiny

  - ### 构造器详细资料

    - #### BsonWriter

          protected BsonWriter(byte[] bs)

    - #### BsonWriter

          public BsonWriter()

    - #### BsonWriter

          public BsonWriter(int size)

  - ### 方法详细资料

    - #### createPool

          public static ObjectPool<BsonWriter> createPool(int max)

    - #### toArray

          public byte[] toArray()

    - #### toBuffers

          public java.nio.ByteBuffer[] toBuffers()

    - #### tiny

          public final boolean tiny()

      从类复制的说明: `Writer`
      当tiny=true时， 字符串为空、boolean为false的字段值都会被跳过， 不会输出。
      指定者:
        `tiny` 在类中 `Writer`
      返回:
        是否简化

    - #### tiny

          public BsonWriter tiny(boolean tiny)

    - #### expand

          protected int expand(int len)

      扩充指定长度的缓冲区
      参数:
        `len` - 扩容长度
      返回:
        固定0

    - #### writeTo

          public void writeTo(byte ch)

    - #### writeTo

          public final void writeTo(byte... chs)

    - #### writeTo

          public void writeTo(byte[] chs,
                              int start,
                              int len)

    - #### recycle

          protected boolean recycle()

    - #### toString

          public java.lang.String toString()

      覆盖:
        `toString` 在类中 `java.lang.Object`

    - #### count

          public final int count()

    - #### writeBoolean

          public final void writeBoolean(boolean value)

      从类复制的说明: `Writer`
      写入一个boolean值
      指定者:
        `writeBoolean` 在类中 `Writer`
      参数:
        `value` - boolean值

    - #### writeByte

          public final void writeByte(byte value)

      从类复制的说明: `Writer`
      写入一个byte值
      指定者:
        `writeByte` 在类中 `Writer`
      参数:
        `value` - byte值

    - #### writeChar

          public final void writeChar(char value)

      从类复制的说明: `Writer`
      写入一个char值
      指定者:
        `writeChar` 在类中 `Writer`
      参数:
        `value` - char值

    - #### writeShort

          public final void writeShort(short value)

      从类复制的说明: `Writer`
      写入一个short值
      指定者:
        `writeShort` 在类中 `Writer`
      参数:
        `value` - short值

    - #### writeInt

          public final void writeInt(int value)

      从类复制的说明: `Writer`
      写入一个int值
      指定者:
        `writeInt` 在类中 `Writer`
      参数:
        `value` - int值

    - #### writeLong

          public final void writeLong(long value)

      从类复制的说明: `Writer`
      写入一个long值
      指定者:
        `writeLong` 在类中 `Writer`
      参数:
        `value` - long值

    - #### writeFloat

          public final void writeFloat(float value)

      从类复制的说明: `Writer`
      写入一个float值
      指定者:
        `writeFloat` 在类中 `Writer`
      参数:
        `value` - float值

    - #### writeDouble

          public final void writeDouble(double value)

      从类复制的说明: `Writer`
      写入一个double值
      指定者:
        `writeDouble` 在类中 `Writer`
      参数:
        `value` - double值

    - #### wirteClassName

          public final void wirteClassName(java.lang.String clazz)

      从类复制的说明: `Writer`
      写入类名
      指定者:
        `wirteClassName` 在类中 `Writer`
      参数:
        `clazz` - 类名

    - #### writeObjectB

          public final void writeObjectB(java.lang.Object obj)

      从类复制的说明: `Writer`
      输出一个对象前的操作 注： 覆盖此方法必须要先调用父方法 super.writeObjectB(obj);
      覆盖:
        `writeObjectB` 在类中 `Writer`
      参数:
        `obj` - 写入的对象

    - #### writeObjectE

          public final void writeObjectE(java.lang.Object obj)

      从类复制的说明: `Writer`
      输出一个对象后的操作
      指定者:
        `writeObjectE` 在类中 `Writer`
      参数:
        `obj` - 写入的对象

    - #### writeFieldName

          public final void writeFieldName(Attribute attribute)

      从类复制的说明: `Writer`
      输出一个字段名
      指定者:
        `writeFieldName` 在类中 `Writer`
      参数:
        `attribute` - 字段的Attribute对象

    - #### writeSmallString

          public final void writeSmallString(java.lang.String value)

      对于类的字段名、枚举值这些长度一般不超过255且不会出现双字节字符的字符串采用writeSmallString处理, readSmallString用于读取
      指定者:
        `writeSmallString` 在类中 `Writer`
      参数:
        `value` - String值

    - #### writeString

          public final void writeString(java.lang.String value)

      从类复制的说明: `Writer`
      写入一个String值
      指定者:
        `writeString` 在类中 `Writer`
      参数:
        `value` - String值

    - #### writeNull

          public final void writeNull()

      从类复制的说明: `Writer`
      输出null值
      指定者:
        `writeNull` 在类中 `Writer`

    - #### writeArrayB

          public final void writeArrayB(int size)

      从类复制的说明: `Writer`
      输出一个数组前的操作
      指定者:
        `writeArrayB` 在类中 `Writer`
      参数:
        `size` - 数组长度

    - #### writeArrayMark

          public final void writeArrayMark()

      从类复制的说明: `Writer`
      输出数组元素间的间隔符
      指定者:
        `writeArrayMark` 在类中 `Writer`

    - #### writeArrayE

          public final void writeArrayE()

      从类复制的说明: `Writer`
      输出一个数组后的操作
      指定者:
        `writeArrayE` 在类中 `Writer`

    - #### writeMapB

          public void writeMapB(int size)

      从类复制的说明: `Writer`
      输出一个Map前的操作
      指定者:
        `writeMapB` 在类中 `Writer`
      参数:
        `size` - map大小

    - #### writeMapMark

          public final void writeMapMark()

      从类复制的说明: `Writer`
      输出一个Map中key与value间的间隔符
      指定者:
        `writeMapMark` 在类中 `Writer`

    - #### writeMapE

          public final void writeMapE()

      从类复制的说明: `Writer`
      输出一个Map后的操作
      指定者:
        `writeMapE` 在类中 `Writer`