jsoncons 0.1.0

data/lib/jsoncons/jsoncons/include/jsoncons_ext/csv/csv_reader.hpp

@@ -0,0 +1,348 @@
+// Copyright 2013 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_CSV_CSV_READER_HPP
+#define JSONCONS_CSV_CSV_READER_HPP
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <memory> // std::allocator
+#include <utility> // std::move
+#include <istream> // std::basic_istream
+#include <jsoncons/source.hpp>
+#include <jsoncons/json_exception.hpp>
+#include <jsoncons/json_visitor.hpp>
+#include <jsoncons_ext/csv/csv_error.hpp>
+#include <jsoncons_ext/csv/csv_parser.hpp>
+#include <jsoncons/json.hpp>
+#include <jsoncons/json_reader.hpp>
+#include <jsoncons/json_decoder.hpp>
+#include <jsoncons/source_adaptor.hpp>
+#include <jsoncons_ext/csv/csv_options.hpp>
+
+namespace jsoncons { namespace csv {
+
+    template<class CharT,class Source=jsoncons::stream_source<CharT>,class Allocator=std::allocator<char>>
+    class basic_csv_reader 
+    {
+        struct stack_item
+        {
+            stack_item() noexcept
+               : array_begun_(false)
+            {
+            }
+
+            bool array_begun_;
+        };
+        using char_type = CharT;
+        using temp_allocator_type = Allocator;
+        typedef typename std::allocator_traits<temp_allocator_type>:: template rebind_alloc<CharT> char_allocator_type;
+
+        basic_csv_reader(const basic_csv_reader&) = delete; 
+        basic_csv_reader& operator = (const basic_csv_reader&) = delete; 
+
+        basic_default_json_visitor<CharT> default_visitor_;
+        text_source_adaptor<Source> source_;
+        basic_json_visitor<CharT>& visitor_;
+        basic_csv_parser<CharT,Allocator> parser_;
+
+    public:
+        // Structural characters
+        static constexpr size_t default_max_buffer_size = 16384;
+        //!  Parse an input stream of CSV text into a json object
+        /*!
+          \param is The input stream to read from
+        */
+
+        template <class Sourceable>
+        basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor, 
+                         const Allocator& alloc = Allocator())
+
+           : basic_csv_reader(std::forward<Sourceable>(source), 
+                              visitor, 
+                              basic_csv_decode_options<CharT>(), 
+                              default_csv_parsing(), 
+                              alloc)
+        {
+        }
+
+        template <class Sourceable>
+        basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         const basic_csv_decode_options<CharT>& options, 
+                         const Allocator& alloc = Allocator())
+
+            : basic_csv_reader(std::forward<Sourceable>(source), 
+                               visitor, 
+                               options, 
+                               default_csv_parsing(),
+                               alloc)
+        {
+        }
+
+        template <class Sourceable>
+        basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         std::function<bool(csv_errc,const ser_context&)> err_handler, 
+                         const Allocator& alloc = Allocator())
+            : basic_csv_reader(std::forward<Sourceable>(source), 
+                               visitor, 
+                               basic_csv_decode_options<CharT>(), 
+                               err_handler,
+                               alloc)
+        {
+        }
+
+        template <class Sourceable>
+        basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         const basic_csv_decode_options<CharT>& options,
+                         std::function<bool(csv_errc,const ser_context&)> err_handler, 
+                         const Allocator& alloc = Allocator())
+           : source_(std::forward<Sourceable>(source)),
+             visitor_(visitor),
+             parser_(options, err_handler, alloc)
+             
+        {
+        }
+
+        ~basic_csv_reader() noexcept = default;
+
+        void read()
+        {
+            std::error_code ec;
+            read(ec);
+            if (ec)
+            {
+                JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column()));
+            }
+        }
+
+        void read(std::error_code& ec)
+        {
+            read_internal(ec);
+        }
+
+        std::size_t line() const
+        {
+            return parser_.line();
+        }
+
+        std::size_t column() const
+        {
+            return parser_.column();
+        }
+
+        bool eof() const
+        {
+            return parser_.source_exhausted() && source_.eof();
+        }
+
+    private:
+
+        void read_internal(std::error_code& ec)
+        {
+            if (source_.is_error())
+            {
+                ec = csv_errc::source_error;
+                return;
+            }   
+            while (!parser_.stopped())
+            {
+                if (parser_.source_exhausted())
+                {
+                    auto s = source_.read_buffer(ec);
+                    if (ec) return;
+                    if (s.size() > 0)
+                    {
+                        parser_.update(s.data(),s.size());
+                    }
+                }
+                parser_.parse_some(visitor_, ec);
+                if (ec) return;
+            }
+        }
+    };
+
+    template<class CharT,class Source=jsoncons::stream_source<CharT>,class Allocator=std::allocator<char>>
+    class legacy_basic_csv_reader 
+    {
+        struct stack_item
+        {
+            stack_item() noexcept
+               : array_begun_(false)
+            {
+            }
+
+            bool array_begun_;
+        };
+        using char_type = CharT;
+        using temp_allocator_type = Allocator;
+        typedef typename std::allocator_traits<temp_allocator_type>:: template rebind_alloc<CharT> char_allocator_type;
+
+        legacy_basic_csv_reader(const legacy_basic_csv_reader&) = delete; 
+        legacy_basic_csv_reader& operator = (const legacy_basic_csv_reader&) = delete; 
+
+        basic_default_json_visitor<CharT> default_visitor_;
+        text_source_adaptor<Source> source_;
+        basic_json_visitor<CharT>& visitor_;
+        basic_csv_parser<CharT,Allocator> parser_;
+
+    public:
+        // Structural characters
+        static constexpr size_t default_max_buffer_size = 16384;
+        //!  Parse an input stream of CSV text into a json object
+        /*!
+          \param is The input stream to read from
+        */
+
+        template <class Sourceable>
+        legacy_basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor, 
+                         const Allocator& alloc = Allocator())
+
+           : legacy_basic_csv_reader(std::forward<Sourceable>(source), 
+                              visitor, 
+                              basic_csv_decode_options<CharT>(), 
+                              default_csv_parsing(), 
+                              alloc)
+        {
+        }
+
+        template <class Sourceable>
+        legacy_basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         const basic_csv_decode_options<CharT>& options, 
+                         const Allocator& alloc = Allocator())
+
+            : legacy_basic_csv_reader(std::forward<Sourceable>(source), 
+                               visitor, 
+                               options, 
+                               default_csv_parsing(),
+                               alloc)
+        {
+        }
+
+        template <class Sourceable>
+        legacy_basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         std::function<bool(csv_errc,const ser_context&)> err_handler, 
+                         const Allocator& alloc = Allocator())
+            : legacy_basic_csv_reader(std::forward<Sourceable>(source), 
+                               visitor, 
+                               basic_csv_decode_options<CharT>(), 
+                               err_handler,
+                               alloc)
+        {
+        }
+
+        template <class Sourceable>
+        legacy_basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         const basic_csv_decode_options<CharT>& options,
+                         std::function<bool(csv_errc,const ser_context&)> err_handler, 
+                         const Allocator& alloc = Allocator(),
+                         typename std::enable_if<!std::is_constructible<jsoncons::basic_string_view<CharT>,Sourceable>::value>::type* = 0)
+           : source_(std::forward<Sourceable>(source)),
+             visitor_(visitor),
+             parser_(options, err_handler, alloc)
+        {
+        }
+
+        template <class Sourceable>
+        legacy_basic_csv_reader(Sourceable&& source,
+                         basic_json_visitor<CharT>& visitor,
+                         const basic_csv_decode_options<CharT>& options,
+                         std::function<bool(csv_errc,const ser_context&)> err_handler, 
+                         const Allocator& alloc = Allocator(),
+                         typename std::enable_if<std::is_constructible<jsoncons::basic_string_view<CharT>,Sourceable>::value>::type* = 0)
+           : source_(),
+             visitor_(visitor),
+             parser_(options, err_handler, alloc)             
+        {
+            jsoncons::basic_string_view<CharT> sv(std::forward<Sourceable>(source));
+            auto r = unicode_traits::detect_encoding_from_bom(sv.data(), sv.size());
+            if (!(r.encoding == unicode_traits::encoding_kind::utf8 || r.encoding == unicode_traits::encoding_kind::undetected))
+            {
+                JSONCONS_THROW(ser_error(json_errc::illegal_unicode_character,parser_.line(),parser_.column()));
+            }
+            std::size_t offset = (r.ptr - sv.data());
+            parser_.update(sv.data()+offset,sv.size()-offset);
+        }
+
+        ~legacy_basic_csv_reader() noexcept = default;
+
+        void read()
+        {
+            std::error_code ec;
+            read(ec);
+            if (ec)
+            {
+                JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column()));
+            }
+        }
+
+        void read(std::error_code& ec)
+        {
+            read_internal(ec);
+        }
+
+        std::size_t line() const
+        {
+            return parser_.line();
+        }
+
+        std::size_t column() const
+        {
+            return parser_.column();
+        }
+
+        bool eof() const
+        {
+            return parser_.source_exhausted() && source_.eof();
+        }
+
+    private:
+
+        void read_internal(std::error_code& ec)
+        {
+            if (source_.is_error())
+            {
+                ec = csv_errc::source_error;
+                return;
+            }   
+            while (!parser_.stopped())
+            {
+                if (parser_.source_exhausted())
+                {
+                    auto s = source_.read_buffer(ec);
+                    if (ec) return;
+                    if (s.size() > 0)
+                    {
+                        parser_.update(s.data(),s.size());
+                    }
+                }
+                parser_.parse_some(visitor_, ec);
+                if (ec) return;
+            }
+        }
+    };
+
+#if !defined(JSONCONS_NO_DEPRECATED)
+    using csv_reader = legacy_basic_csv_reader<char>;
+    using wcsv_reader = legacy_basic_csv_reader<wchar_t>;
+#endif
+
+    using csv_string_reader = basic_csv_reader<char,string_source<char>>;
+    using wcsv_string_reader = basic_csv_reader<wchar_t,string_source<wchar_t>>;
+    using csv_stream_reader = basic_csv_reader<char,stream_source<char>>;
+    using wcsv_stream_reader = basic_csv_reader<wchar_t,stream_source<wchar_t>>;
+
+}}
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons_ext/csv/csv_serializer.hpp

