error_map.hxx

Go to the documentation of this file.

#ifndef ERROR_MAP_HXX
#define ERROR_MAP_HXX

// @<COPYRIGHT_START>@
// ===============================================
// Copyright 2006 UGS Corp. All Rights Reserved.
// ===============================================
// @<COPYRIGHT_END>@

#include <base_utils/TcBaseTypes.hxx>
#include <error.h>

#include <base_utils/SharedPtr.hxx>
#include <base_utils/ErrorStoreBase.hxx>
#include <tc/tc_startup.h>

#include <fclasses/libfclasses_exports.h>

class IFail;
class ResultStatus;
class status_t;

// \ref doxygen_namespace_bug
namespace Teamcenter
{
class Error;
class ExceptionPolicy;

// Implementation details.
namespace Private
{
FCLASSES_API Error takeErrorStack( int ifail );
FCLASSES_API Error takeErrorStack( IFail const& ifail );
FCLASSES_API Error takeErrorStack( status_t const& status );

FCLASSES_API Error readErrorStack( int ifail );

FCLASSES_API Error pushErrorStack( int ifail, const char *s1=0, const char *s2=0, const char *s3=0, const char *s4=0, const char *s5=0, const char *s6=0, const char *s7=0 );
}

class FCLASSES_API Error
{
public:
    inline Error();
    inline ~Error();
    // Default copy and assign.
    // Error( Error const& );
    // Error& operator=( Error const& );

    inline bool isOk() const;
    inline bool isError() const;

    inline int ifail() const;
    inline std::string errorMessage() const;
    operator ResultStatus() const;

private:
    friend Error Teamcenter::Private::takeErrorStack( int ifail );
    friend Error Teamcenter::Private::takeErrorStack( IFail const& ifail );
    friend Error Teamcenter::Private::takeErrorStack( status_t const& status );

    friend Error Teamcenter::Private::readErrorStack( int ifail );
    friend Error Teamcenter::Private::pushErrorStack( int ifail, const char *s1, const char *s2, const char *s3, const char *s4, const char *s5, const char *s6, const char *s7 );

    inline explicit Error( int ifail );

    int m_ifail;
    std::string m_errorMessage;
};

class FCLASSES_API ErrorMap
{
public:
    inline ErrorMap();

    // Copy and assign.
    inline ErrorMap( ErrorMap const& );
    inline ErrorMap& operator=( ErrorMap const& );

    ErrorMap& add( size_t id, Error const& error );
    inline ErrorMap& add( size_t id, int ifail );
    inline ErrorMap& add( size_t id, IFail const& ifail );
    inline ErrorMap& add( size_t id, status_t const& status );
    ErrorMap& operator+=( ErrorMap const& right );

    typedef size_t key_type;
    typedef Error mapped_type;
    typedef StdSmMap< size_t, Error >::Map::value_type value_type;

    typedef StdSmMap< size_t, Error >::Map::iterator iterator;
    typedef StdSmMap< size_t, Error >::Map::const_iterator const_iterator;

    inline size_t size() const;
    inline bool empty() const;

    iterator find( size_t id );
    const_iterator find( size_t id ) const;

    inline iterator begin();
    inline iterator end();
    inline const_iterator begin() const;
    inline const_iterator end() const;

private:
    typedef StdSmMap< size_t, Error >::Map StdErrorMap;

    inline StdErrorMap& ensureMap();

    shared_ptr< StdErrorMap > m_map;

    StdErrorMap m_emptyMap;
};

class FCLASSES_API ExceptionPolicy
{
public:
    ExceptionPolicy();
    explicit ExceptionPolicy( bool throwOnError );
    ~ExceptionPolicy();

    static bool throwOnError();

private:
    // Prohibit copy and assign.
    ExceptionPolicy( ExceptionPolicy const& );
    ExceptionPolicy& operator=( ExceptionPolicy const& );

    bool m_setThrowOnError;

    static bool s_throwOnError;
    static bool s_overrideThrowOnError;
    friend class IgnoreExceptionPolicy;
};

class FCLASSES_API IgnoreExceptionPolicy
{
public:
    IgnoreExceptionPolicy();
    ~IgnoreExceptionPolicy();
};


inline Error::Error()
: m_ifail( ITK_ok ), m_errorMessage()
{
}

inline Error::~Error()
{
    // Required to prevent warnings in std::vector-on-sm template compilation
    // with msvc7.1 compiler.
}

inline Error::Error( int ifail )
: m_ifail( ifail ), m_errorMessage()
{
    if ( ifail != ITK_ok )
    {
        m_errorMessage = Teamcenter::ErrorStoreBase::getInstance().ask_last_message( ifail ); // ifail must already been in ERROR_store
    }
}

inline bool Error::isOk() const
{
    return m_ifail == ITK_ok;
}

inline bool Error::isError() const
{
    return m_ifail != ITK_ok;
}

inline int Error::ifail() const
{
    return m_ifail;
}

inline std::string Error::errorMessage() const
{
    return m_errorMessage;
}

inline ErrorMap::ErrorMap()
: m_map(),
  m_emptyMap()
{
}

inline ErrorMap::ErrorMap( ErrorMap const& errorMap )
: m_map( errorMap.m_map ),
  m_emptyMap()
{
}

inline ErrorMap& ErrorMap::operator=( ErrorMap const& errorMap )
{
    // Deliberately not checking for self-assignment.
    // Exception-safe classes rarely need to whatever QAZ says.
    m_map = errorMap.m_map;
    // No need to copy m_emptyMap.  They are both empty!
    return *this;
}

inline ErrorMap& ErrorMap::add( size_t id, int ifail )
{
    return add( id, Teamcenter::Private::takeErrorStack( ifail ) );
}

inline ErrorMap& ErrorMap::add( size_t id, IFail const& ifail )
{
    return add( id, Teamcenter::Private::takeErrorStack( ifail ) );
}

inline ErrorMap& ErrorMap::add( size_t id, status_t const& status )
{
    return add( id, Teamcenter::Private::takeErrorStack( status ) );
}

inline size_t ErrorMap::size() const
{
    if ( m_map )
        return m_map->size();
    else
        return 0;
}
inline bool ErrorMap::empty() const
{
    if ( m_map )
        return m_map->empty();
    else
        return true;
}

inline ErrorMap::iterator ErrorMap::begin()
{
    if ( m_map )
        return m_map->begin();
    else
        return m_emptyMap.begin();
}

inline ErrorMap::iterator ErrorMap::end()
{
    if ( m_map )
        return m_map->end();
    else
        return m_emptyMap.end();
}

inline ErrorMap::const_iterator ErrorMap::begin() const
{
    if ( m_map )
        return m_map->begin();
    else
        return m_emptyMap.begin();
}

inline ErrorMap::const_iterator ErrorMap::end() const
{
    if ( m_map )
        return m_map->end();
    else
        return m_emptyMap.end();
}
}  // namespace Teamcenter
#include <fclasses/libfclasses_undef.h>
#endif