Re: Two Templates
On Oct 23, 3:22 pm, "Jim Langston" <tazmas...@rocketmail.com> wrote:
I am curious, however, why this TransformTo even exists, why that logic
isn't being handled in the tempalte swapEndianess<T> which could do the
exact same thing if the endianess is the same, simply return the value. =
I
do not know of any other reasoning for specialiazing then leaving it alon=
e,
and that is what swapEndianess<T> should do in the firstplace.
I'm curious what happens if you call swapEndianess< T > with a value with
the same endian policy. swapEndianess is probably interesting to look =
at
also.
Well, the "TransformTo" code with the "swapEndianess" that precedes it
is:
//! \brief generic function to swap the byte ordering of a given type
//!
//! The byte ordering can be swapped meaningfully only for unsigned
integer types
//! therefore specializations are provided only for those types. We
use
//! template specialization in order to avoid automatic argument
conversion.
template<typename T>
struct SwapEndianess {};
template<> struct SwapEndianess< uint8 >
{
uint8 operator()(uint8 value) const { return value; }
};
template<> struct SwapEndianess< uint16 >
{
uint16 operator()(uint16 value) const
{
return _byteswap_ushort( value );
}
};
template<> struct SwapEndianess< uint32 >
{
uint32 operator()(uint32 value) const
{
return _byteswap_ulong( value );
}
};
template<> struct SwapEndianess< uint64 >
{
uint64 operator()(uint64 value) const
{
return _byteswap_uint64( value );
}
};
template<typename T>
inline T swapEndianess(T value)
{
return SwapEndianess< T >()( value ); <--- Point of interest
}
//! \brief Generic function object to give its char serialization a
given
//! specified byte ordering.
//!
//! The byte ordering of the argument is swapped unless it matches the
byte
//! ordering of the target machine.
//! We use partial specialization to achieve this.
template<typename T, Endianess endianPolicy> struct TransformTo
{
T operator()(T value) const { return swapEndianess< T >( value ); }
};
template<typename T > struct TransformTo< T, Machine::endianess >
{
T operator()(T value) const { return value; }
};
It looks to me like the author of the code put a lot more effort into
swapping the "Endianess" than he needed to. And the problem I'm up
against is that the call to "SwapEndianess< T >()( value )", next to
which I added the comment "Point of interest" doesn't compile on my
version of Visual Studio. So I'm trying to find some other way of
doing this that achieves the same functionality. If I go on the
assumption that all "swapEndianess" does is swap the order of the
bytes, couldn't I just write:
uint8 swapEndianess ( uint8 value)
{
return value;
}
uint16 swapEndianess ( uint16 value)
{
return _byteswap_ushort( value);
}
uint32 swapEndianess ( uint32 value)
{
return _byteswap_ulong( value);
}
uint64 swapEndianess ( uint64 value)
{
return _byteswap_uint64( value);
}
Granted that would require me to write a lot more code for the
"TransformTo()"s then the current author has done, but at least it
would compile. I think I would have to write four "TransformTo()"s
instead of just the one that's there, but I'd be willing to do that.
The first one would just be:
uint8 TransformTo ( uint8 value)
{
return value;
}
wouldn't it? And for the next three I'd have:
uint16 TransformTo ( uint16 value)
{
return [some condition] ? value : swapEndianess( value);
}
uint32 TransformTo ( uint32 value)
{
return [some condition] ? value : swapEndianess( value);
}
uint64 TransformTo ( uint64 value)
{
return [some condition] ? value : swapEndianess( value);
}
where [some condition] would be identical for the three, but what
exactly would [some condition] be? I'd be comparing something against
"Machine::endianess", but what?
Kevin S