@@ -0,0 +1,12 @@
+// Copyright 2013 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_CSV_CSV_SERIALIZER_HPP
+#define JSONCONS_CSV_CSV_SERIALIZER_HPP
+
+#include <jsoncons_ext/csv/csv_encoder.hpp>
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons_ext/csv/decode_csv.hpp

@@ -0,0 +1,208 @@
+/// Copyright 2013 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_CSV_DECODE_CSV_HPP
+#define JSONCONS_CSV_DECODE_CSV_HPP
+
+#include <jsoncons_ext/csv/csv_options.hpp>
+#include <jsoncons_ext/csv/csv_reader.hpp>
+#include <jsoncons_ext/csv/csv_encoder.hpp>
+#include <jsoncons_ext/csv/csv_cursor.hpp>
+
+namespace jsoncons { 
+namespace csv {
+
+    template <class T,class Source>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_sequence_of<Source,typename T::char_type>::value,T>::type 
+    decode_csv(const Source& s, const basic_csv_decode_options<typename Source::value_type>& options = basic_csv_decode_options<typename Source::value_type>())
+    {
+        using char_type = typename Source::value_type;
+
+        json_decoder<T> decoder;
+
+        basic_csv_reader<char_type,jsoncons::string_source<char_type>> reader(s,decoder,options);
+        reader.read();
+        if (!decoder.is_valid())
+        {
+            JSONCONS_THROW(ser_error(conv_errc::conversion_failed, reader.line(), reader.column()));
+        }
+        return decoder.get_result();
+    }
+
+    template <class T,class Source>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_char_sequence<Source>::value,T>::type 
+    decode_csv(const Source& s, const basic_csv_decode_options<typename Source::value_type>& options = basic_csv_decode_options<typename Source::value_type>())
+    {
+        using char_type = typename Source::value_type;
+
+        basic_csv_cursor<char_type> cursor(s, options);
+        jsoncons::json_decoder<basic_json<char_type>> decoder;
+
+        std::error_code ec;
+        T val = decode_traits<T,char_type>::decode(cursor, decoder, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));
+        }
+        return val;
+    }
+
+    template <class T,class CharT>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value,T>::type 
+    decode_csv(std::basic_istream<CharT>& is, const basic_csv_decode_options<CharT>& options = basic_csv_decode_options<CharT>())
+    {
+        using char_type = CharT;
+
+        json_decoder<T> decoder;
+
+        basic_csv_reader<char_type,jsoncons::stream_source<char_type>> reader(is,decoder,options);
+        reader.read();
+        if (!decoder.is_valid())
+        {
+            JSONCONS_THROW(ser_error(conv_errc::conversion_failed, reader.line(), reader.column()));
+        }
+        return decoder.get_result();
+    }
+
+    template <class T,class CharT>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value,T>::type 
+    decode_csv(std::basic_istream<CharT>& is, const basic_csv_decode_options<CharT>& options = basic_csv_decode_options<CharT>())
+    {
+        basic_csv_cursor<CharT> cursor(is, options);
+        jsoncons::json_decoder<basic_json<CharT>> decoder;
+
+        std::error_code ec;
+        T val = decode_traits<T,CharT>::decode(cursor, decoder, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));
+        }
+        return val;
+    }
+
+    template <class T, class InputIt>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value,T>::type
+    decode_csv(InputIt first, InputIt last,
+                const basic_csv_decode_options<typename std::iterator_traits<InputIt>::value_type>& options = 
+                    basic_csv_decode_options<typename std::iterator_traits<InputIt>::value_type>())
+    {
+        using char_type = typename std::iterator_traits<InputIt>::value_type;
+
+        jsoncons::json_decoder<T> decoder;
+        basic_csv_reader<char_type, iterator_source<InputIt>> reader(iterator_source<InputIt>(first,last), decoder, options);
+        reader.read();
+        if (!decoder.is_valid())
+        {
+            JSONCONS_THROW(ser_error(conv_errc::conversion_failed, reader.line(), reader.column()));
+        }
+        return decoder.get_result();
+    }
+
+    template <class T, class InputIt>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value,T>::type
+    decode_csv(InputIt first, InputIt last,
+               const basic_csv_decode_options<typename std::iterator_traits<InputIt>::value_type>& options = 
+                    basic_csv_decode_options<typename std::iterator_traits<InputIt>::value_type>())
+    {
+        using char_type = typename std::iterator_traits<InputIt>::value_type;
+
+        basic_csv_cursor<char_type,iterator_source<InputIt>> cursor(iterator_source<InputIt>(first, last), options);
+        jsoncons::json_decoder<basic_json<char_type>> decoder;
+        std::error_code ec;
+        T val = decode_traits<T,char_type>::decode(cursor, decoder, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));
+        }
+        return val;
+    }
+
+    // With leading allocator parameter
+
+    template <class T,class Source,class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_sequence_of<Source,typename T::char_type>::value,T>::type 
+    decode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const Source& s, 
+               const basic_csv_decode_options<typename Source::value_type>& options = basic_csv_decode_options<typename Source::value_type>())
+    {
+        using char_type = typename Source::value_type;
+
+        json_decoder<T,TempAllocator> decoder(temp_alloc);
+
+        basic_csv_reader<char_type,jsoncons::string_source<char_type>,TempAllocator> reader(s,decoder,options,temp_alloc);
+        reader.read();
+        if (!decoder.is_valid())
+        {
+            JSONCONS_THROW(ser_error(conv_errc::conversion_failed, reader.line(), reader.column()));
+        }
+        return decoder.get_result();
+    }
+
+    template <class T,class Source,class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_char_sequence<Source>::value,T>::type 
+    decode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const Source& s, 
+               const basic_csv_decode_options<typename Source::value_type>& options = basic_csv_decode_options<typename Source::value_type>())
+    {
+        using char_type = typename Source::value_type;
+
+        basic_csv_cursor<char_type,stream_source<char_type>,TempAllocator> cursor(s, options, temp_alloc);
+        json_decoder<basic_json<char_type,sorted_policy,TempAllocator>,TempAllocator> decoder(temp_alloc, temp_alloc);
+
+        std::error_code ec;
+        T val = decode_traits<T,char_type>::decode(cursor, decoder, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));
+        }
+        return val;
+    }
+
+    template <class T,class CharT,class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value,T>::type 
+    decode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               std::basic_istream<CharT>& is, 
+               const basic_csv_decode_options<CharT>& options = basic_csv_decode_options<CharT>())
+    {
+        using char_type = CharT;
+
+        json_decoder<T,TempAllocator> decoder(temp_alloc);
+
+        basic_csv_reader<char_type,jsoncons::string_source<char_type>,TempAllocator> reader(is,decoder,options,temp_alloc);
+        reader.read();
+        if (!decoder.is_valid())
+        {
+            JSONCONS_THROW(ser_error(conv_errc::conversion_failed, reader.line(), reader.column()));
+        }
+        return decoder.get_result();
+    }
+
+    template <class T,class CharT,class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value,T>::type 
+    decode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               std::basic_istream<CharT>& is, 
+               const basic_csv_decode_options<CharT>& options = basic_csv_decode_options<CharT>())
+    {
+        basic_csv_cursor<CharT,stream_source<CharT>,TempAllocator> cursor(is, options, temp_alloc);
+        json_decoder<basic_json<CharT,sorted_policy,TempAllocator>,TempAllocator> decoder(temp_alloc, temp_alloc);
+
+        std::error_code ec;
+        T val = decode_traits<T,CharT>::decode(cursor, decoder, ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec, cursor.context().line(), cursor.context().column()));
+        }
+        return val;
+    }
+
+} // namespace csv 
+} // namespace jsoncons
+
+#endif

