Class Encoder

Fleece/Core/Encoder.hh:29–267

Generates Fleece-encoded data. */

    /** Generates Fleece-encoded data. */
    class Encoder {
    public:
        /** Constructs an encoder. */
        Encoder(size_t reserveOutputSize =256);
        Encoder(FILE* NONNULL);
        ~Encoder();

        /** Sets the uniqueStrings property. If true (the default), the encoder tries to write
            each unique string only once. This saves space but makes the encoder slightly slower. */
        void uniqueStrings(bool b)      {_uniqueStrings = b;}

        /** Sets the base Fleece data that the encoded data will be (logically) appended to.
            Any writeValue() calls whose Value points into the base data will be written as
            pointers.
            @param base  The base Fleece document that's being appended to.
            @param markExternPointers  If true, pointers into the base document (i.e. out of the
                        encoded data) will be marked with the `extern` flag. The resulting Fleece
                        document must then be opened as a Doc using the `externData` property
                        pointing to wherever a copy of the base document is.
            @param cutoff  If nonzero, this specifies the maximum number of bytes of the base
                        (starting from the end) that should be used. Any base data before
                        the cutoff will not be referenced in the encoder output. */
        void setBase(slice base, bool markExternPointers =false, size_t cutoff =0);

        /** Scans the base document for strings and adds them to the encoder's string table.
            If equivalent strings are written to the encoder they will then be encoded as pointers
            to the existing strings. */
        void reuseBaseStrings();

        bool valueIsInBase(const Value *value) const;

        bool isEmpty() const            {return _out.length() == 0 && _stackDepth == 1 && _items->empty();}
        size_t bytesWritten() const     {return _out.length();} // may be an underestimate

        /** Ends encoding, writing the last of the data to the Writer. */
        void end();

        /** Returns the encoded data. This implicitly calls end(). */
        alloc_slice finish();

        /** Returns the encoded data as a Doc. This implicitly calls end(). */
        Retained<Doc> finishDoc();

        /** Resets the encoder so it can be used again. */
        void reset();

        /////// Writing data:

        void writeNull();
        void writeUndefined();
        void writeBool(bool);

        void writeInt(int64_t i);
        void writeUInt(uint64_t i);
        void writeFloat(float);
        void writeDouble(double);

        void writeString(slice s)                           {(void)_writeString(s);}