#89299# Binary layout of uno_Any changed

2 files changed, 253 insertions, 246 deletions

diff --git a/configmgr/source/inc/anypair.hxx b/configmgr/source/inc/anypair.hxx
index 38b53861f8f4..d8262f6f4674 100644
--- a/configmgr/source/inc/anypair.hxx
+++ b/configmgr/source/inc/anypair.hxx
@@ -5,8 +5,8 @@
 #include <uno/any2.h>
 #endif
 
-#ifndef _COM_SUN_STAR_UNO_ANY_HXX_
-#include <com/sun/star/uno/Any.hxx>
+#ifndef _COM_SUN_STAR_UNO_ANY_H_
+#include <com/sun/star/uno/Any.h>
 #endif
 
 #ifndef _COM_SUN_STAR_LANG_ILLEGALARGUMENTEXCEPTION_HPP_
@@ -20,20 +20,33 @@ namespace configmgr
     namespace lang = css::lang;
 
     //==========================================================================
-    //= AnyPair
+    //= Basic (POD) data structure for representing a single value in an AnyPair
     //==========================================================================
-    // this AnyPair holds 2 Any's with has always the same type.
-    // to safe some mem we have decide to create this construct.
 
+    typedef uno_Any cfgmgr_AnyPair_Data;
+
+    inline bool cfgmgr_AnyPair_Data_hasValue(cfgmgr_AnyPair_Data const* _pData)
+    { return (typelib_TypeClass_VOID != _pData->pType->eTypeClass); }
+    //==========================================================================
+    //= cfgmgr_AnyPair Basic (POD) data structure for an AnyPair
+    //==========================================================================
 
     struct cfgmgr_AnyPair
     {
-        typelib_TypeDescriptionReference * m_pType;
-        void*     m_pFirst;
-        void*     m_pSecond;
+        typelib_TypeDescriptionReference *  pType;
+        cfgmgr_AnyPair_Data                 m_first;
+        cfgmgr_AnyPair_Data                 m_second;
     };
 
+    inline bool cfgmgr_AnyPair_isEmpty(cfgmgr_AnyPair const* _pPair)
+    { return (typelib_TypeClass_VOID == _pPair->pType->eTypeClass); }
+
 // -----------------------------------------------------------------------------
+    //==========================================================================
+    //= AnyPair
+    //==========================================================================
+    // this AnyPair holds 2 nullable Any's which have to have the same type.
+
     class AnyPair
     {
         cfgmgr_AnyPair m_aAnyPair;
@@ -42,7 +55,7 @@ namespace configmgr
         // ctors
         AnyPair();
         explicit AnyPair(uno::Type const& _aType); // one Type, any's are null
-        explicit AnyPair(uno::Any const& _aAny); // one any
+        explicit AnyPair(uno::Any const& _aAny); // one any - to first
 
         explicit AnyPair(uno::Any const& _aAny, uno::Any const& _aAny2) SAL_THROW((lang::IllegalArgumentException));
 
@@ -56,22 +69,22 @@ namespace configmgr
         ~AnyPair();
 
         // set-types
-        void setType(uno::Type const& _aType);
-
-        void setFirst(uno::Any const& _aAny);
-        void setSecond(uno::Any const& _aAny);
+        sal_Bool setFirst(uno::Any const& _aAny);
+        sal_Bool setSecond(uno::Any const& _aAny);
 
 
         uno::Any getFirst() const;
         uno::Any getSecond() const;
         uno::Type getValueType() const;
 
-        bool hasFirst() const {return m_aAnyPair.m_pFirst  ? true : false;}
-        bool hasSecond() const {return m_aAnyPair.m_pSecond ? true : false;}
-        bool isNull() const   {return m_aAnyPair.m_pFirst == NULL && m_aAnyPair.m_pSecond == 0;}
+        bool hasFirst()  const { return cfgmgr_AnyPair_Data_hasValue(&m_aAnyPair.m_first);}
+        bool hasSecond() const { return cfgmgr_AnyPair_Data_hasValue(&m_aAnyPair.m_second);}
+        bool hasValue()  const { return hasFirst() || hasSecond(); }
+        bool isNull  ()  const { return ! hasValue(); }
+        bool isEmpty()   const { return cfgmgr_AnyPair_isEmpty(&m_aAnyPair); }
 
-        void check_init();
-        void init();
+        void check_init() {};
+        void init() {};
     };
 
 