data/lib/jsoncons/jsoncons/include/jsoncons_ext/csv/encode_csv.hpp

@@ -0,0 +1,122 @@
+/// Copyright 2013 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_CSV_ENCODE_CSV_HPP
+#define JSONCONS_CSV_ENCODE_CSV_HPP
+
+#include <jsoncons_ext/csv/csv_options.hpp>
+#include <jsoncons_ext/csv/csv_reader.hpp>
+#include <jsoncons_ext/csv/csv_encoder.hpp>
+
+namespace jsoncons { 
+namespace csv {
+
+    template <class T,class Container>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type 
+    encode_csv(const T& j, Container& s, const basic_csv_encode_options<typename Container::value_type>& options = basic_csv_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+        basic_csv_encoder<char_type,jsoncons::string_sink<std::basic_string<char_type>>> encoder(s,options);
+        j.dump(encoder);
+    }
+
+    template <class T,class Container>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type 
+    encode_csv(const T& val, Container& s, const basic_csv_encode_options<typename Container::value_type>& options = basic_csv_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+        basic_csv_encoder<char_type,jsoncons::string_sink<std::basic_string<char_type>>> encoder(s,options);
+        std::error_code ec;
+        encode_traits<T,char_type>::encode(val, encoder, json(), ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+    }
+
+    template <class T, class CharT>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value,void>::type 
+    encode_csv(const T& j, std::basic_ostream<CharT>& os, const basic_csv_encode_options<CharT>& options = basic_csv_encode_options<CharT>())
+    {
+        using char_type = CharT;
+        basic_csv_encoder<char_type,jsoncons::stream_sink<char_type>> encoder(os,options);
+        j.dump(encoder);
+    }
+
+    template <class T, class CharT>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value,void>::type 
+    encode_csv(const T& val, std::basic_ostream<CharT>& os, const basic_csv_encode_options<CharT>& options = basic_csv_encode_options<CharT>())
+    {
+        using char_type = CharT;
+        basic_csv_encoder<char_type,jsoncons::stream_sink<char_type>> encoder(os,options);
+        std::error_code ec;
+        encode_traits<T,CharT>::encode(val, encoder, json(), ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+    }
+
+    // with temp_allocator_arg_t
+
+    template <class T, class Container, class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type 
+    encode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const T& j, Container& s, const basic_csv_encode_options<typename Container::value_type>& options = basic_csv_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+        basic_csv_encoder<char_type,jsoncons::string_sink<std::basic_string<char_type>>,TempAllocator> encoder(s, options, temp_alloc);
+        j.dump(encoder);
+    }
+
+    template <class T, class Container, class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value &&
+                            traits_extension::is_back_insertable_char_container<Container>::value>::type 
+    encode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const T& val, Container& s, const basic_csv_encode_options<typename Container::value_type>& options = basic_csv_encode_options<typename Container::value_type>())
+    {
+        using char_type = typename Container::value_type;
+        basic_csv_encoder<char_type,jsoncons::string_sink<std::basic_string<char_type>>,TempAllocator> encoder(s, options, temp_alloc);
+        std::error_code ec;
+        encode_traits<T,char_type>::encode(val, encoder, json(), ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    typename std::enable_if<traits_extension::is_basic_json<T>::value,void>::type 
+    encode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const T& j, std::basic_ostream<CharT>& os, const basic_csv_encode_options<CharT>& options = basic_csv_encode_options<CharT>())
+    {
+        using char_type = CharT;
+        basic_csv_encoder<char_type,jsoncons::stream_sink<char_type>,TempAllocator> encoder(os, options, temp_alloc);
+        j.dump(encoder);
+    }
+
+    template <class T, class CharT, class TempAllocator>
+    typename std::enable_if<!traits_extension::is_basic_json<T>::value,void>::type 
+    encode_csv(temp_allocator_arg_t, const TempAllocator& temp_alloc,
+               const T& val, std::basic_ostream<CharT>& os, const basic_csv_encode_options<CharT>& options = basic_csv_encode_options<CharT>())
+    {
+        using char_type = CharT;
+        basic_csv_encoder<char_type,jsoncons::stream_sink<char_type>,TempAllocator> encoder(os, options, temp_alloc);
+        std::error_code ec;
+        encode_traits<T,CharT>::encode(val, encoder, json(), ec);
+        if (ec)
+        {
+            JSONCONS_THROW(ser_error(ec));
+        }
+    }
+
+} // namespace csv 
+} // namespace jsoncons
+
+#endif