www.pudn.com > Loki.rar > VC_Alignment.h

// Last update: June 20, 2001 
 
#ifdef _MSC_VER 
# pragma once 
#else 
# error "Visual C++ specific header !" 
#endif 
 
#ifndef VC_ALIGNMENT_INC_ 
#define VC_ALIGNMENT_INC_ 
 
#include "Typelist.h" 
#include "static_check.h" 
 
//////////////////////////////////////////////////////////////////////////////// 
// class template MaxAlign 
// Computes the maximum alignof for all types in a typelist 
// Usage: MaxAlign::result 
//////////////////////////////////////////////////////////////////////////////// 
 
template  struct VC_MaxAlign; 
 
template <>  
struct VC_MaxAlign< ::Loki::NullType > 
{ 
    enum { result = 0 }; 
}; 
 
template  
struct VC_MaxAlign 
{ 
private: 
    ASSERT_TYPELIST(TList); 
 
    typedef typename TList::Head Head; 
    typedef typename TList::Tail Tail; 
 
private: 
    enum { headResult = __alignof(Head)        }; 
    enum { tailResult = VC_MaxAlign::result }; 
 
public: 
    enum { result = headResult > tailResult ?  
           headResult : tailResult }; 
}; 
 
                          
//////////////////////////////////////////////////////////////////////////////// 
// class VC_AlignedPODBase 
// Defines a host of protected types used by VC_AlignedPOD (defined later) 
// Could be just part of VC_AlignedPOD itself, but making it separate ought to  
// reduce compile times  
//////////////////////////////////////////////////////////////////////////////// 
class VC_AlignedPODBase 
{ 
protected: 
 
    template 
    struct AlignedPod 
    { 
        STATIC_CHECK(AlignmentSize == 0, BadAlignmentSize_OnlyUpTo128); 
    }; 
 
// 
// I used the macro because align(#)  
// only works with Integer literals 
// 
#define ALIGNED_POD(_size_)                                   \ 
template<> struct AlignedPod<_size_> {                        \ 
  __declspec(align(_size_)) struct type { char X[_size_]; };  \ 
  enum { alignment = __alignof(type) }; };                    \ 
STATIC_CHECK((_size_ == sizeof(AlignedPod<_size_>::type)), SizeofNotEqualSize); \ 
STATIC_CHECK((_size_ == (AlignedPod<_size_>::alignment)), SizeofNotEqualAlignof) 
 
 
    ALIGNED_POD(1); 
    ALIGNED_POD(2); 
    ALIGNED_POD(4); 
    ALIGNED_POD(8); 
    ALIGNED_POD(16); 
    ALIGNED_POD(32); 
    ALIGNED_POD(64); 
    ALIGNED_POD(128); 
    // can be up to 8192 - is it realistic? 
 
#undef ALIGNED_POD 
 
}; 
 
 
//////////////////////////////////////////////////////////////////////////////// 
// class template VC_AlignedPOD 
// Computes the alignment of all types in a typelist 
//////////////////////////////////////////////////////////////////////////////// 
 
template  
class VC_AlignedPOD : VC_AlignedPODBase 
{ 
    enum { maxAlign = VC_MaxAlign::result }; 
 
public: 
    typedef typename AlignedPod::type Result; 
}; 
 
#endif // VC_ALIGNMENT_INC_