UT/UT_ErrorManager.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      ramin & dale
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_ErrorManager.h (Utility library)
 *
 * COMMENTS:
 *              This class implements an error manager which will
 *              manage a list of error messages.
 *              NOTE: It assumes ownership of the errors that it is givin.
 *
 */

#ifndef __UT_ErrorManager_h__
#define __UT_ErrorManager_h__

#include "UT_API.h"
#include "UT_Error.h"
#include "UT_PtrArray.h"
#include <fstream.h>

typedef UT_PtrArray<UT_Error *> UT_ErrorList;

class UT_API UT_ErrorManager
{
    enum {
        FLAG_ERRORS_READ = 0x01,
        FLAG_SCAN_NEEDED = 0x02,
        FLAG_DISABLED    = 0x04,
        FLAG_DEADLOCK    = 0x08,
    };

public:
    UT_ErrorManager();
   ~UT_ErrorManager();

    UT_ErrorSeverity addMessage (const char *type, int code, const char *msg=0);
    UT_ErrorSeverity addPrompt  (const char *type, int code, const char *msg=0);
    UT_ErrorSeverity addWarning (const char *type, int code, const char *msg=0);
    UT_ErrorSeverity addError   (const char *type, int code, const char *msg=0);
    UT_ErrorSeverity addFatal   (const char *type, int code, const char *msg=0);
    UT_ErrorSeverity systemError(const char *msg=0);
    UT_ErrorSeverity commonWarning(UT_CommonErrorCode what, const char *msg=0);
    UT_ErrorSeverity commonError(UT_CommonErrorCode what, const char *msg=0);

    UT_ErrorSeverity addDeadlockError();

    UT_ErrorSeverity addGeneric(const char *type, int code, const char *msg,
                                UT_ErrorSeverity sev);

    void        clearAndDestroyErrors();

    int         getNumErrors() const    { return myList.entries(); }

    int         stealErrors(UT_ErrorManager &victim, 
                            int rangestart = 0, int rangeend = -1,
                            UT_ErrorSeverity severity = UT_ERROR_NONE,
                            bool borrow_only = false);

    int         removeError(int index);
    int         findError(const char *type, int code) const;

//  passing in a severity of NONE will return all errors
//
    int         getErrorMessages(UT_String &messages, 
                                 UT_ErrorSeverity severity = UT_ERROR_NONE,
                                 int headerflag=1);

//  Returns the worst error state
//
    UT_ErrorSeverity    getSeverity()
                        {
                            if( getNeedScan() )
                                computeSeverity();
                            return mySeverity;
                        }

//  This is for backward compatibility: use "getSeverity" !!!
    UT_ErrorSeverity    getErrorState() { return getSeverity(); }

    void                pruneDuplicates(); 

    bool                isDisabled() const
                        {
                            return ((myFlags & FLAG_DISABLED) != 0);
                        }
    void                setDisabled(bool f)
                        {
                            if (f)
                                myFlags |=  FLAG_DISABLED;
                            else
                                myFlags &= ~FLAG_DISABLED;
                        }

    UT_ErrorSeverity    updateSeverity(UT_ErrorSeverity sev)
                        {
                            if (sev > mySeverity)
                                mySeverity = sev;
                            return mySeverity;
                        }

    bool                hasDeadlockError() const
                        {
                            return ((myFlags & FLAG_DEADLOCK) != 0);
                        }

protected:
    void                setReadFlag(int state);
    int                 getReadFlag() const
                        {
                            return (myFlags & FLAG_ERRORS_READ) != 0;
                        }

    void                setNeedScan(int state);
    int                 getNeedScan() const
                        {
                            return (myFlags & FLAG_SCAN_NEEDED) != 0;
                        }

    void                setDeadlockError(bool onoff)
                        {
                            if (onoff)
                                myFlags |=  FLAG_DEADLOCK;
                            else
                                myFlags &= ~FLAG_DEADLOCK;
                        }

private:

    static const int    MAX_ERRORS_KEPT = 40;   // Max when doing regular add
    static const int    MAX_ERRORS_STEAL = 400; // Max errors when stealing 

    UT_ErrorSeverity    append(UT_Error *error,
                               int max_errors = MAX_ERRORS_KEPT,
                               bool log = true);

    void                computeSeverity();

    UT_ErrorList        myList;
    UT_ErrorSeverity    mySeverity;
    char                myFlags;
};

UT_API UT_ErrorManager  *UTgetErrorManager();
UT_API UT_ErrorManager  *UTgetErrorManager(int thraed);
UT_API void              UTpushErrorManager();
UT_API void              UTpushErrorManager(int thread);
UT_API void              UTpopErrorManager();
UT_API void              UTpopErrorManager(int thread);

UT_API UT_ErrorSeverity UTaddWarning(const char *type, int code,
                                     const char *msg=0);
UT_API UT_ErrorSeverity UTaddPrompt(const char *type, int code,
                                     const char *msg=0);
UT_API UT_ErrorSeverity UTaddMessage(const char *type, int code,
                                     const char *msg=0);
UT_API UT_ErrorSeverity UTaddError  (const char *type, int code,
                                     const char *msg=0);
UT_API UT_ErrorSeverity UTaddFatal  (const char *type, int code,
                                     const char *msg=0);
UT_API UT_ErrorSeverity UTaddSystemError(const char *msg=0);
UT_API UT_ErrorSeverity UTaddCommonWarning(UT_CommonErrorCode what,
                                           const char *msg=0);
UT_API UT_ErrorSeverity UTaddCommonError(UT_CommonErrorCode what,
                                         const char *msg=0);
UT_API UT_ErrorSeverity UTaddDeadlockError();

UT_API int              UTfindError(const char *type, int code);

UT_API UT_ErrorSeverity UTgetErrorSeverity();

UT_API int       UTcheckOutStream(ostream &os, const char *m, const char *path=0);
#endif

---