StdBitfieldAdapt< T > Struct Template Reference

#include <StdAdaptors.h>

Collaboration diagram for StdBitfieldAdapt< T >:

Public Types
typedef StdBitfieldEntry< T >	Entry

Public Member Functions
	StdBitfieldAdapt (T &rVal, const Entry *pNames)
void	CompileFunc (StdCompiler *pComp) const
template<class D >
bool	operator== (const D &nValue) const
template<class D >
StdBitfieldAdapt< T > &	operator= (const D &nValue)

Public Attributes
T &	rVal
const Entry *	pNames

Detailed Description

template<class T>
struct StdBitfieldAdapt< T >

Definition at line 890 of file StdAdaptors.h.

Member Typedef Documentation

Entry

template<class T >

typedef StdBitfieldEntry<T> StdBitfieldAdapt< T >::Entry

Definition at line 892 of file StdAdaptors.h.

Constructor & Destructor Documentation

StdBitfieldAdapt()

template<class T >

StdBitfieldAdapt< T >::StdBitfieldAdapt ( T &  rVal, const Entry *  pNames  )

inline

Definition at line 894 of file StdAdaptors.h.

: rVal(rVal), pNames(pNames) { assert(pNames); }

References StdEnumAdapt< T, int_t >::pNames.

Member Function Documentation

CompileFunc()

template<class T >

void StdBitfieldAdapt< T >::CompileFunc ( StdCompiler *  pComp ) const

inline

Definition at line 897 of file StdAdaptors.h.

    {
        // simply write for non-verbose compilers
        if (!pComp->isVerbose())
        {
            pComp->Value(rVal);
            return;
        }
        // writing?
        if (!pComp->isDeserializer())
        {
            T val = rVal, orig_val = rVal;
            // Write until value is comsumed
            bool fFirst = true;
            for (const Entry *pName = pNames; pName->Name; pName++)
                if ((pName->Val & val) == pName->Val)
                {
                    // Avoid writing meaningless none-values (e.g. Category=C4D_None|C4D_Object)
                    if (orig_val && !pName->Val) continue;
                    // Put "|"
                    if (!fFirst) pComp->Separator(StdCompiler::SEP_VLINE);
                    // Put name
                    pComp->String(const_cast<char **>(&pName->Name), StdCompiler::RCT_Idtf);
                    fFirst = false;
                    // Remove bits
                    val &= ~pName->Val;
                }
            // Anything left is written as number, or a simple 0 in case no default was used
            if (val || fFirst)
            {
                // Put "|"
                if (!fFirst) pComp->Separator(StdCompiler::SEP_VLINE);
                // Put value
                pComp->Value(val);
            }
        }
        // reading?
        else
        {
            T val = 0;
            // Read
            do
            {
#ifdef STDCOMPILER_EXCEPTION_WORKAROUND
                T tmp;
                // Try to read as number
                if (pComp->ValueSafe(tmp))
                    val |= tmp;
                else
                {
#else
                // Try to read as number
                try
                {
                    T tmp;
                    pComp->Value(tmp);
                    val |= tmp;
                }
                catch (StdCompiler::NotFoundException *pEx)
                {
                    delete pEx;
#endif
                    // Try to read as string
                    StdStrBuf Name;
                    pComp->Value(mkParAdapt(Name, StdCompiler::RCT_Idtf));
                    // Search in name list
                    const Entry *pName = pNames;
                    for (; pName->Name; pName++)
                        if (Name == pName->Name)
                        {
                            val |= pName->Val;
                            break;
                        }
                    // Not found? Warn
                    if (!pName->Name)
                        pComp->Warn("Unknown bit name: %s", Name.getData());
                }
                // Expect separation
            } while (pComp->Separator(StdCompiler::SEP_VLINE));
            // Write value back
            rVal = val;
        }
    }

References StdStrBuf::getData(), StdCompiler::isDeserializer(), StdCompiler::isVerbose(), mkParAdapt(), StdEnumEntry< T >::Name, StdBitfieldEntry< T >::Name, StdEnumAdapt< T, int_t >::pNames, StdCompiler::RCT_Idtf, StdEnumAdapt< T, int_t >::rVal, StdCompiler::SEP_VLINE, StdCompiler::Separator(), StdCompiler::String(), StdBitfieldEntry< T >::Val, StdCompiler::Value(), and StdCompiler::Warn().

Here is the call graph for this function:

operator=()

template<class T >

template<class D >

StdBitfieldAdapt<T>& StdBitfieldAdapt< T >::operator= ( const D &  nValue )

inline

Definition at line 982 of file StdAdaptors.h.

{ rVal = nValue; return *this; }

References StdEnumAdapt< T, int_t >::rVal.

operator==()

template<class T >

template<class D >

bool StdBitfieldAdapt< T >::operator== ( const D &  nValue ) const

inline

Definition at line 981 of file StdAdaptors.h.

{ return rVal == nValue; }

References StdEnumAdapt< T, int_t >::rVal.

Member Data Documentation

pNames

template<class T >

const Entry* StdBitfieldAdapt< T >::pNames

Definition at line 895 of file StdAdaptors.h.

rVal

template<class T >

T& StdBitfieldAdapt< T >::rVal

Definition at line 895 of file StdAdaptors.h.

---

The documentation for this struct was generated from the following file:

• StdAdaptors.h