Re: [boost] Re: Re: string algorithms review

From: Bronek Kozicki (Brok_at_[hidden])
Date: 2003-10-20 07:05:31

Pavol Droba <droba_at_[hidden]> wrote:
>> How about trim ( in_place( orig ) )?

> As I have already mentioned, inplace variant differ in the
> implementation from the copy variants. Such a convetion would be hard
> to achieve.

Not so, if in_place returns proxy object.

template <typename T> class inplace_proxy;
template <typename T> inplace_proxy<T&> in_place(T&);

template<> class inplace_proxy<std::string&>
{
public:
  inplace_proxy<std::string&> (std::string& str) : ref_(str) {}
  inplace_proxy<std::string&> (const inplace_proxy<std::string&> & src)
: ref_(src.ref_) {}
  std::string& ref() {return ref_;}
//...
private:
  std::string& ref_;
  inplace_proxy<std::string&>& operator=(const
inplace_proxy<std::string&>&);
};

template<>
inplace_proxy<std::string&> in_place<std::string>(std::string& str)
{
  return inplace_proxy<std::string&>(str);
}

(template "inplace_proxy<std::string&>" is just an idea, there might be
something else instead)

> IMHO copy and inplace variants should be very explicitly
> distinguished.

We might have two overloaded versions of mutating algorithms:

inplace_proxy<std::string&> trim(inplace_proxy<std::string&>);

std::string trim(const std::string &);

which will make both variants very easy to distinguish. Additional bonus
is that you can nest calls to both variants in very natural manner:

 ucase(trim(in_place(str1))); // in place
 std::string str3 = ucase(trim(str2)); // using temporary copies

There is a problem, though: proxy class (or template, as proposed above)
will add small overhead, which is problem for "in-place algorithms" as
these might be expected to be significaly faster than "copying
algorithms", thus carrying as small overhead as possible.

B.