CommonSignatureComputationDataAdapter.h

Go to the documentation of this file.

/**************************************************************************************************
 * Copyright (c) 2022 Calypso Networks Association https://calypsonet.org/                        *
 *                                                                                                *
 * See the NOTICE file(s) distributed with this work for additional information regarding         *
 * copyright ownership.                                                                           *
 *                                                                                                *
 * This program and the accompanying materials are made available under the terms of the Eclipse  *
 * Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0                  *
 *                                                                                                *
 * SPDX-License-Identifier: EPL-2.0                                                               *
 **************************************************************************************************/
 
#pragma once
 
/* Calypsonet Terminal Calypso */
#include "CommonSignatureComputationData.h"
 
/* Keyple Core Util */
#include "IllegalStateException.h"
 
namespace keyple {
namespace card {
namespace calypso {
 
using namespace calypsonet::terminal::calypso::transaction;
using namespace keyple::core::util::cpp::exception;
 
template <typename T>
class CommonSignatureComputationDataAdapter : virtual public CommonSignatureComputationData<T> {
public:
    T& setData(const std::vector<uint8_t>& data, const uint8_t kif, const uint8_t kvc) override
    {
        mData = data;
        mKif = kif;
        mKvc = kvc;
 
        return dynamic_cast<T&>(*this);
    }
 
    T& setSignatureSize(const int size) override
    {
        mSignatureSize = size;
 
        return dynamic_cast<T&>(*this);
    }
 
    T& setKeyDiversifier(const std::vector<uint8_t>& diversifier) override
    {
        mKeyDiversifier = diversifier;
        mIsKeyDiversifierSet = true;
 
        return dynamic_cast<T&>(*this);
    }
 
    const std::vector<uint8_t>& getSignature() const override
    {
        if (!mSignatureProcessed) {
            throw IllegalStateException("The command has not yet been processed");
        }
 
        return mSignature;
    }
 
    virtual const std::vector<uint8_t>& getData() const
    {
        return mData;
    }
 
 
    virtual uint8_t getKif() const
    {
        return mKif;
    }
 
    virtual uint8_t getKvc() const
    {
        return mKvc;
    }
 
    virtual int getSignatureSize() const
    {
        return mSignatureSize;
    }
 
    virtual void setSignature(const std::vector<uint8_t>& signature)
    {
        mSignature = signature;
        mSignatureProcessed = true;
    }
 
    virtual const std::vector<uint8_t>& getKeyDiversifier() const
    {
        return mKeyDiversifier;
    }
 
    bool isKeyDiversifierSet() const
    {
        return mIsKeyDiversifierSet;
    }
 
private:
    std::vector<uint8_t> mData;
 
    uint8_t mKif;
 
    uint8_t mKvc;
 
    int mSignatureSize = 8;
 
    std::vector<uint8_t> mKeyDiversifier;
 
    bool mIsKeyDiversifierSet = false;
 
    std::vector<uint8_t> mSignature;
 
    bool mSignatureProcessed = false;
};
 
}
}
}