VirtualBox

Changeset 36508 in vbox for trunk/include/iprt/cpp


Ignore:
Timestamp:
Apr 1, 2011 3:03:59 PM (14 years ago)
Author:
vboxsync
Message:

iprt/C++: some cleanup.

Location:
trunk/include/iprt/cpp
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/cpp/autores.h

    r36499 r36508  
    44
    55/*
    6  * Copyright (C) 2008 Oracle Corporation
     6 * Copyright (C) 2008-2011 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3131
    3232/**
    33  * @addtogroup grp_rt_cpp_util
    34  * @{
    35  */
    36 
    37 /**
    3833 * A simple class used to prevent copying and assignment.
    3934 *
    4035 * Inherit from this class in order to prevent automatic generation
    4136 * of the copy constructor and assignment operator in your class.
     37 *
     38 * @todo Functionality duplicated by iprt::non_copyable. grr!
     39 *
     40 * @addtogroup grp_rt_cpp_util
    4241 */
    4342class RTCNonCopyable
    … …  
    5150};
    5251
    53 /** @} */
    54 
    55 /**
    56  * @defgroup grp_rt_cpp_autores    C++ Resource Management
     52
     53/** @defgroup grp_rt_cpp_autores    C++ Resource Management
    5754 * @ingroup grp_rt_cpp
    5855 * @{
    … …  
    8582 */
    8683template <class T>
    87 inline void RTAutoResDestruct(T aHandle)
     84inline void RTAutoResDestruct(T a_h)
    8885{
    8986    AssertFatalMsgFailed(("Unspecialized template!\n"));
    90     NOREF(aHandle);
     87    NOREF(a_h);
    9188}
    9289

  • trunk/include/iprt/cpp/exception.h

    r36499 r36508  
    44
    55/*
    6  * Copyright (C) 2006-2010 Oracle Corporation
     6 * Copyright (C) 2006-2011 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3232{
    3333
    34 /**
    35  * @defgroup grp_rt_cpp_exceptions    C++ Exceptions
     34/** @defgroup grp_rt_cpp_exceptions     C++ Exceptions
    3635 * @ingroup grp_rt_cpp
    3736 * @{

  • trunk/include/iprt/cpp/list.h

    r36500 r36508  
    2929#include <iprt/cpp/meta.h>
    3030#include <iprt/mem.h>
     31#include <iprt/string.h> /* for memcpy */
    3132
    3233#include <new> /* For std::bad_alloc */
    … …  
    3536{
    3637
    37 /**
    38  * @defgroup grp_rt_cpp_list   C++ List support
     38/** @defgroup grp_rt_cpp_list   C++ List support
    3939 * @ingroup grp_rt_cpp
    4040 *
    … …  
    312312    {
    313313        /* Prevent self assignment */
    314         if (this == &other) return *this;
     314        if (this == &other)
     315            return *this;
     316
    315317        /* Values cleanup */
    316318        ListHelper<T, list_type>::eraseRange(m_pArray, 0, m_cSize);
     319
    317320        /* Copy */
    318321        if (other.m_cSize != m_cCapacity)
    … …  
    520523
    521524    /**
    522       * Generic realloc, which does some kind of boundary checking.
     525     * Generic realloc, which does some kind of boundary checking.
    523526     */
    524527    void realloc(size_t cNewSize)
    … …  
    527530        if (cNewSize == m_cCapacity)
    528531            return;
     532
    529533        /* If we get smaller we have to delete some of the objects at the end
    530534           of the list. */
    … …  
    535539            m_cSize -= m_cSize - cNewSize;
    536540        }
     541
    537542        /* If we get zero we delete the array it self. */
    538543        if (   cNewSize == 0
    … …  
    543548        }
    544549        m_cCapacity = cNewSize;
     550
    545551        /* Resize the array. */
    546552        if (cNewSize > 0)
    … …  
    549555            if (!m_pArray)
    550556            {
     557                /** @todo you leak memory. */
    551558                m_cCapacity = 0;
    552559                m_cSize = 0;
    553560#ifdef RT_EXCEPTIONS_ENABLED
    554561                throw std::bad_alloc();
    555 #endif /* RT_EXCEPTIONS_ENABLED */
     562#endif
    556563            }
    557564        }
    … …  
    570577        if (!m_pArray)
    571578        {
     579            /** @todo you leak memory. */
    572580            m_cCapacity = 0;
    573581            m_cSize = 0;
    574582#ifdef RT_EXCEPTIONS_ENABLED
    575583            throw std::bad_alloc();
    576 #endif /* RT_EXCEPTIONS_ENABLED */
     584#endif
    577585        }
    578586    }
    … …  
    604612 */
    605613template <class T, typename TYPE = typename if_<(sizeof(T) > sizeof(void*)), T*, T>::result>
    606 class list: public ListBase<T, TYPE> {};
     614class list : public ListBase<T, TYPE> {};
    607615
    608616/**
    … …  
    628636} /* namespace iprt */
    629637
    630 #endif /* ___iprt_cpp_list_h */
    631 
     638#endif /* !___iprt_cpp_list_h */
     639

  • trunk/include/iprt/cpp/lock.h

    r36499 r36508  
    44
    55/*
    6  * Copyright (C) 2007 Oracle Corporation
     6 * Copyright (C) 2007-2011 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3434RT_C_DECLS_BEGIN
    3535
    36 /**
    37  * @defgroup grp_rt_cpp_lock       C++ Scope-based Locking
     36/** @defgroup grp_rt_cpp_lock       C++ Scope-based Locking
    3837 * @ingroup grp_rt_cpp
    3938 * @{
    … …  
    5352class RTLockMtx
    5453{
    55     friend class RTLock;
     54friend class RTLock;
    5655
    57     private:
    58         RTCRITSECT      mMtx;
     56private:
     57    RTCRITSECT      mMtx;
    5958
    60     public:
    61         RTLockMtx()
    62         {
     59public:
     60    RTLockMtx()
     61    {
    6362#ifdef RT_LOCK_STRICT_ORDER
    64             RTCritSectInitEx(&mMtx, 0 /*fFlags*/,
    65                              RTLockValidatorClassCreateUnique(RT_SRC_POS, NULL),
    66                              RTLOCKVAL_SUB_CLASS_NONE, NULL);
     63        RTCritSectInitEx(&mMtx, 0 /*fFlags*/,
     64                         RTLockValidatorClassCreateUnique(RT_SRC_POS, NULL),
     65                         RTLOCKVAL_SUB_CLASS_NONE, NULL);
    6766#else
    68             RTCritSectInit(&mMtx);
     67        RTCritSectInit(&mMtx);
    6968#endif
    70         }
     69    }
    7170
    72         /** Use to when creating locks that belongs in the same "class".  */
    73         RTLockMtx(RT_SRC_POS_DECL, uint32_t uSubClass = RTLOCKVAL_SUB_CLASS_NONE)
    74         {
     71    /** Use to when creating locks that belongs in the same "class".  */
     72    RTLockMtx(RT_SRC_POS_DECL, uint32_t uSubClass = RTLOCKVAL_SUB_CLASS_NONE)
     73    {
    7574#ifdef RT_LOCK_STRICT_ORDER
    76             RTCritSectInitEx(&mMtx, 0 /*fFlags*/,
    77                              RTLockValidatorClassForSrcPos(RT_SRC_POS_ARGS, NULL),
    78                              uSubClass, NULL);
     75        RTCritSectInitEx(&mMtx, 0 /*fFlags*/,
     76                         RTLockValidatorClassForSrcPos(RT_SRC_POS_ARGS, NULL),
     77                         uSubClass, NULL);
    7978#else
    80             NOREF(uSubClass);
    81             RTCritSectInit(&mMtx);
    82             RT_SRC_POS_NOREF();
     79        NOREF(uSubClass);
     80        RTCritSectInit(&mMtx);
     81        RT_SRC_POS_NOREF();
    8382#endif
    84         }
     83    }
    8584
    86         ~RTLockMtx()
    87         {
    88             RTCritSectDelete(&mMtx);
    89         }
     85    ~RTLockMtx()
     86    {
     87        RTCritSectDelete(&mMtx);
     88    }
    9089
    91     // lock() and unlock() are private so that only
    92     // friend RTLock can access them
    93     private:
    94         inline void lock()
    95         {
    96             RTCritSectEnter(&mMtx);
    97         }
     90// lock() and unlock() are private so that only
     91// friend RTLock can access them
     92private:
     93    inline void lock()
     94    {
     95        RTCritSectEnter(&mMtx);
     96    }
    9897
    99         inline void unlock()
    100         {
    101             RTCritSectLeave(&mMtx);
    102         }
     98    inline void unlock()
     99    {
     100        RTCritSectLeave(&mMtx);
     101    }
    103102};
    104103
    … …  
    129128class RTLock
    130129{
    131     private:
    132         RTLockMtx  &mMtx;
    133         bool        mfLocked;
     130private:
     131    RTLockMtx  &mMtx;
     132    bool        mfLocked;
    134133
    135     public:
    136         RTLock(RTLockMtx &aMtx)
    137             : mMtx(aMtx)
     134public:
     135    RTLock(RTLockMtx &aMtx)
     136        : mMtx(aMtx)
     137    {
     138        mMtx.lock();
     139        mfLocked = true;
     140    }
     141
     142    ~RTLock()
     143    {
     144        if (mfLocked)
     145            mMtx.unlock();
     146    }
     147
     148    inline void release()
     149    {
     150        if (mfLocked)
    138151        {
    139             mMtx.lock();
    140             mfLocked = true;
     152            mMtx.unlock();
     153            mfLocked = false;
    141154        }
    142 
    143         ~RTLock()
    144         {
    145             if (mfLocked)
    146                 mMtx.unlock();
    147         }
    148 
    149         inline void release()
    150         {
    151             if (mfLocked)
    152             {
    153                 mMtx.unlock();
    154                 mfLocked = false;
    155             }
    156         }
     155    }
    157156};
    158157

  • trunk/include/iprt/cpp/meta.h

    r36500 r36508  
    3030{
    3131
    32 /**
    33  * @defgroup grp_rt_cpp_meta   C++ Meta programming utilities
     32/** @defgroup grp_rt_cpp_meta   C++ Meta programming utilities
    3433 * @ingroup grp_rt_cpp
    3534 * @{

  • trunk/include/iprt/cpp/ministring.h

    r36501 r36508  
    44
    55/*
    6  * Copyright (C) 2007-2009 Oracle Corporation
     6 * Copyright (C) 2007-2011 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3737{
    3838
    39 /**
    40  * @defgroup grp_rt_cpp_string     C++ String support
     39/** @defgroup grp_rt_cpp_string     C++ String support
    4140 * @ingroup grp_rt_cpp
    4241 * @{
    4342 */
    4443
    45 /**
    46  * @brief Mini C++ string class.
     44/** @brief  Mini C++ string class.
    4745 *
    4846 * "MiniString" is a small C++ string class that does not depend on anything
    … …  
    825823     * Splits a string separated by strSep into its parts.
    826824     *
    827      * @param   strSep       The separator to search for.
    828      * @param   mode         How should empty parts be handled.
     825     * @param   a_rstrSep   The separator to search for.
     826     * @param   a_enmMode   How should empty parts be handled.
    829827     * @returns separated strings as string list.
    830828     */
    831     iprt::list<iprt::MiniString, iprt::MiniString*> split(const iprt::MiniString &strSep, SplitMode mode = RemoveEmptyParts);
     829    iprt::list<iprt::MiniString, iprt::MiniString *> split(const iprt::MiniString &a_rstrSep,
     830                                                           SplitMode a_enmMode = RemoveEmptyParts);
    832831
    833832    /**
    834833     * Joins a list of strings together using the provided separator.
    835834     *
    836      * @param   list         The list to join.
    837      * @param   strSep       The separator used for joining.
     835     * @param   a_rList     The list to join.
     836     * @param   a_rstrSep   The separator used for joining.
    838837     * @returns joined string.
    839838     */
    840     static iprt::MiniString join(const iprt::list<iprt::MiniString, iprt::MiniString*> &list, const iprt::MiniString &strSep = "");
    841        
     839    static iprt::MiniString join(const iprt::list<iprt::MiniString, iprt::MiniString *> &a_rList,
     840                                 const iprt::MiniString &a_rstrSep = "");
     841
    842842protected:
    843843
    … …  
    919919} /* namespace iprt */
    920920
    921 /**
    922  * @addtogroup grp_rt_cpp_string
     921/** @addtogroup grp_rt_cpp_string
    923922 * @{
    924923 */
    925924
    926925/**
     926 * Concatenate two strings.
     927 *
     928 * @param   a_rstr1     String one.
     929 * @param   a_rstr2     String two.
     930 * @returns the concatenate string.
     931 *
    927932 * @relates iprt::MiniString
    928  *
     933 */
     934RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &a_rstr1, const iprt::MiniString &a_rstr2);
     935
     936/**
    929937 * Concatenate two strings.
    930938 *
    931  * @param   one        String one.
    932  * @param   other      String two.
     939 * @param   a_rstr1     String one.
     940 * @param   a_psz2      String two.
    933941 * @returns the concatenate string.
     942 *
     943 * @relates iprt::MiniString
    934944 */
    935 RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &one, const iprt::MiniString &other);
     945RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &a_rstr1, const char *a_psz2);
    936946
    937947/**
     948 * Concatenate two strings.
     949 *
     950 * @param   a_psz1      String one.
     951 * @param   a_rstr2     String two.
     952 * @returns the concatenate string.
     953 *
    938954 * @relates iprt::MiniString
    939  *
    940  * Concatenate two strings.
    941  *
    942  * @param   one        String one.
    943  * @param   pcszOther  String two.
    944  * @returns the concatenate string.
    945955 */
    946 RTDECL(const iprt::MiniString) operator+(const iprt::MiniString &one, const char *pcszOther);
    947 
    948 /**
    949  * @relates iprt::MiniString
    950  *
    951  * Concatenate two strings.
    952  *
    953  * @param   pcszOne    String one.
    954  * @param   other      String two.
    955  * @returns the concatenate string.
    956  */
    957 RTDECL(const iprt::MiniString) operator+(const char *pcszOne, const iprt::MiniString &other);
     956RTDECL(const iprt::MiniString) operator+(const char *a_psz1, const iprt::MiniString &a_rstr2);
    958957
    959958/** @} */

  • trunk/include/iprt/cpp/utils.h

    r36499 r36508  
    44
    55/*
    6  * Copyright (C) 2006-2007 Oracle Corporation
     6 * Copyright (C) 2006-2011 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2727#define ___iprt_cpputils_h
    2828
    29 /**
    30  * @defgroup grp_rt_cpp         IPRT C++ support
    31  * @ingroup grp_rt
    32  */
     29/** @defgroup grp_rt_cpp        IPRT C++ APIs */
    3330
    34 /**
    35  * @defgroup grp_rt_cpp_util    C++ Utilitis
     31/** @defgroup grp_rt_cpp_util   C++ Utilities
    3632 * @ingroup grp_rt_cpp
    3733 * @{
    … …  
    4137 * Shortcut to |const_cast<C &>()| that automatically derives the correct
    4238 * type (class) for the const_cast template's argument from its own argument.
     39 *
    4340 * Can be used to temporarily cancel the |const| modifier on the left-hand side
    4441 * of assignment expressions, like this:
    4542 * @code
    46  *      const Class that;
     43 *      const Class That;
    4744 *      ...
    48  *      unconst (that) = some_value;
     45 *      unconst(That) = SomeValue;
    4946 * @endcode
    5047 */
    5148template <class C>
    52 inline C& unconst(const C &that) { return const_cast<C&>(that); }
     49inline C &unconst(const C &that)
     50{
     51    return const_cast<C &>(that);
     52}
    5353
    5454
    … …  
    5656 * Shortcut to |const_cast<C *>()| that automatically derives the correct
    5757 * type (class) for the const_cast template's argument from its own argument.
     58 *
    5859 * Can be used to temporarily cancel the |const| modifier on the left-hand side
    5960 * of assignment expressions, like this:
    6061 * @code
    61  *      const Class *that;
     62 *      const Class *pThat;
    6263 *      ...
    63  *      unconst (that) = some_value;
     64 *      unconst(pThat) = SomeValue;
    6465 * @endcode
    6566 */
    6667template <class C>
    67 inline C* unconst(const C *that) { return const_cast<C*>(that); }
     68inline C *unconst(const C *that)
     69{
     70    return const_cast<C *>(that);
     71}
    6872
    6973/** @} */
    … …  
    7377
    7478/**
     79 * A simple class used to prevent copying and assignment.
     80 *
     81 * Inherit from this class in order to prevent automatic generation of the copy
     82 * constructor and assignment operator in your class.
     83 *
    7584 * @ingroup grp_rt_cpp_util
    76  * @{
    77  */
    78 
    79 /**
    80  * A simple class used to prevent copying and assignment.  Inherit from this
    81  * class in order to prevent automatic generation of the copy constructor
    82  * and assignment operator in your class.
     85 * @todo Functionality duplicated by RTCNonCopyable. grr!
    8386 */
    8487class non_copyable
    … …  
    8891    ~non_copyable() {}
    8992private:
    90     non_copyable(non_copyable const&);
    91     non_copyable const &operator=(non_copyable const&);
     93    non_copyable(non_copyable const &);
     94    non_copyable const &operator=(non_copyable const &);
    9295};
    9396
    94 /** @} */
     97} /* namespace iprt */
    9598
    96 } // namespace iprt
     99#endif
    97100
    98 #endif // ___iprt_cpputils_h
    99 

  • trunk/include/iprt/cpp/xml.h

    r36499 r36508  
    3636#include <iprt/cpp/exception.h>
    3737
    38 /**
    39  * @defgroup grp_rt_cpp_xml    C++ XML support
     38/** @defgroup grp_rt_cpp_xml    C++ XML support
    4039 * @ingroup grp_rt_cpp
    4140 * @{
    … …  
    747746
    748747#endif /* !___iprt_xml_h */
     748
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette