StockException.h

Go to the documentation of this file.

#ifndef STOCKEXCEPT_H_
#define STOCKEXCEPT_H_

#include<string>
#include<stdexcept>
#include<iostream>

// all cases need only Exceptions header
#include "../utils/UtilsExceptions.h"
#include "TALibException.h"

class StockException : public std::exception
{
    public :
                // not used but may be useful
        StockException() : std::exception(), mNameStock(), mTimescale(), mIndic(), mStockMsg() {
#ifdef DEBUG_EXCEPT
            std::cout << "Constructor StockException Base with no argument " << std::endl;
#endif
        }
        // here use the message of the caller simply
        StockException( const std::string & namestock );
        // only make an error
        StockException( const std::string & namestock, const std::string & message )
                : std::exception(), mNameStock(namestock), mTimescale(), mIndic(), mStockMsg(message) {}
        StockException( const std::string & namestock, const std::string & tmscl,  const std::string & indicator );

        // could get 2 parameters, already useful, same purpose specify the error message
        //StockException( const std::string &stockname, const std::string &mMsg, const std::string &indic_label = std::string() );
        // could get the exception / and try to dynamic_cast to create the final message

        ~StockException() throw() {}
        std::string GetMessage() const {return mStockMsg;}
        void AddHeaderMessage();
        virtual const char * what() const noexcept {
            // if composition, may want to return the protected mExcept.what()
            return mStockMsg.c_str();
        }
        //virtual const char * what() const noexcept = 0;

    // could have specific getnamestock() in base class
    // shared by all derivatives, can set directly or constructor base
    protected :
        std::string mNameStock;
        std::string mTimescale;
        std::string mIndic;
        std::string mStockMsg;
        // optionally the indicator which makes crash for TALib mainly but not only
        // better if in specialized, but general which indicator crashes
        //ETime mTimescale;

};

// if use multiple derivation, public virtual seems to work, not sure how ??
// maybe only one public derivative
class StockFileError : public virtual StockException, public virtual FileError
{
    public :

        StockFileError ( const std::string & namestock, const FileError & fError );
        StockFileError ( const std::string & namestock, const std::string & tmscl,
                        const std::string & indic_label, const FileError & fError );

        // call to e.what is ambiguous, defined in both base class
        // yes it is need to include, at least for debug
        virtual const char * what() const noexcept {
                //std::cout << "Ambiguous what is overriden in StockFileError " << std::endl;
            return StockException::what();
        }
};

// either a derivative for TALib or a composition...
// a sort of base class for TAlib error
class StockTALibError : public virtual StockException, public virtual TALibException
{
    public :
                // not used
        StockTALibError ( const TALibException & fError ) :
            StockException(), TALibException() {
            std::cout << "Constructor StockTALibError " << std::endl;
            mStockMsg = fError.what();
        }
        StockTALibError ( const std::string & namestock, const std::string & tmscl, const TALibException & fError );
        virtual const char * what() const noexcept {
                return StockException::what();
        }
};

class StockPythonException : public StockException
{
    public :
        StockPythonException ( const std::string & namestock, const std::string & message ) :
          StockException ( namestock ) {
          mStockMsg = "Stock : " + namestock + "\nPythonError : " + message;
        }
        virtual const char * what() const noexcept {
                return StockException::what();
        }
};

#endif //STOCKEXCEPT_H_