Boost logo

Boost :

From: Peder Holt (peder.holt_at_[hidden])
Date: 2006-03-02 02:14:00

On 3/1/06, Arkadiy Vertleyb <vertleyb_at_[hidden]> wrote:
> "Peder Holt" <peder.holt_at_[hidden]> wrote
> > 2. In emulation mode, there is no longer any limit to the complexity
> > of the types passed to BOOST_TYPEOF_NESTED_TYPEDEF.
> > BOOST_TYPEOF_LIMIT_SIZE is no longer a limiting factor.
> Interesting.
> I think I can see how you avoid the limit related to the number of template
> parameters (which is a major improvement by itself).
> However, I don't think you can get over the preprocessor limit, can you?
> Also, BOOST_TYPEOF_LIMIT_SIZE is there to avoid unnecessary evaluations of
> the expression, and again, I don't see how you are planning to not depend on
> it... Assumming, of course, that I figured out things correctly, and you
> are planning to do something like this:
> struct name
> {
> enum {
> value1 = sizeof(encode(expr).item1),
> value2 = sizeof(encode(expr).item2),
> ...
> valueN = sizeof(encode(expr).itemN),
> };
> typedef<decode<some_iterator<name> >::type type;
> };
> encode still needs to be called BOOST_TYPEOF_LIMIT_SIZE times, doesn't it?
> Am I missing something?

What I do is basically the following:
struct name {
   template<int Iteration>
   struct encode_part {
      static int Offset=Iteration*BOOST_TYPEOF_NESTED_SIZE (currently 50)
      typedef offset_vector<nested_vector0<>,boost::mpl::size_t<Offset>
> start_vector;
      template<typename T>
      static sizer<encode_type<start,vector,T> > encode(const T& arg);
      static int value0=sizeof(encode(expr).item0);
      typedef boost::mpl::size_t<value0> item0;
   template<typename Pos>
   struct decode_iter {
      static const int pos=Pos::value;
      static const int where=pos%BOOST_TYPEOF_NESTED_SIZE;
      static const int iteration=pos/BOOST_TYPEOF_NESTED_SIZE;
      typedef typename
v_iter<encode_part<iteration>,mpl::size_t<where> >::type type;
      typedef decode_iter<Pos::next> next;
   typedef typename decode_type<decode_iter<mpl::size_t<0> > >::type type;

What this means, is that a new encode_vector of size
BOOST_TYPEOF_NESTED_SIZE will be calculated if the expresion is

E.g. if the expression needs 151 integers to be encoded, 4 separate
encoding vectors will be used to represent the expression.

push_back for offset_vector decrements the offset, until the offset is
0, then it calls push_back on the nested_vector.

push_back on a nested_vector of size BOOST_TYPEOF_NESTED_SIZE returns
the input vector.


> Regards,
> Arkadiy
> _______________________________________________
> Unsubscribe & other changes:

Boost list run by bdawes at, gregod at, cpdaniel at, john at