diff --git a/configmgr/source/misc/anypair.cxx b/configmgr/source/misc/anypair.cxx
index 8fe657547216..da091efce961 100644
--- a/configmgr/source/misc/anypair.cxx
+++ b/configmgr/source/misc/anypair.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: anypair.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: jb $ $Date: 2001-07-05 17:05:47 $
+ *  last change: $Author: jb $ $Date: 2001-07-06 10:20:50 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -59,271 +59,314 @@
  *
  ************************************************************************/
 
+#include <anypair.hxx>
+
 #ifndef _UNO_ANY2_H_
 #include <uno/any2.h>
 #endif
 
-#ifndef _COM_SUN_STAR_UNO_ANY_H_
-#include <com/sun/star/uno/Any.h>
+#ifndef _COM_SUN_STAR_UNO_ANY_HXX_
+#include <com/sun/star/uno/Any.hxx>
 #endif
 
-#include <anypair.hxx>
-
-#include <rtl/alloc.h>
+#define CFG_PRECOND( expr )  OSL_PRECOND ( expr, "Violated Precondition:  " #expr)
+#define CFG_POSTCOND( expr ) OSL_POSTCOND( expr, "Violated Postcondition: " #expr)
 
 namespace configmgr
 {
     namespace css = com::sun::star;
     namespace uno = css::uno;
 
-
-
-// Dirty Hack
-    inline uno_Any * firstAny(cfgmgr_AnyPair* _pPair)
-    {
-        return reinterpret_cast<uno_Any*>(_pPair);
-    }
+// -----------------------------------------------------------------------------
+    static inline bool impl_Any_hasValue(uno_Any const * _pData)
+    { return (typelib_TypeClass_VOID != _pData->pType->eTypeClass); }
 
 // -----------------------------------------------------------------------------
-    void anypair_construct_default(cfgmgr_AnyPair *_pAnyPair)
+    static inline
+    void anypair_default_construct_Data( typelib_TypeDescriptionReference ** _ppType,
+                                         cfgmgr_AnyPair_Data* _pAnyPairData)
     {
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
-        uno_any_construct(firstAny(_pAnyPair),0,0, uno::cpp_acquire);
-        OSL_ASSERT(_pAnyPair->m_pFirst == NULL);
-        _pAnyPair->m_pSecond = NULL;
+        uno_any_construct(_pAnyPairData, 0,0, uno::cpp_acquire);
+
+        *_ppType = _pAnyPairData->pType;
+        ::typelib_typedescriptionreference_acquire( *_ppType );
+
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_construct_type(cfgmgr_AnyPair *_pAnyPair, typelib_TypeDescriptionReference* _pType)
+    static inline
+    void anypair_type_construct_Data(cfgmgr_AnyPair_Data* _pAnyPairData,
+                                        typelib_TypeDescriptionReference * /*_pType*/)
     {
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
-        _pAnyPair->m_pType = _pType;
-        ::typelib_typedescriptionreference_acquire( _pAnyPair->m_pType );
+        // type is currently unused
+        uno_any_construct(_pAnyPairData, 0,0, uno::cpp_acquire);
     }
+
 // -----------------------------------------------------------------------------
-    void anypair_assign_type(cfgmgr_AnyPair *_pAnyPair, typelib_TypeDescriptionReference* _pType)
+    static inline
+    void anypair_any_construct_Data(cfgmgr_AnyPair_Data* _pAnyPairData, uno_Any const *_pUnoAny)
     {
-        typelib_typedescriptionreference_assign( &_pAnyPair->m_pType, _pType );
+        uno_type_any_construct(_pAnyPairData, _pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire);
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_construct_first(cfgmgr_AnyPair *_pAnyPair, const uno_Any *_pUnoAny)
+    static inline
+    void anypair_copy_construct_Data( cfgmgr_AnyPair_Data* _pAnyPairData,
+                                      cfgmgr_AnyPair_Data const * _pAnyPairDataFrom,
+                                      typelib_TypeDescriptionReference * /*_pType*/)
     {
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
-
-        uno_type_any_construct(firstAny(_pAnyPair), _pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire);
-        _pAnyPair->m_pSecond = NULL;
+        // type is currently unused
+        uno_type_any_construct(_pAnyPairData, _pAnyPairDataFrom->pData, _pAnyPairDataFrom->pType, uno::cpp_acquire);
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_construct_second(cfgmgr_AnyPair *_pAnyPair, const uno_Any *_pUnoAny)
+    static inline
+    void anypair_destruct_Data(cfgmgr_AnyPair_Data* _pAnyPairData,
+                               typelib_TypeDescriptionReference * /*_pType*/)
     {
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
-
-        uno_Any aTmp;
-        uno_type_any_construct(&aTmp,_pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire);
-        _pAnyPair->m_pType = aTmp.pType;
-        _pAnyPair->m_pSecond = aTmp.pData;
-        _pAnyPair->m_pFirst = NULL;
+        // type is currently unused
+        ::uno_any_destruct(_pAnyPairData, uno::cpp_release );
     }
 
 // -----------------------------------------------------------------------------
-    // if type not equal, you got false and the struct contains {0,0,0}
-    sal_Bool anypair_construct(cfgmgr_AnyPair *_pAnyPair, const uno_Any* _pFirstAny, const uno_Any *_pSecondAny)
+
+    static
+    sal_Bool anypair_assign_Data( typelib_TypeDescriptionReference** _ppType,
+                                  cfgmgr_AnyPair_Data* _pAnyPairData,
+                                  uno_Any const *_pUnoAny)
     {
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
-        bool bHasFirst  = (_pFirstAny ->pType->eTypeClass != typelib_TypeClass_VOID);
-        bool bHasSecond = (_pSecondAny->pType->eTypeClass != typelib_TypeClass_VOID);
+        typelib_TypeDescriptionReference* pNewType = _pUnoAny->pType;
 
-        if (bHasFirst)
-        {
-            if (bHasSecond && ! typelib_typedescriptionreference_equals(_pFirstAny->pType,_pSecondAny->pType))
-            {
-                OSL_ENSURE(false, "anypair_construct(): Cannot construct - Different types");
-                return false;
-            }
+        bool bCanAssign  = false;
+        bool bChangeType = false;
 
-            // construct first value
-            uno_type_any_construct(firstAny(_pAnyPair), _pFirstAny->pData, _pFirstAny->pType, uno::cpp_acquire);
+        typelib_TypeClass eOldTC = (*_ppType)->eTypeClass;
+        if ( pNewType->eTypeClass == typelib_TypeClass_VOID)
+            bCanAssign = true;
 
-            if (bHasSecond && _pSecondAny->pData != NULL)
-            {
-                // construct second value
-                uno_Any aTmp;
-                uno_type_any_construct(&aTmp,_pSecondAny->pData, _pSecondAny->pType, uno::cpp_acquire);
-                _pAnyPair->m_pSecond = aTmp.pData;
+        else if (eOldTC == typelib_TypeClass_VOID || eOldTC == typelib_TypeClass_ANY )
+            bChangeType = bCanAssign = true;
+
+        else if ( typelib_typedescriptionreference_equals(*_ppType,pNewType)  )
+            bCanAssign = true;
 
-                OSL_ASSERT(typelib_typedescriptionreference_equals(aTmp.pType,_pAnyPair->m_pType));
-                typelib_typedescriptionreference_release(aTmp.pType);
-            }
-            // else
-            //  _pAnyPair->m_pSecond = NULL;
-        }
         else
+            bCanAssign = false;
+
+        if (bCanAssign)
         {
-            if (bHasSecond)
+            ::uno_type_any_assign(_pAnyPairData, _pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire, uno::cpp_release );
+            if (bChangeType)
             {
-                anypair_construct_second(_pAnyPair,_pSecondAny);
-            }
-            else
-            {
-                _pAnyPair->m_pType = _pFirstAny->pType;
-                typelib_typedescriptionreference_acquire(_pAnyPair->m_pType);
-            //  _pAnyPair->m_pFirst = NULL;
+                ::typelib_typedescriptionreference_release( *_ppType );
+                *_ppType = pNewType; // *_ppType = _pAnyPairData->pType
+                ::typelib_typedescriptionreference_acquire( *_ppType );
             }
         }
+        else
+            OSL_ENSURE(false, "anypair_assign_XXX(): Cannot assign - Type mismatch");
 
-        return true;
+        return bCanAssign;
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_clear_first(cfgmgr_AnyPair* _pAnyPair)
+    static inline
+    void anypair_clear_Data(cfgmgr_AnyPair_Data* _pAnyPairData,
+                            typelib_TypeDescriptionReference * /*_pType*/)
     {
-        if (_pAnyPair->m_pFirst)
-        {
-            uno_Any aTmp;
-            aTmp.pData = _pAnyPair->m_pFirst;
-            aTmp.pType = _pAnyPair->m_pType;
-            typelib_typedescriptionreference_acquire(aTmp.pType);
+        // type is currently unused
+        uno_any_assign(_pAnyPairData, 0, 0, uno::cpp_acquire, uno::cpp_release);
+    }
 
-            uno_any_destruct(&aTmp, uno::cpp_release);
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+    void anypair_construct_default(cfgmgr_AnyPair * _pAnyPair)
+    {
+        CFG_PRECOND( _pAnyPair != NULL );
 
-            _pAnyPair->m_pFirst = NULL;
-        }
+        anypair_default_construct_Data(&_pAnyPair->pType, &_pAnyPair->m_first);
+        anypair_type_construct_Data   (&_pAnyPair->m_second,_pAnyPair->pType);
+
+        CFG_POSTCOND(  cfgmgr_AnyPair_isEmpty(_pAnyPair) );
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_clear_second(cfgmgr_AnyPair* _pAnyPair)
+    void anypair_construct_type(cfgmgr_AnyPair * _pAnyPair, typelib_TypeDescriptionReference* _pType)
     {
-        if (_pAnyPair->m_pSecond)
-        {
-            uno_Any aTmp;
-            aTmp.pData = _pAnyPair->m_pSecond;
-            aTmp.pType = _pAnyPair->m_pType;
-            typelib_typedescriptionreference_acquire(aTmp.pType);
+        CFG_PRECOND( _pAnyPair != NULL );
+        CFG_PRECOND( _pType != NULL );
 
-            uno_any_destruct(&aTmp, uno::cpp_release);
+        _pAnyPair->pType = _pType;
+        ::typelib_typedescriptionreference_acquire( _pAnyPair->pType );
 
-            _pAnyPair->m_pSecond = NULL;
-        }
+        anypair_type_construct_Data(&_pAnyPair->m_first ,_pAnyPair->pType);
+        anypair_type_construct_Data(&_pAnyPair->m_second,_pAnyPair->pType);
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_destruct(cfgmgr_AnyPair* _pAnyPair)
+    void anypair_construct_first(cfgmgr_AnyPair * _pAnyPair, uno_Any const *_pUnoAny)
     {
-        anypair_clear_first(_pAnyPair);
-        anypair_clear_second(_pAnyPair);
+        CFG_PRECOND( _pAnyPair != NULL );
+        CFG_PRECOND( _pUnoAny != NULL );
 
-        ::typelib_typedescriptionreference_release( _pAnyPair->m_pType );
-        OSL_DEBUG_ONLY(_pAnyPair->m_pType = (typelib_TypeDescriptionReference*)0xdeadbeef);
+        _pAnyPair->pType = _pUnoAny->pType;
+        ::typelib_typedescriptionreference_acquire( _pAnyPair->pType );
 
+        anypair_any_construct_Data (&_pAnyPair->m_first, _pUnoAny);
+        anypair_type_construct_Data(&_pAnyPair->m_second,_pAnyPair->pType);
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
     }
 
 // -----------------------------------------------------------------------------
-    void anypair_copy_construct(cfgmgr_AnyPair* _pAnyPair, const cfgmgr_AnyPair* _pAnyPairFrom)
+    void anypair_construct_second(cfgmgr_AnyPair * _pAnyPair, uno_Any const *_pUnoAny)
     {
-        _pAnyPair->m_pType = _pAnyPairFrom->m_pType;
-        _pAnyPair->m_pFirst = _pAnyPair->m_pSecond = NULL;
+        CFG_PRECOND( _pAnyPair != NULL );
+        CFG_PRECOND( _pUnoAny != NULL );
 
-        typelib_typedescriptionreference_acquire(_pAnyPair->m_pType);
+        _pAnyPair->pType = _pUnoAny->pType;
+        ::typelib_typedescriptionreference_acquire( _pAnyPair->pType );
 
-        if (_pAnyPairFrom->m_pFirst)
-        {
-            uno_Any aTmp;
-            uno_type_any_construct(&aTmp,_pAnyPairFrom->m_pFirst, _pAnyPairFrom->m_pType, uno::cpp_acquire);
-            _pAnyPair->m_pFirst = aTmp.pData;
-            OSL_ASSERT(typelib_typedescriptionreference_equals(_pAnyPair->m_pType,aTmp.pType));
-            typelib_typedescriptionreference_release(aTmp.pType);
-        }
-        if (_pAnyPairFrom->m_pSecond)
+        anypair_type_construct_Data(&_pAnyPair->m_first, _pAnyPair->pType);
+        anypair_any_construct_Data (&_pAnyPair->m_second,_pUnoAny);
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
+    }
+
+// -----------------------------------------------------------------------------
+    // if type not equal, you got false and the struct contains undefined values
+    sal_Bool anypair_construct(cfgmgr_AnyPair * _pAnyPair, uno_Any const * _pFirstAny, uno_Any const *_pSecondAny)
+    {
+        CFG_PRECOND( _pAnyPair != NULL );
+        CFG_PRECOND( _pFirstAny  != NULL );
+        CFG_PRECOND( _pSecondAny != NULL );
+
+        bool bHasFirst  = impl_Any_hasValue(_pFirstAny);
+        bool bHasSecond = impl_Any_hasValue(_pSecondAny);
+
+        if (bHasFirst && bHasSecond)
         {
-            uno_Any aTmp;
-            uno_type_any_construct(&aTmp,_pAnyPairFrom->m_pSecond, _pAnyPairFrom->m_pType, uno::cpp_acquire);
-            _pAnyPair->m_pSecond = aTmp.pData;
-            OSL_ASSERT(typelib_typedescriptionreference_equals(_pAnyPair->m_pType,aTmp.pType));
-            typelib_typedescriptionreference_release(aTmp.pType);
+            if ( ! typelib_typedescriptionreference_equals(_pFirstAny->pType,_pSecondAny->pType))
+            {
+                OSL_ENSURE(false, "anypair_construct(): Cannot construct - Different types");
+                return false;
+            }
         }
+
+        _pAnyPair->pType = bHasFirst ? _pFirstAny->pType : _pSecondAny->pType;
+        ::typelib_typedescriptionreference_acquire( _pAnyPair->pType );
+
+        anypair_any_construct_Data (&_pAnyPair->m_first ,_pFirstAny);
+        anypair_any_construct_Data (&_pAnyPair->m_second,_pSecondAny);
+
+        CFG_POSTCOND((bHasFirst || bHasSecond) == !cfgmgr_AnyPair_isEmpty(_pAnyPair) );
+        CFG_POSTCOND( bHasFirst  == cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
+        CFG_POSTCOND( bHasSecond == cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
+
+        return true;
     }
+// -----------------------------------------------------------------------------
 
-    static
-    sal_Bool anypair_canassign(typelib_TypeDescriptionReference* _ppType, const uno_Any *_pUnoAny)
+    void anypair_copy_construct(cfgmgr_AnyPair* _pAnyPair, cfgmgr_AnyPair const * _pAnyPairFrom)
     {
-        typelib_TypeClass eTC = _ppType->eTypeClass;
-        if  (eTC == typelib_TypeClass_VOID || eTC == typelib_TypeClass_ANY )
-            return true;
+        CFG_PRECOND( _pAnyPair     != NULL );
+        CFG_PRECOND( _pAnyPairFrom != NULL );
 
-        else if ( typelib_typedescriptionreference_equals(_ppType,_pUnoAny->pType)  )
-            return true;
+        _pAnyPair->pType = _pAnyPairFrom->pType;
+        ::typelib_typedescriptionreference_acquire( _pAnyPair->pType );
 
-        else if (_pUnoAny->pType->eTypeClass == typelib_TypeClass_VOID)
-            return true;
+        anypair_copy_construct_Data(&_pAnyPair->m_first,  &_pAnyPairFrom->m_first,  _pAnyPair->pType);
+        anypair_copy_construct_Data(&_pAnyPair->m_second, &_pAnyPairFrom->m_second, _pAnyPair->pType);
 
-        else
-            return false;
     }
 
-    static
-    sal_Bool anypair_assign_helper(typelib_TypeDescriptionReference** _ppType, void** _ppData , const uno_Any *_pUnoAny)
+// -----------------------------------------------------------------------------
+    void anypair_destruct(cfgmgr_AnyPair* _pAnyPair)
     {
-        if (!anypair_canassign(*_ppType,_pUnoAny))
-            return false;
+        CFG_PRECOND( _pAnyPair != NULL );
 
-        bool bOldNull = (*_ppData == NULL);
-        bool bNewNull = (_pUnoAny->pType->eTypeClass == typelib_TypeClass_VOID);
+        anypair_destruct_Data(&_pAnyPair->m_first,  _pAnyPair->pType);
+        anypair_destruct_Data(&_pAnyPair->m_second, _pAnyPair->pType );
 
-        if (bOldNull)
-        {
-            if (!bNewNull)
-            {
-                uno_Any aTmp;
-                uno_type_any_construct(&aTmp,_pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire);
+        ::typelib_typedescriptionreference_release( _pAnyPair->pType );
+        OSL_DEBUG_ONLY(_pAnyPair->pType = (typelib_TypeDescriptionReference*)0xdeadbeef);
 
-                typelib_typedescriptionreference_release(*_ppType);
+    }
 
-                *_ppData = aTmp.pData;
-                *_ppType = aTmp.pType;
-            }
-        }
-        else
-        {
-            uno_Any aTmp;
-            aTmp.pData = *_ppData;
-            aTmp.pType = *_ppType;
+// -----------------------------------------------------------------------------
+    sal_Bool anypair_assign_first(cfgmgr_AnyPair* _pAnyPair, uno_Any const * _pUnoAny)
+    {
+        CFG_PRECOND( _pAnyPair     != NULL );
+        CFG_PRECOND( _pUnoAny != NULL );
 
-            if (bNewNull)
-                typelib_typedescriptionreference_acquire(*_ppType);
+        return anypair_assign_Data(&_pAnyPair->pType, &_pAnyPair->m_first, _pUnoAny);
+    }
 
-            uno_type_any_assign(&aTmp,_pUnoAny->pData, _pUnoAny->pType, uno::cpp_acquire, uno::cpp_release);
+// -----------------------------------------------------------------------------
+    sal_Bool anypair_assign_second(cfgmgr_AnyPair* _pAnyPair, uno_Any const * _pUnoAny)
+    {
+        return anypair_assign_Data(&_pAnyPair->pType, &_pAnyPair->m_second, _pUnoAny);
+    }
 
-            if (bNewNull)
-            {
-                OSL_ASSERT(aTmp.pData == NULL);
-                *_ppData = NULL;
-                typelib_typedescriptionreference_release(aTmp.pType);
-            }
-            else
-            {
-                *_ppData = aTmp.pData;
-                *_ppType = aTmp.pType;
-            }
+// -----------------------------------------------------------------------------
+    void anypair_assign(cfgmgr_AnyPair* _pAnyPair, cfgmgr_AnyPair const * _pAnyPairFrom)
+    {
+        if (_pAnyPair != _pAnyPairFrom)
+        {
+            anypair_destruct(_pAnyPair);
+            anypair_copy_construct(_pAnyPair, _pAnyPairFrom);
         }
+    }
 
-        return true;
+// -----------------------------------------------------------------------------
+    void anypair_clear_first(cfgmgr_AnyPair* _pAnyPair)
+    {
+        CFG_PRECOND( _pAnyPair != NULL );
+
+        anypair_clear_Data(&_pAnyPair->m_first, _pAnyPair->pType);
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
     }
+
 // -----------------------------------------------------------------------------
-    sal_Bool anypair_assign_first(cfgmgr_AnyPair* _pAnyPair, const uno_Any* _pAny)
+    void anypair_clear_second(cfgmgr_AnyPair* _pAnyPair)
     {
-        return anypair_assign_helper(&_pAnyPair->m_pType, &_pAnyPair->m_pFirst, _pAny);
+        CFG_PRECOND( _pAnyPair != NULL );
+
+        anypair_clear_Data(&_pAnyPair->m_second, _pAnyPair->pType );
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
     }
 
 // -----------------------------------------------------------------------------
-    sal_Bool anypair_assign_second(cfgmgr_AnyPair* _pAnyPair, const uno_Any* _pAny)
+    void anypair_clear_values(cfgmgr_AnyPair* _pAnyPair)
     {
-        return anypair_assign_helper(&_pAnyPair->m_pType, &_pAnyPair->m_pSecond, _pAny);
+        CFG_PRECOND( _pAnyPair != NULL );
+
+        anypair_clear_Data(&_pAnyPair->m_first, _pAnyPair->pType);
+        anypair_clear_Data(&_pAnyPair->m_second, _pAnyPair->pType );
+
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_first) );
+        CFG_POSTCOND( !cfgmgr_AnyPair_Data_hasValue(&_pAnyPair->m_second) );
     }
 
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+    static
+    inline
+    uno::Any anypair_Data_toAny(cfgmgr_AnyPair_Data const * _pAnyPairData,
+                                typelib_TypeDescriptionReference * /*_pType*/)
+    {
+        return uno::Any( _pAnyPairData->pData, _pAnyPairData->pType );
+    }
 
 // -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
     // ctors
     AnyPair::AnyPair()
     {
@@ -353,20 +396,16 @@ namespace configmgr
 
 // -----------------------------------------------------------------------------
     // copy-ctor
-    AnyPair::AnyPair(AnyPair const& _aAny)
+    AnyPair::AnyPair(AnyPair const& _aOther)
     {
-        anypair_copy_construct(&m_aAnyPair, &_aAny.m_aAnyPair);
+        anypair_copy_construct(&m_aAnyPair, &_aOther.m_aAnyPair);
     }
 
 // -----------------------------------------------------------------------------
     // assign operator
-    AnyPair& AnyPair::operator=(AnyPair const& _aAny)
+    AnyPair& AnyPair::operator=(AnyPair const& _aOther)
     {
-        if (this != &_aAny)
-        {
-            anypair_destruct(&m_aAnyPair);
-            anypair_copy_construct(&m_aAnyPair, &_aAny.m_aAnyPair);
-        }
+        anypair_assign(&m_aAnyPair, &_aOther.m_aAnyPair);
         return *this;
     }
 
@@ -379,80 +418,35 @@ namespace configmgr
 
 
 // -----------------------------------------------------------------------------
-    void AnyPair::setFirst(uno::Any const& _aAny)
+    sal_Bool AnyPair::setFirst(uno::Any const& _aAny)
     {
-        OSL_VERIFY(anypair_assign_first(&m_aAnyPair,&_aAny));
+        return anypair_assign_first(&m_aAnyPair,&_aAny);
     }
 
 // -----------------------------------------------------------------------------
-    void AnyPair::setSecond(uno::Any const& _aAny)
+    sal_Bool AnyPair::setSecond(uno::Any const& _aAny)
     {
-        OSL_VERIFY(anypair_assign_second(&m_aAnyPair,&_aAny));
+        return anypair_assign_second(&m_aAnyPair,&_aAny);
     }
 
 // -----------------------------------------------------------------------------
     uno::Any AnyPair::getFirst() const
     {
-        // BACK: null any, if any not set.
-        if (m_aAnyPair.m_pFirst)
-        {
-            return uno::Any( m_aAnyPair.m_pFirst, m_aAnyPair.m_pType );
-        }
-        else
-            return uno::Any();
+        return anypair_Data_toAny( &m_aAnyPair.m_first, m_aAnyPair.pType );
     }
 // -----------------------------------------------------------------------------
     uno::Any AnyPair::getSecond() const
     {
-        // BACK: null any, if any not set.
-        if (m_aAnyPair.m_pSecond)
-        {
-            return uno::Any( m_aAnyPair.m_pSecond, m_aAnyPair.m_pType );
-        }
-        else
-            return uno::Any();
+        return anypair_Data_toAny( &m_aAnyPair.m_second, m_aAnyPair.pType );
     }
 
 // -----------------------------------------------------------------------------
     uno::Type AnyPair::getValueType() const
     {
-        return uno::Type(m_aAnyPair.m_pType);
+        return uno::Type(m_aAnyPair.pType);
     }
 
 // -----------------------------------------------------------------------------
 
-    // in Header
-    // bool hasFirst() const {return m_pFirst  ? true : false;}
-    // bool hasSecond() const {return m_pSecond ? true : false;}
-    // bool isNull() const   {return m_pFirst == NULL && m_pSecond == 0;}
-    void AnyPair::check_init()
-    {
-        if (this->hasFirst() || this->hasSecond())
-        {
-            OSL_ASSERT(this->getValueType() != ::getVoidCppuType());
-        }
-    }
-// -----------------------------------------------------------------------------
-    void AnyPair::init()
-    {
-        if (hasSecond())
-        {
-            OSL_ASSERT(this->getValueType() != ::getVoidCppuType());
-        }
-        else if (hasFirst())
-        {
-            OSL_ASSERT(this->getValueType() != ::getVoidCppuType());
-        }
-        else
-        {
-            // no type set, we must be void.
-            OSL_ASSERT(this->getValueType() == ::getVoidCppuType()); // at init time ValueType must be void
-        }
-    }
-
-
-
-
-
 } // namespace