Removed old-style C++ handlers that relied on UB in favor of more normal ones.

1 files changed, 273 insertions, 330 deletions

diff --git a/upb/sink.h b/upb/sink.h
index 0b98f07..8cab45d 100644
--- a/upb/sink.h
+++ b/upb/sink.h
@@ -22,17 +22,177 @@
 
 #ifdef __cplusplus
 namespace upb {
-class BufferSink;
-class BufferSource;
 class BytesSink;
 class Sink;
 }
 #endif
 
-UPB_DECLARE_TYPE(upb::BufferSink, upb_bufsink)
-UPB_DECLARE_TYPE(upb::BufferSource, upb_bufsrc)
-UPB_DECLARE_TYPE(upb::BytesSink, upb_bytessink)
-UPB_DECLARE_TYPE(upb::Sink, upb_sink)
+/* upb_sink *******************************************************************/
+
+UPB_BEGIN_EXTERN_C
+
+typedef struct {
+  const upb_handlers *handlers;
+  void *closure;
+} upb_sink;
+
+#define PUTVAL(type, ctype)                                            \
+  UPB_INLINE bool upb_sink_put##type(upb_sink *s, upb_selector_t sel,  \
+                                     ctype val) {                      \
+    typedef upb_##type##_handlerfunc functype;                         \
+    functype *func;                                                    \
+    const void *hd;                                                    \
+    if (!s->handlers) return true;                                     \
+    func = (functype *)upb_handlers_gethandler(s->handlers, sel, &hd); \
+    if (!func) return true;                                            \
+    return func(s->closure, hd, val);                                  \
+  }
+
+PUTVAL(int32,  int32_t)
+PUTVAL(int64,  int64_t)
+PUTVAL(uint32, uint32_t)
+PUTVAL(uint64, uint64_t)
+PUTVAL(float,  float)
+PUTVAL(double, double)
+PUTVAL(bool,   bool)
+#undef PUTVAL
+
+UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
+  s->handlers = h;
+  s->closure = c;
+}
+
+UPB_INLINE size_t upb_sink_putstring(upb_sink *s, upb_selector_t sel,
+                                     const char *buf, size_t n,
+                                     const upb_bufhandle *handle) {
+  typedef upb_string_handlerfunc func;
+  func *handler;
+  const void *hd;
+  if (!s->handlers) return n;
+  handler = (func *)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!handler) return n;
+  return handler(s->closure, hd, buf, n, handle);
+}
+
+UPB_INLINE bool upb_sink_putunknown(upb_sink *s, const char *buf, size_t n) {
+  typedef upb_unknown_handlerfunc func;
+  func *handler;
+  const void *hd;
+  if (!s->handlers) return true;
+  handler =
+      (func *)upb_handlers_gethandler(s->handlers, UPB_UNKNOWN_SELECTOR, &hd);
+
+  if (!handler) return n;
+  return handler(s->closure, hd, buf, n);
+}
+
+UPB_INLINE bool upb_sink_startmsg(upb_sink *s) {
+  typedef upb_startmsg_handlerfunc func;
+  func *startmsg;
+  const void *hd;
+  if (!s->handlers) return true;
+  startmsg =
+      (func *)upb_handlers_gethandler(s->handlers, UPB_STARTMSG_SELECTOR, &hd);
+
+  if (!startmsg) return true;
+  return startmsg(s->closure, hd);
+}
+
+UPB_INLINE bool upb_sink_endmsg(upb_sink *s, upb_status *status) {
+  typedef upb_endmsg_handlerfunc func;
+  func *endmsg;
+  const void *hd;
+  if (!s->handlers) return true;
+  endmsg =
+      (func *)upb_handlers_gethandler(s->handlers, UPB_ENDMSG_SELECTOR, &hd);
+
+  if (!endmsg) return true;
+  return endmsg(s->closure, hd, status);
+}
+
+UPB_INLINE bool upb_sink_startseq(upb_sink *s, upb_selector_t sel,
+                                  upb_sink *sub) {
+  typedef upb_startfield_handlerfunc func;
+  func *startseq;
+  const void *hd;
+  sub->closure = s->closure;
+  sub->handlers = s->handlers;
+  if (!s->handlers) return true;
+  startseq = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!startseq) return true;
+  sub->closure = startseq(s->closure, hd);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endseq(upb_sink *s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endseq;
+  const void *hd;
+  if (!s->handlers) return true;
+  endseq = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!endseq) return true;
+  return endseq(s->closure, hd);
+}
+
+UPB_INLINE bool upb_sink_startstr(upb_sink *s, upb_selector_t sel,
+                                  size_t size_hint, upb_sink *sub) {
+  typedef upb_startstr_handlerfunc func;
+  func *startstr;
+  const void *hd;
+  sub->closure = s->closure;
+  sub->handlers = s->handlers;
+  if (!s->handlers) return true;
+  startstr = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!startstr) return true;
+  sub->closure = startstr(s->closure, hd, size_hint);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endstr(upb_sink *s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endstr;
+  const void *hd;
+  if (!s->handlers) return true;
+  endstr = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!endstr) return true;
+  return endstr(s->closure, hd);
+}
+
+UPB_INLINE bool upb_sink_startsubmsg(upb_sink *s, upb_selector_t sel,
+                                     upb_sink *sub) {
+  typedef upb_startfield_handlerfunc func;
+  func *startsubmsg;
+  const void *hd;
+  sub->closure = s->closure;
+  if (!s->handlers) {
+    sub->handlers = NULL;
+    return true;
+  }
+  sub->handlers = upb_handlers_getsubhandlers_sel(s->handlers, sel);
+  startsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!startsubmsg) return true;
+  sub->closure = startsubmsg(s->closure, hd);
+  return sub->closure ? true : false;
+}
+
+UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
+  typedef upb_endfield_handlerfunc func;
+  func *endsubmsg;
+  const void *hd;
+  if (!s->handlers) return true;
+  endsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel, &hd);
+
+  if (!endsubmsg) return s->closure;
+  return endsubmsg(s->closure, hd);
+}
+
+UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
@@ -81,16 +241,24 @@ class upb::Sink {
    *
    * TODO: once the Handlers know the expected closure type, verify that T
    * matches it. */
-  template <class T> Sink(const Handlers* handlers, T* closure);
+  template <class T> Sink(const upb_handlers* handlers, T* closure) {
+    Reset(handlers, closure);
+  }
+
+  upb_sink* ptr() { return &sink_; }
 
   /* Resets the value of the sink. */
-  template <class T> void Reset(const Handlers* handlers, T* closure);
+  template <class T> void Reset(const upb_handlers* handlers, T* closure) {
+    upb_sink_reset(&sink_, handlers, closure);
+  }
 
   /* Returns the top-level object that is bound to this sink.
    *
    * TODO: once the Handlers know the expected closure type, verify that T
    * matches it. */
-  template <class T> T* GetObject() const;
+  template <class T> T* GetObject() const {
+    return static_cast<T*>(sink_.closure);
+  }
 
   /* Functions for pushing data into the sink.
    *
@@ -108,37 +276,57 @@ class upb::Sink {
    *   // ...
    *   sink->EndMessage(&status);
    *   sink->EndSubMessage(endsubmsg_selector); */
-  bool StartMessage();
-  bool EndMessage(Status* status);
+  bool StartMessage() { return upb_sink_startmsg(&sink_); }
+  bool EndMessage(Status* status) { return upb_sink_endmsg(&sink_, status); }
 
   /* Putting of individual values.  These work for both repeated and
    * non-repeated fields, but for repeated fields you must wrap them in
    * calls to StartSequence()/EndSequence(). */
-  bool PutInt32(Handlers::Selector s, int32_t val);
-  bool PutInt64(Handlers::Selector s, int64_t val);
-  bool PutUInt32(Handlers::Selector s, uint32_t val);
-  bool PutUInt64(Handlers::Selector s, uint64_t val);
-  bool PutFloat(Handlers::Selector s, float val);
-  bool PutDouble(Handlers::Selector s, double val);
-  bool PutBool(Handlers::Selector s, bool val);
+  bool PutInt32(HandlersPtr::Selector s, int32_t val) {
+    return upb_sink_putint32(&sink_, s, val);
+  }
+
+  bool PutInt64(HandlersPtr::Selector s, int64_t val) {
+    return upb_sink_putint64(&sink_, s, val);
+  }
+
+  bool PutUInt32(HandlersPtr::Selector s, uint32_t val) {
+    return upb_sink_putuint32(&sink_, s, val);
+  }
+
+  bool PutUInt64(HandlersPtr::Selector s, uint64_t val) {
+    return upb_sink_putuint64(&sink_, s, val);
+  }
+
+  bool PutFloat(HandlersPtr::Selector s, float val) {
+    return upb_sink_putfloat(&sink_, s, val);
+  }
+
+  bool PutDouble(HandlersPtr::Selector s, double val) {
+    return upb_sink_putdouble(&sink_, s, val);
+  }
+
+  bool PutBool(HandlersPtr::Selector s, bool val) {
+    return upb_sink_putbool(&sink_, s, val);
+  }
 
   /* Putting of string/bytes values.  Each string can consist of zero or more
    * non-contiguous buffers of data.
    *
    * For StartString(), the function will write a sink for the string to "sub."
    * The sub-sink must be used for any/all PutStringBuffer() calls. */
-  bool StartString(Handlers::Selector s, size_t size_hint, Sink* sub);
-  size_t PutStringBuffer(Handlers::Selector s, const char *buf, size_t len,
-                         const BufferHandle *handle);
-  bool EndString(Handlers::Selector s);
+  bool StartString(HandlersPtr::Selector s, size_t size_hint, Sink* sub);
+  size_t PutStringBuffer(HandlersPtr::Selector s, const char *buf, size_t len,
+                         const upb_bufhandle *handle);
+  bool EndString(HandlersPtr::Selector s);
 
   /* For submessage fields.
    *
    * For StartSubMessage(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * submessage. */
-  bool StartSubMessage(Handlers::Selector s, Sink* sub);
-  bool EndSubMessage(Handlers::Selector s);
+  bool StartSubMessage(HandlersPtr::Selector s, Sink* sub);
+  bool EndSubMessage(HandlersPtr::Selector s);
 
   /* For repeated fields of any type, the sequence of values must be wrapped in
    * these calls.
@@ -146,84 +334,26 @@ class upb::Sink {
    * For StartSequence(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * sequence. */
-  bool StartSequence(Handlers::Selector s, Sink* sub);
-  bool EndSequence(Handlers::Selector s);
+  bool StartSequence(HandlersPtr::Selector s, Sink* sub);
+  bool EndSequence(HandlersPtr::Selector s);
 
   /* Copy and assign specifically allowed.
    * We don't even bother making these members private because so many
    * functions need them and this is mainly just a dumb data container anyway.
    */
-#else
-struct upb_sink {
-#endif
-  const upb_handlers *handlers;
-  void *closure;
-};
 
-#ifdef __cplusplus
-class upb::BytesSink {
- public:
-  BytesSink() {}
+ private:
+  upb_sink sink_;
+};
 
-  /* Constructs a new sink for the given frozen handlers and closure.
-   *
-   * TODO(haberman): once the Handlers know the expected closure type, verify
-   * that T matches it. */
-  template <class T> BytesSink(const BytesHandler* handler, T* closure);
+#endif  /* __cplusplus */
 
-  /* Resets the value of the sink. */
-  template <class T> void Reset(const BytesHandler* handler, T* closure);
+/* upb_bytessink **************************************************************/
 
-  bool Start(size_t size_hint, void **subc);
-  size_t PutBuffer(void *subc, const char *buf, size_t len,
-                   const BufferHandle *handle);
-  bool End();
-#else
-struct upb_bytessink {
-#endif
+typedef struct {
   const upb_byteshandler *handler;
   void *closure;
-};
-
-#ifdef __cplusplus
-
-/* A class for pushing a flat buffer of data to a BytesSink.
- * You can construct an instance of this to get a resumable source,
- * or just call the static PutBuffer() to do a non-resumable push all in one
- * go. */
-class upb::BufferSource {
- public:
-  BufferSource();
-  BufferSource(const char* buf, size_t len, BytesSink* sink);
-
-  /* Returns true if the entire buffer was pushed successfully.  Otherwise the
-   * next call to PutNext() will resume where the previous one left off.
-   * TODO(haberman): implement this. */
-  bool PutNext();
-
-  /* A static version; with this version is it not possible to resume in the
-   * case of failure or a partially-consumed buffer. */
-  static bool PutBuffer(const char* buf, size_t len, BytesSink* sink);
-
-  template <class T> static bool PutBuffer(const T& str, BytesSink* sink) {
-    return PutBuffer(str.c_str(), str.size(), sink);
-  }
-#else
-struct upb_bufsrc {
-  char dummy;
-#endif
-};
-
-UPB_BEGIN_EXTERN_C
-
-/* A class for accumulating output string data in a flat buffer. */
-
-upb_bufsink *upb_bufsink_new(upb_env *env);
-void upb_bufsink_free(upb_bufsink *sink);
-upb_bytessink *upb_bufsink_sink(upb_bufsink *sink);
-const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len);
-
-/* Inline definitions. */
+} upb_bytessink ;
 
 UPB_INLINE void upb_bytessink_reset(upb_bytessink *s, const upb_byteshandler *h,
                                     void *closure) {
@@ -240,8 +370,8 @@ UPB_INLINE bool upb_bytessink_start(upb_bytessink *s, size_t size_hint,
   start = (func *)s->handler->table[UPB_STARTSTR_SELECTOR].func;
 
   if (!start) return true;
-  *subc = start(s->closure, upb_handlerattr_handlerdata(
-                                &s->handler->table[UPB_STARTSTR_SELECTOR].attr),
+  *subc = start(s->closure,
+                s->handler->table[UPB_STARTSTR_SELECTOR].attr.handler_data,
                 size_hint);
   return *subc != NULL;
 }
@@ -255,8 +385,7 @@ UPB_INLINE size_t upb_bytessink_putbuf(upb_bytessink *s, void *subc,
   putbuf = (func *)s->handler->table[UPB_STRING_SELECTOR].func;
 
   if (!putbuf) return true;
-  return putbuf(subc, upb_handlerattr_handlerdata(
-                          &s->handler->table[UPB_STRING_SELECTOR].attr),
+  return putbuf(subc, s->handler->table[UPB_STRING_SELECTOR].attr.handler_data,
                 buf, size, handle);
 }
 
@@ -268,266 +397,80 @@ UPB_INLINE bool upb_bytessink_end(upb_bytessink *s) {
 
   if (!end) return true;
   return end(s->closure,
-             upb_handlerattr_handlerdata(
-                 &s->handler->table[UPB_ENDSTR_SELECTOR].attr));
-}
-
-bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink);
-
-#define PUTVAL(type, ctype)                                                    \
-  UPB_INLINE bool upb_sink_put##type(upb_sink *s, upb_selector_t sel,          \
-                                     ctype val) {                              \
-    typedef upb_##type##_handlerfunc functype;                                 \
-    functype *func;                                                            \
-    const void *hd;                                                            \
-    if (!s->handlers) return true;                                             \
-    func = (functype *)upb_handlers_gethandler(s->handlers, sel);              \
-    if (!func) return true;                                                    \
-    hd = upb_handlers_gethandlerdata(s->handlers, sel);                        \
-    return func(s->closure, hd, val);                                          \
-  }
-
-PUTVAL(int32,  int32_t)
-PUTVAL(int64,  int64_t)
-PUTVAL(uint32, uint32_t)
-PUTVAL(uint64, uint64_t)
-PUTVAL(float,  float)
-PUTVAL(double, double)
-PUTVAL(bool,   bool)
-#undef PUTVAL
-
-UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
-  s->handlers = h;
-  s->closure = c;
+             s->handler->table[UPB_ENDSTR_SELECTOR].attr.handler_data);
 }
 
