[boost] Re: Re: Serialization library - submission #5 and request

From: Eric Woodruff (Eric.Woodruff_at_[hidden])
Date: 2002-09-12 15:19:51

Here are my two cents on the serialization library:

I haven't looked through it that much, just this message thread actually,
but I plan on looking through what it supports further. (I'm still looking
for the link to where I can download it and check it out)

1) I disagree with the use of the << operator. iostreams already have
claimed this operator and they mean a very specific usage: they imply
formating, which includes removal of whitespace etc. This is a very
different function of writing something out in binary.
2) void pointers are bad practice, and in one of the usages I saw below,
completely unnecessary. C++ provides templates, so use them. The idea of
translating a type to a byte array should always require a reinterpret cast:

template <typename Object>
void write_binary (Object const* const object) {
   /// do stuff reinterpret_cast and const_cast if necessary get a char
const* const
}

You should never just ignore type information, no matter what the purpose.

----- Original Message -----
From: Robert Ramey
Newsgroups: gmane.comp.lib.boost.devel
Sent: Thursday, 2002:September:12 11:12
Subject: FW: Re: Serialization library - submission #5 and request

Sorry, I meant to send this to the list.

yes, it will still call operator<< for each double in an std:vector

if this is not what you want, note that basic_oarchive also contains
read_binary and write_binary if you want to the to "conversion"
within your own code rather than withing the serialization system.

Also there is nothing to prevent adding your own operator<<
to any derivation of basic_oarchive/basic_iarchive.

Its not clear to me what it is that you want to do that is
incompatible with the serialziation library as it stands.
Perhaps ;you might want to submit a small example

Robert Ramey

-----Original Message-----
From: Matthias Troyer [SMTP:troyer_at_[hidden]]
Sent: Wednesday, September 11, 2002 1:44 PM
To: Robert Ramey
Subject: Re: [boost] Re: Serialization library - submission #5 and request

Robert,

Am I mistaken or will this still call
basic_oarchive::operator<<(double)
for each value in an array or std::vector?

Matthias

On Wednesday, Sep 11, 2002, at 10:07 US/Pacific, Robert Ramey wrote:

> Date: Wed, 11 Sep 2002 07:20:27 -0700
> From: Matthias Troyer <troyer_at_[hidden]>
> To: boost_at_[hidden]
> Subject: Re: [boost] Re: Serialization library - submission #5 and
> request
> Message-ID: <9ECECC44-C591-11D6-AD6F-003065B8A044_at_[hidden]>
> In-Reply-To: <01C25908.C39B9900_at_[hidden]>
>> Content-Type: text/plain; charset=US-ASCII; format=flowed
>> MIME-Version: 1.0 (Apple Message framework v543)
>> Content-Transfer-Encoding: 7bit
>> Precedence: bulk
>> Message: 13
>
>> Hi Robert,
>
>> Maybe I'm just too stupid to see it, but from looking at the
>> documentation I can't see how, e.g. I would write an oarchive
>> that calls
>
>> xdr_double(...)
>
>> for a single double value
>
> See example below for a skeletal xdr archive for the above case.  My
> view is that
> this would handle all cases where xdr is used for storage.  data is
> converted between
> xdr and native format on output and input.  This addresses what I
> would see as the
> most common case whereby native format is used withing the program
> while
> xdr is used as a common format for communication of doubles between
> platforms.
> So I would not expect to see an array of xdr_doubles in the program
> itself.
>
> However suppose that one has an array of a very large number of small
> objects and
> its desired to save serialization overhead.  This is a the general
> statement of your
> example.  It is addressed in the reference manual under the heading
> "Very Large Numbers of Small Objects"
>> xdr_vector(...,&xdr_double)
>
>> for an array of doubles. As I see it, and have implemented it in my
>> serialization library that I would love to replace by a boost one,
>> we need additional virtual functions for (de)serializing arrays of
>> the basic data types.
>
> I'm not sure of what kind of array we're talking about - i.e.
> std::vector, boost::array
> or native C++ arrays.  In any case, std::vector<T> is already in the
> library.  It is
> a specific example of adding serialization to templates in a
> non-intrusive way.
> This is described in the documentation under "Serialization of
> Templates" the package
> also includes a couple of examples showing how to add serialization to
> any template.
>
> Of course, maybe the easiest in this specific case is to implement
> your preferred
> method of serialization of your xdr_vector by defining save/load
> functions as your
> would anyother class.
>
>> Please tell me if I am wrong and how to manage this using your
>> library.
>
>> Best regards,
>
>> Matthias
>
>
>
>
>
>
> namespace boost {
>
> //////////////////////////////////////////////////////////////////////
> // class xdr_oarchive - write serialization_detaild objects to a
> binary output stream
> class xdr_oarchive : public basic_oarchive
> {
> public:
> virtual void init(){
> os.seekp(0);
> basic_oarchive::init();
> }
> xdr_oarchive(std::ostream &_os) :
> os(_os)
> {
> #ifndef BOOST_NO_STD_LOCALE
> os.imbue(std::locale::classic());
> #endif
> init();
> //////////////////////
> // xdr specific code here
> }
> ~xdr_oarchive(){}
> private:
> // native binary streams are handled as bytes
> std::ostream &os;
>
> virtual void write_string(const std::string &s);
> #ifndef BOOST_NO_STD_WSTRING
> virtual void write_string(const std::wstring &ws);
> #endif
> virtual void write_binary(const void *address, size_t count)
> {
> //////////////////////
> // xdr specific code here
> }
> #ifndef BOOST_NO_INTRINSIC_WCHAR_T
> virtual basic_oarchive & operator<<(wchar_t _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #endif
> virtual basic_oarchive & operator<<(signed char _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(unsigned char _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(char _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(short _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(unsigned short _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(int _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(unsigned int _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(long _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(unsigned long _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(float _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(double _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(long double _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #ifndef BOOST_NO_INT64_T
> virtual basic_oarchive & operator<<(int64_t _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_oarchive & operator<<(uint64_t _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #endif
> };
>
> //////////////////////////////////////////////////////////////////////
> // class xdr_iarchive - read serialization_detaild objects from a
> input binary stream
> class xdr_iarchive : public basic_iarchive
> {
> public:
> virtual void init(){
> is.seekg(0);
> basic_iarchive::init();
> }
> xdr_iarchive(std::istream &_is) :
> is(_is)
> {
> #ifndef BOOST_NO_STD_LOCALE
> is.imbue(std::locale::classic());
> #endif
> init();
> //////////////////////
> // xdr specific code here
> }
> ~xdr_iarchive(){}
> private:
> // native streams are always handled as bytes
> std::istream &is;
> virtual void read_string(std::string &s);
> #ifndef BOOST_NO_STD_WSTRING
> virtual void read_string(std::wstring &ws);
> #endif
> virtual void read_binary(void *address, size_t count)
> {
> //////////////////////
> // xdr specific code here
> }
> #ifndef BOOST_NO_INTRINSIC_WCHAR_T
> virtual basic_iarchive& operator>>(wchar_t& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #endif
> virtual basic_iarchive & operator>>(signed char &_Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive & operator>>(unsigned char &_Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive & operator>>(char &_Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(short& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(unsigned short& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(int& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(unsigned int& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(long& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(unsigned long& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(float& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(double& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive& operator>>(long double& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #ifndef BOOST_NO_INT64_T
> virtual basic_iarchive & operator>>(int64_t& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> virtual basic_iarchive & operator>>(uint64_t& _Val)
> {
> //////////////////////
> // xdr specific code here
> }
> #endif
> };
>
> }// namespace boost

_______________________________________________
Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost