activemq-cpp/src/main/activemq/util/CMSExceptionSupport.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _ACTIVEMQ_UTIL_CMSEXCEPTIONSUPPORT_H_
#define _ACTIVEMQ_UTIL_CMSEXCEPTIONSUPPORT_H_

#include <activemq/util/Config.h>

#include <cms/CMSException.h>
#include <cms/CMSSecurityException.h>
#include <cms/MessageEOFException.h>
#include <cms/MessageFormatException.h>
#include <cms/MessageNotReadableException.h>
#include <cms/MessageNotWriteableException.h>
#include <cms/InvalidClientIdException.h>
#include <cms/InvalidDestinationException.h>
#include <cms/InvalidSelectorException.h>
#include <cms/IllegalStateException.h>
#include <cms/ResourceAllocationException.h>
#include <cms/TransactionInProgressException.h>
#include <cms/TransactionRolledBackException.h>
#include <cms/UnsupportedOperationException.h>
#include <cms/XAException.h>

#include <decaf/lang/Exception.h>

#include <string>

namespace activemq {
namespace util {

    class AMQCPP_API CMSExceptionSupport {
    private:

        CMSExceptionSupport();

    public:

        virtual ~CMSExceptionSupport();

        static cms::CMSException create(const std::string& msg, const decaf::lang::Exception& cause);

        static cms::CMSException create(const decaf::lang::Exception& cause);

        static cms::MessageEOFException createMessageEOFException(const decaf::lang::Exception& cause);

        static cms::MessageFormatException createMessageFormatException(const decaf::lang::Exception& cause);

    };

}}

/**
* Macro for catching an exception of one type and then re-throwing
* as a Basic CMSException, good for cases where the method isn't specific
* about what CMS Exceptions are thrown, bad if you need to throw an
* exception of MessageNotReadableException for instance.
*/
#define AMQ_CATCH_ALL_THROW_CMSEXCEPTION() \
    catch (cms::CMSSecurityException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::IllegalStateException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::InvalidClientIdException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::InvalidDestinationException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::InvalidSelectorException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::MessageEOFException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::MessageFormatException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::MessageNotReadableException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::MessageNotWriteableException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::ResourceAllocationException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::TransactionInProgressException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::TransactionRolledBackException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::UnsupportedOperationException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::XAException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (cms::CMSException& ex) { \
        ex.setMark(__FILE__, __LINE__); \
        throw; \
    } catch (activemq::exceptions::ActiveMQException& ex) { \
        if (ex.getCause() != NULL) { \
            const std::exception* cause = ex.getCause(); \
            { \
                const cms::CMSSecurityException* exception = \
                    dynamic_cast<const cms::CMSSecurityException*>(cause); \
                if (exception != NULL) { \
                    throw cms::CMSSecurityException(*exception); \
                } \
            } \
            { \
                const cms::IllegalStateException* exception = \
                    dynamic_cast<const cms::IllegalStateException*>(cause); \
                if (exception != NULL) { \
                    throw cms::IllegalStateException(*exception); \
                } \
            } \
            { \
                const cms::InvalidClientIdException* exception = \
                    dynamic_cast<const cms::InvalidClientIdException*>(cause); \
                if (exception != NULL) { \
                    throw cms::InvalidClientIdException(*exception); \
                } \
            } \
            { \
                const cms::InvalidDestinationException* exception = \
                    dynamic_cast<const cms::InvalidDestinationException*>(cause); \
                if (exception != NULL) { \
                    throw cms::InvalidDestinationException(*exception); \
                } \
            } \
            { \
                const cms::InvalidSelectorException* exception = \
                    dynamic_cast<const cms::InvalidSelectorException*>(cause); \
                if (exception != NULL) { \
                    throw cms::InvalidSelectorException(*exception); \
                } \
            } \
            { \
                const cms::MessageEOFException* exception = \
                    dynamic_cast<const cms::MessageEOFException*>(cause); \
                if (exception != NULL) { \
                    throw cms::MessageEOFException(*exception); \
                } \
            } \
            { \
                const cms::MessageFormatException* exception = \
                    dynamic_cast<const cms::MessageFormatException*>(cause); \
                if (exception != NULL) { \
                    throw cms::MessageFormatException(*exception); \
                } \
            } \
            { \
                const cms::MessageNotReadableException* exception = \
                    dynamic_cast<const cms::MessageNotReadableException*>(cause); \
                if (exception != NULL) { \
                    throw cms::MessageNotReadableException(*exception); \
                } \
            } \
            { \
                const cms::MessageNotWriteableException* exception = \
                    dynamic_cast<const cms::MessageNotWriteableException*>(cause); \
                if (exception != NULL) { \
                    throw cms::MessageNotWriteableException(*exception); \
                } \
            } \
            { \
                const cms::ResourceAllocationException* exception = \
                    dynamic_cast<const cms::ResourceAllocationException*>(cause); \
                if (exception != NULL) { \
                    throw cms::ResourceAllocationException(*exception); \
                } \
            } \
            { \
                const cms::TransactionInProgressException* exception = \
                    dynamic_cast<const cms::TransactionInProgressException*>(cause); \
                if (exception != NULL) { \
                    throw cms::TransactionInProgressException(*exception); \
                } \
            } \
            { \
                const cms::TransactionRolledBackException* exception = \
                    dynamic_cast<const cms::TransactionRolledBackException*>(cause); \
                if (exception != NULL) { \
                    throw cms::TransactionRolledBackException(*exception); \
                } \
            } \
            { \
                const cms::UnsupportedOperationException* exception = \
                    dynamic_cast<const cms::UnsupportedOperationException*>(cause); \
                if (exception != NULL) { \
                    throw cms::UnsupportedOperationException(*exception); \
                } \
            } \
            { \
                const cms::XAException* exception = \
                    dynamic_cast<const cms::XAException*>(cause); \
                if (exception != NULL) { \
                    throw cms::XAException(*exception); \
                } \
            } \
            { \
                const cms::CMSException* exception = \
                    dynamic_cast<const cms::CMSException*>(cause); \
                if (exception != NULL) { \
                    throw cms::CMSException(*exception); \
                } \
            } \
        } \
        ex.setMark(__FILE__, __LINE__); \
        throw ex.convertToCMSException(); \
    } catch(decaf::lang::Exception& ex){ \
        ex.setMark(__FILE__, __LINE__); \
        activemq::exceptions::ActiveMQException amqEx(ex); \
        throw amqEx.convertToCMSException(); \
    } catch(std::exception& ex){ \
        throw cms::CMSException(ex.what(), NULL); \
    } catch(...) { \
        throw cms::CMSException("Caught Unknown Exception", NULL); \
    }

#endif /* _ACTIVEMQ_UTIL_CMSEXCEPTIONSUPPORT_H_ */