Re: [boost] A little utility class I'd like to contribute to boos t

From: Vesa Karvonen (vesa.karvonen_at_[hidden])
Date: 2001-06-15 09:45:48

How about using an applicative template to supply the initialization
parameter:

    template
    < class value_type
    , class initializer
    >
    struct initialized
    { typedef value_type
        value_type;

      // constructor invokes the initializer
      initialized() : m_value(initializer::apply()) {}

      // ...desired convenience operators...
    private:
      value_type
        m_value;
    };

    // An initializer
    template
    < int value
    >
    struct initializer_int
    { static int apply() {return value;}
    };

The user could then write:

    initialized<int, initializer_int<5> >

However, this is not the end of the story. The applicative template
approach would make it possible to perform an arbitrary computation in
order to calculate the default. Even a reasonable compiler can completely
eliminate any run-time overhead compared to the direct template parameter
approach.

In my opinnion, the "convenience operators" should be configurable. The
semantics and availability of
- get/set,
- conversions,
- address of operator and
- other built-in operators
should be configurable.

This is starting to sound like a Property concept.

----- Original Message -----
From: "Aleksey Gurtovoy" <alexy_at_[hidden]>
To: <boost_at_[hidden]>
Sent: Thursday, June 14, 2001 5:16
Subject: RE: [boost] A little utility class I'd like to contribute to boos
t

> David Abrahams wrote:
> > I think it's nice, but would prefer to call the template
> > "initialized".
>
> Me too (in fact, that's exactly how something like this is called in our
> code :).
>
> > Also, I note that it /only/ works with built-in
> > integer types. What about pointers and floating types? I think
> > these deserve an "initialized" type as well.
>
> Yes, it should be something like this:
>
> template< typename T
>         , typename non_type_parameter<T>::type Default
>             = typename non_type_parameter<T>::type()
>         >
> struct initialized : boost::mpl::select_type<
>           boost::is_pointer<T>::value
>         , initialized_ptr<T>
>         , initialized_arithmetic<T>
>         >::type
>     {
>     // ...
>     };
>
> where 'non_type_parameter<double>::type' (or 'float') gives you
something
> like 'long', so at least you can have an integer-based initialization:
>
> initialized<double> d; // ok
> initialized<double, 15> d1; // ok
> // initialized<double, 15.5> d1; // error
>
> Also, overloading of unary operator& to make it return an address of
> internal object might make sense too.
>
>
> Aleksey
>
> To unsubscribe, send email to:
<mailto:boost-unsubscribe_at_[hidden]>
>
>
> Your use of Yahoo! Groups is subject to
http://docs.yahoo.com/info/terms/
>
>
>