Imported Upstream version 1.8.0

1 files changed, 48 insertions, 85 deletions

diff --git a/util/assert_util.h b/util/assert_util.h
index 018dc43..151e950 100644
--- a/util/assert_util.h
+++ b/util/assert_util.h
@@ -27,51 +27,6 @@ namespace mongo {
         StaleConfigInContextCode = 13388
     };
 
-	/* these are manipulated outside of mutexes, so be careful */
-    struct Assertion {
-        Assertion() {
-            msg[0] = msg[127] = 0;
-            context[0] = context[127] = 0;
-            file = "";
-            line = 0;
-            when = 0;
-        }
-    private:
-        static mongo::mutex *_mutex;
-        char msg[128];
-        char context[128];
-        const char *file;
-        unsigned line;
-        time_t when;
-    public:
-        void set(const char *m, const char *ctxt, const char *f, unsigned l) {
-            if( _mutex == 0 ) {
-                /* asserted during global variable initialization */
-                return;
-            }
-            scoped_lock lk(*_mutex);
-            strncpy(msg, m, 127);
-            strncpy(context, ctxt, 127);
-            file = f;
-            line = l;
-            when = time(0);
-        }
-        std::string toString();
-        bool isSet() {
-            return when != 0;
-        }
-    };
-
-    enum {
-        AssertRegular = 0,
-        AssertW = 1,
-        AssertMsg = 2,
-        AssertUser = 3
-    };
-
-    /* last assert of diff types: regular, wassert, msgassert, uassert: */
-    extern Assertion lastAssert[4];
-
     class AssertionCount {
     public:
         AssertionCount();
@@ -84,24 +39,20 @@ namespace mongo {
         int user;
         int rollovers;
     };
-    
+
     extern AssertionCount assertionCount;
-    
+
     struct ExceptionInfo {
-        ExceptionInfo() : msg(""),code(-1){}
+        ExceptionInfo() : msg(""),code(-1) {}
         ExceptionInfo( const char * m , int c )
-            : msg( m ) , code( c ){
+            : msg( m ) , code( c ) {
         }
         ExceptionInfo( const string& m , int c )
-            : msg( m ) , code( c ){
+            : msg( m ) , code( c ) {
         }
-
         void append( BSONObjBuilder& b , const char * m = "$err" , const char * c = "code" ) const ;
-        
         string toString() const { stringstream ss; ss << "exception: " << code << " " << msg; return ss.str(); }
-
         bool empty() const { return msg.empty(); }
-                
 
         string msg;
         int code;
@@ -109,69 +60,81 @@ namespace mongo {
 
     class DBException : public std::exception {
     public:
-        DBException( const ExceptionInfo& ei ) : _ei(ei){}
-        DBException( const char * msg , int code ) : _ei(msg,code){}
-        DBException( const string& msg , int code ) : _ei(msg,code){}
+        DBException( const ExceptionInfo& ei ) : _ei(ei) {}
+        DBException( const char * msg , int code ) : _ei(msg,code) {}
+        DBException( const string& msg , int code ) : _ei(msg,code) {}
         virtual ~DBException() throw() { }
-        
-        virtual const char* what() const throw(){ return _ei.msg.c_str(); }
+
+        virtual const char* what() const throw() { return _ei.msg.c_str(); }
         virtual int getCode() const { return _ei.code; }
-        
+
         virtual void appendPrefix( stringstream& ss ) const { }
-        
+
         virtual string toString() const {
             stringstream ss; ss << getCode() << " " << what(); return ss.str();
             return ss.str();
         }
-        
+
         const ExceptionInfo& getInfo() const { return _ei; }
 
     protected:
         ExceptionInfo _ei;
     };
-    
+
     class AssertionException : public DBException {
     public:
 
-        AssertionException( const ExceptionInfo& ei ) : DBException(ei){}
-        AssertionException( const char * msg , int code ) : DBException(msg,code){}
-        AssertionException( const string& msg , int code ) : DBException(msg,code){}
+        AssertionException( const ExceptionInfo& ei ) : DBException(ei) {}
+        AssertionException( const char * msg , int code ) : DBException(msg,code) {}
+        AssertionException( const string& msg , int code ) : DBException(msg,code) {}
 
         virtual ~AssertionException() throw() { }
-        
+
         virtual bool severe() { return true; }
         virtual bool isUserAssertion() { return false; }
 
         /* true if an interrupted exception - see KillCurrentOp */
-        bool interrupted() { 
+        bool interrupted() {
             return _ei.code == 11600 || _ei.code == 11601;
         }
     };
-    
+
     /* UserExceptions are valid errors that a user can cause, like out of disk space or duplicate key */
     class UserException : public AssertionException {
     public:
-        UserException(int c , const string& m) : AssertionException( m , c ){}
+        UserException(int c , const string& m) : AssertionException( m , c ) {}
 
         virtual bool severe() { return false; }
         virtual bool isUserAssertion() { return true; }
         virtual void appendPrefix( stringstream& ss ) const { ss << "userassert:"; }
     };
-    
+
     class MsgAssertionException : public AssertionException {
     public:
-        MsgAssertionException( const ExceptionInfo& ei ) : AssertionException( ei ){}
-        MsgAssertionException(int c, const string& m) : AssertionException( m , c ){}
+        MsgAssertionException( const ExceptionInfo& ei ) : AssertionException( ei ) {}
+        MsgAssertionException(int c, const string& m) : AssertionException( m , c ) {}
         virtual bool severe() { return false; }
         virtual void appendPrefix( stringstream& ss ) const { ss << "massert:"; }
     };
 
+
     void asserted(const char *msg, const char *file, unsigned line);
     void wasserted(const char *msg, const char *file, unsigned line);
+
+    /** a "user assertion".  throws UserAssertion.  logs.  typically used for errors that a user
+       could cause, such as dupliate key, disk full, etc.
+    */
     void uasserted(int msgid, const char *msg);
     inline void uasserted(int msgid , string msg) { uasserted(msgid, msg.c_str()); }
-    void uassert_nothrow(const char *msg); // reported via lasterror, but don't throw exception
+
+    /** reported via lasterror, but don't throw exception */
+    void uassert_nothrow(const char *msg);
+
+    /** msgassert and massert are for errors that are internal but have a well defined error text string.
+        a stack trace is logged.
+    */
     void msgassertedNoTrace(int msgid, const char *msg);
+    inline void msgassertedNoTrace(int msgid, const string& msg) { msgassertedNoTrace( msgid , msg.c_str() ); }
     void msgasserted(int msgid, const char *msg);
     inline void msgasserted(int msgid, string msg) { msgasserted(msgid, msg.c_str()); }
 
@@ -204,21 +167,21 @@ namespace mongo {
 #if defined(_DEBUG)
 # define MONGO_dassert assert
 #else
-# define MONGO_dassert(x) 
+# define MONGO_dassert(x)
 #endif
 #define dassert MONGO_dassert
 
     // some special ids that we want to duplicate
-    
+
     // > 10000 asserts
     // < 10000 UserException
-    
+
     enum { ASSERT_ID_DUPKEY = 11000 };
 
     /* throws a uassertion with an appropriate msg */
     void streamNotGood( int code , string msg , std::ios& myios );
 
-    inline void assertStreamGood(unsigned msgid, string msg, std::ios& myios) { 
+    inline void assertStreamGood(unsigned msgid, string msg, std::ios& myios) {
         if( !myios.good() ) streamNotGood(msgid, msg, myios);
     }
 
@@ -228,15 +191,15 @@ namespace mongo {
 
 #define BOOST_CHECK_EXCEPTION MONGO_BOOST_CHECK_EXCEPTION
 #define MONGO_BOOST_CHECK_EXCEPTION( expression ) \
-	try { \
-		expression; \
-	} catch ( const std::exception &e ) { \
+    try { \
+        expression; \
+    } catch ( const std::exception &e ) { \
         stringstream ss; \
-		ss << "caught boost exception: " << e.what();   \
+        ss << "caught boost exception: " << e.what();   \
         msgasserted( 13294 , ss.str() );        \
-	} catch ( ... ) { \
-		massert( 10437 ,  "unknown boost failed" , false );   \
-	}
+    } catch ( ... ) { \
+        massert( 10437 ,  "unknown boost failed" , false );   \
+    }
 
 #define DESTRUCTOR_GUARD MONGO_DESTRUCTOR_GUARD
 #define MONGO_DESTRUCTOR_GUARD( expression ) \