-UPB_INLINE size_t upb_sink_putstring(upb_sink *s, upb_selector_t sel,
-                                     const char *buf, size_t n,
-                                     const upb_bufhandle *handle) {
-  typedef upb_string_handlerfunc func;
-  func *handler;
-  const void *hd;
-  if (!s->handlers) return n;
-  handler = (func *)upb_handlers_gethandler(s->handlers, sel);
-
-  if (!handler) return n;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return handler(s->closure, hd, buf, n, handle);
-}
-
-UPB_INLINE bool upb_sink_putunknown(upb_sink *s, const char *buf, size_t n) {
-  typedef upb_unknown_handlerfunc func;
-  func *handler;
-  const void *hd;
-  if (!s->handlers) return true;
-  handler = (func *)upb_handlers_gethandler(s->handlers, UPB_UNKNOWN_SELECTOR);
-
-  if (!handler) return n;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_UNKNOWN_SELECTOR);
-  return handler(s->closure, hd, buf, n);
-}
-
-UPB_INLINE bool upb_sink_startmsg(upb_sink *s) {
-  typedef upb_startmsg_handlerfunc func;
-  func *startmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  startmsg = (func*)upb_handlers_gethandler(s->handlers, UPB_STARTMSG_SELECTOR);
-
-  if (!startmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_STARTMSG_SELECTOR);
-  return startmsg(s->closure, hd);
-}
-
-UPB_INLINE bool upb_sink_endmsg(upb_sink *s, upb_status *status) {
-  typedef upb_endmsg_handlerfunc func;
-  func *endmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  endmsg = (func *)upb_handlers_gethandler(s->handlers, UPB_ENDMSG_SELECTOR);
-
-  if (!endmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, UPB_ENDMSG_SELECTOR);
-  return endmsg(s->closure, hd, status);
-}
+#ifdef __cplusplus
 
-UPB_INLINE bool upb_sink_startseq(upb_sink *s, upb_selector_t sel,
-                                  upb_sink *sub) {
-  typedef upb_startfield_handlerfunc func;
-  func *startseq;
-  const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startseq = (func*)upb_handlers_gethandler(s->handlers, sel);
+class upb::BytesSink {
+ public:
+  BytesSink() {}
 
-  if (!startseq) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startseq(s->closure, hd);
-  return sub->closure ? true : false;
-}
+  upb_bytessink* ptr() { return &sink_; }
 
-UPB_INLINE bool upb_sink_endseq(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endseq;
-  const void *hd;
-  if (!s->handlers) return true;
-  endseq = (func*)upb_handlers_gethandler(s->handlers, sel);
+  /* Constructs a new sink for the given frozen handlers and closure.
+   *
+   * TODO(haberman): once the Handlers know the expected closure type, verify
+   * that T matches it. */
+  template <class T> BytesSink(const upb_byteshandler* handler, T* closure) {
+    upb_bytessink_reset(&sink_, handler, closure);
+  }
 
-  if (!endseq) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endseq(s->closure, hd);
-}
+  /* Resets the value of the sink. */
+  template <class T> void Reset(const upb_byteshandler* handler, T* closure) {
+    upb_bytessink_reset(&sink_, handler, closure);
+  }
 
-UPB_INLINE bool upb_sink_startstr(upb_sink *s, upb_selector_t sel,
-                                  size_t size_hint, upb_sink *sub) {
-  typedef upb_startstr_handlerfunc func;
-  func *startstr;
-  const void *hd;
-  sub->closure = s->closure;
-  sub->handlers = s->handlers;
-  if (!s->handlers) return true;
-  startstr = (func*)upb_handlers_gethandler(s->handlers, sel);
+  bool Start(size_t size_hint, void **subc) {
+    return upb_bytessink_start(&sink_, size_hint, subc);
+  }
 
-  if (!startstr) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startstr(s->closure, hd, size_hint);
-  return sub->closure ? true : false;
-}
+  size_t PutBuffer(void *subc, const char *buf, size_t len,
+                   const upb_bufhandle *handle) {
+    return upb_bytessink_putbuf(&sink_, subc, buf, len, handle);
+  }
 
-UPB_INLINE bool upb_sink_endstr(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endstr;
-  const void *hd;
-  if (!s->handlers) return true;
-  endstr = (func*)upb_handlers_gethandler(s->handlers, sel);
+  bool End() {
+    return upb_bytessink_end(&sink_);
+  }
 
-  if (!endstr) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endstr(s->closure, hd);
-}
+ private:
+  upb_bytessink sink_;
+};
 
