BadPixelHandler.h

Go to the documentation of this file.

#ifndef BADPIXELHANDLER_H
#define BADPIXELHANDLER_H
 
#include "AbstractHandler.h"
 
namespace SocCamera {
 
template <typename BprCoreProvider>
class tcBadPixelHandler : public tcAbstractHandler
{
public:
    tcBadPixelHandler(BprCoreProvider *apSensor,
                      tcAbstractHandler *apNextHandler = NULL, std::map<std::string, tcAbstractHandler*> *apMap = NULL)
        : tcAbstractHandler(nullptr, apNextHandler)
        , mpBpr(apSensor)
    {
        if(apMap) {
            (*apMap)["SBPR"] = this;
            (*apMap)["GBPR"] = this;
            (*apMap)["SBPRM"] = this;
            (*apMap)["GBPRM"] = this;
        }
    }
 
    enum teOperation {
        eeGetM,
        eeSetM,
        eeGet,
        eeSet
    };
 
    virtual std::string execute(std::string& arCommandString,
        std::string& arParameters) {
        std::string retVal;
        teOperation type;
        int32 value;
        teNackCode rv = eeNoError;
 
        if (arCommandString == "SBPR") {
            type = eeSet;
        } else if (arCommandString == "GBPR") {
            type = eeGet;
        } else if (arCommandString == "SBPRM") {
            type = eeSetM;
        } else if (arCommandString == "GBPRM") {
            type = eeGetM;
        } else {
            return tcAbstractHandler::execute(arCommandString, arParameters);
        }
 
        tcStringTokenizer strtok(arParameters);
        switch (type) {
        case eeSet:
        case eeSetM:
            if (strtok.hasNext()) {
                if (!strtok.nextInt(&value)) {
                    rv = eeArgumentOutOfRange;
                }
            } else {
                rv = eeArgumentMissing;
            }
            break;
        default:
            break;
        }
 
        // Execute the operation if there wasn't a problem parsing input.
        rv = (rv == eeNoError ? this->execute(type, value) : rv);
        std::string str = carrotNumber(value);
        if (rv == eeNoError) {
            switch (type) {
            case eeGet:
            case eeGetM:
                retVal = ack(&str);
                break;
            default:
                retVal = ack();
                break;
            }
        } else {
            retVal = nack(rv);
        }
 
        return retVal;
    }
 
    virtual teNackCode execute(teOperation aeOp, int32 &arValue) {
        switch(aeOp) {
        case eeGetM:
            arValue = mpBpr->mapState();
            break;
        case eeSetM:
            mpBpr->setMapState(arValue);
            break;
        case eeGet:
            arValue = mpBpr->onState();
            break;
        case eeSet:
            if(!arValue) {
                mpBpr->setData("");
            } else {
                mpBpr->setData(mpBpr->defaultData());
            }
            break;
        }
 
        return eeNoError;
    }
 
    void update(tsUpdate asMessage) {
        tcRegUpdateMsg* pmsg = (tcRegUpdateMsg*) asMessage.mpMessage;
        tcRegUpdateUint32Msg* pu32msg = (pmsg->m_regtype == eeRegUint32) ? (tcRegUpdateUint32Msg*) pmsg : NULL;
        teNackCode ncode = eeNoError;
 
        if (pu32msg != NULL)
        {
            switch (pmsg->m_address)
            {
            default:
                return;
 
            case BAD_PIXEL_CTRL_MAP_ADDR:
                mpBpr->setMapState(pu32msg->m_newval);
                break;
            case BAD_PIXEL_CTRL_ADDR:
                if(!pu32msg->m_newval) {
                    mpBpr->setData("");
                } else {
                    mpBpr->setData(mpBpr->defaultData());
                }
                break;
            }
 
            switch (ncode)
            {
            case eeNoError:
                break;
 
            case eeOperationNotSupported:
                pu32msg->m_status = GEV_STATUS_NOT_IMPLEMENTED;
                pu32msg->m_fixval = pu32msg->m_oldval;
                break;
 
            case eeArgumentOutOfRange:
                pu32msg->m_status = GEV_STATUS_INVALID_PARAMETER;
                pu32msg->m_fixval = pu32msg->m_oldval;
                break;
 
            case eeCaptureInProgress:
                pu32msg->m_status = GEV_STATUS_BUSY;
                pu32msg->m_fixval = pu32msg->m_oldval;
                break;
 
            default:
                pu32msg->m_status = GEV_STATUS_ERROR;
                pu32msg->m_fixval = pu32msg->m_oldval;
                break;
            }
            pmsg->m_handled = true;
        }
    }
 
private:
    BprCoreProvider* mpBpr;
 
};
 
}
 
#endif // BADPIXELHANDLER_H