-UPB_INLINE bool upb_sink_startsubmsg(upb_sink *s, upb_selector_t sel,
-                                     upb_sink *sub) {
-  typedef upb_startfield_handlerfunc func;
-  func *startsubmsg;
-  const void *hd;
-  sub->closure = s->closure;
-  if (!s->handlers) {
-    sub->handlers = NULL;
-    return true;
-  }
-  sub->handlers = upb_handlers_getsubhandlers_sel(s->handlers, sel);
-  startsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel);
+#endif  /* __cplusplus */
 
-  if (!startsubmsg) return true;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  sub->closure = startsubmsg(s->closure, hd);
-  return sub->closure ? true : false;
-}
+/* upb_bufsrc *****************************************************************/
 
-UPB_INLINE bool upb_sink_endsubmsg(upb_sink *s, upb_selector_t sel) {
-  typedef upb_endfield_handlerfunc func;
-  func *endsubmsg;
-  const void *hd;
-  if (!s->handlers) return true;
-  endsubmsg = (func*)upb_handlers_gethandler(s->handlers, sel);
+UPB_BEGIN_EXTERN_C
 
-  if (!endsubmsg) return s->closure;
-  hd = upb_handlers_gethandlerdata(s->handlers, sel);
-  return endsubmsg(s->closure, hd);
-}
+bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink *sink);
 
 UPB_END_EXTERN_C
 
 #ifdef __cplusplus
 
 namespace upb {
-
-template <class T> Sink::Sink(const Handlers* handlers, T* closure) {
-  upb_sink_reset(this, handlers, closure);
-}
-template <class T>
-inline void Sink::Reset(const Handlers* handlers, T* closure) {
-  upb_sink_reset(this, handlers, closure);
-}
-inline bool Sink::StartMessage() {
-  return upb_sink_startmsg(this);
-}
-inline bool Sink::EndMessage(Status* status) {
-  return upb_sink_endmsg(this, status);
-}
-inline bool Sink::PutInt32(Handlers::Selector sel, int32_t val) {
-  return upb_sink_putint32(this, sel, val);
-}
-inline bool Sink::PutInt64(Handlers::Selector sel, int64_t val) {
-  return upb_sink_putint64(this, sel, val);
-}
-inline bool Sink::PutUInt32(Handlers::Selector sel, uint32_t val) {
-  return upb_sink_putuint32(this, sel, val);
-}
-inline bool Sink::PutUInt64(Handlers::Selector sel, uint64_t val) {
-  return upb_sink_putuint64(this, sel, val);
-}
-inline bool Sink::PutFloat(Handlers::Selector sel, float val) {
-  return upb_sink_putfloat(this, sel, val);
-}
-inline bool Sink::PutDouble(Handlers::Selector sel, double val) {
-  return upb_sink_putdouble(this, sel, val);
+template <class T> bool PutBuffer(const T& str, upb_bytessink* sink) {
+  return upb_bufsrc_putbuf(str.c_str(), str.size(), sink);
 }
-inline bool Sink::PutBool(Handlers::Selector sel, bool val) {
-  return upb_sink_putbool(this, sel, val);
-}
-inline bool Sink::StartString(Handlers::Selector sel, size_t size_hint,
-                              Sink *sub) {
-  return upb_sink_startstr(this, sel, size_hint, sub);
-}
-inline size_t Sink::PutStringBuffer(Handlers::Selector sel, const char *buf,
-                                    size_t len, const BufferHandle* handle) {
-  return upb_sink_putstring(this, sel, buf, len, handle);
-}
-inline bool Sink::EndString(Handlers::Selector sel) {
-  return upb_sink_endstr(this, sel);
-}
-inline bool Sink::StartSubMessage(Handlers::Selector sel, Sink* sub) {
-  return upb_sink_startsubmsg(this, sel, sub);
-}
-inline bool Sink::EndSubMessage(Handlers::Selector sel) {
-  return upb_sink_endsubmsg(this, sel);
-}
-inline bool Sink::StartSequence(Handlers::Selector sel, Sink* sub) {
-  return upb_sink_startseq(this, sel, sub);
-}
-inline bool Sink::EndSequence(Handlers::Selector sel) {
-  return upb_sink_endseq(this, sel);
 }
 
-template <class T>
-BytesSink::BytesSink(const BytesHandler* handler, T* closure) {
-  Reset(handler, closure);
-}
+#endif  /* __cplusplus */
 
-template <class T>
-void BytesSink::Reset(const BytesHandler *handler, T *closure) {
-  upb_bytessink_reset(this, handler, closure);
-}
-inline bool BytesSink::Start(size_t size_hint, void **subc) {
-  return upb_bytessink_start(this, size_hint, subc);
-}
-inline size_t BytesSink::PutBuffer(void *subc, const char *buf, size_t len,
-                                   const BufferHandle *handle) {
-  return upb_bytessink_putbuf(this, subc, buf, len, handle);
-}
-inline bool BytesSink::End() {
-  return upb_bytessink_end(this);
-}
+/* upb_bufsink ****************************************************************/
 
-inline bool BufferSource::PutBuffer(const char *buf, size_t len,
-                                    BytesSink *sink) {
-  return upb_bufsrc_putbuf(buf, len, sink);
-}
+/* A class for accumulating output string data in a flat buffer. */
+struct upb_bufsink;
+typedef struct upb_bufsink upb_bufsink;
 
-}  /* namespace upb */
-#endif
+UPB_BEGIN_EXTERN_C
+
+upb_bufsink *upb_bufsink_init(upb_env *env);
+void upb_bufsink_free(upb_bufsink *sink);
+upb_bytessink *upb_bufsink_sink(upb_bufsink *sink);
+const char *upb_bufsink_getdata(const upb_bufsink *sink, size_t *len);
+
+UPB_END_EXTERN_C
 
 #endif