chip.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_CHIP_HPP
#define LOGICALACCESS_CHIP_HPP
 
#include <memory>
#include <vector>
#include <logicalaccess/cards/ichip.hpp>
#include <logicalaccess/lla_fwd.hpp>
#include <logicalaccess/lla_core_api.hpp>
#include <logicalaccess/services/cardservice.hpp>
 
namespace logicalaccess
{
#define CHIP_UNKNOWN "UNKNOWN"
#define CHIP_GENERICTAG "GenericTag"
 
typedef enum {
    CPS_NO_POWER   = 0x00, 
    CPS_UNKNOWN    = 0x01, 
    CPS_POWER_LOW  = 0x02, 
    CPS_POWER_HIGH = 0x03  
} ChipPowerStatus;
 
class LLA_CORE_API Chip : public IChip, public std::enable_shared_from_this<Chip>
{
  public:
    Chip();
 
    explicit Chip(std::string cardtype);
 
    virtual ~Chip()
    {
    }
 
    const std::string &getCardType() const override;
 
    std::string getGenericCardType() const override;
 
    virtual std::shared_ptr<LocationNode> getRootLocationNode();
 
    std::shared_ptr<Commands> getCommands() const override
    {
        return d_commands;
    }
 
    void setCommands(std::shared_ptr<Commands> commands)
    {
        d_commands = commands;
    }
 
    ByteVector getChipIdentifier() const override
    {
        return d_chipIdentifier;
    }
 
    virtual void setChipIdentifier(ByteVector identifier)
    {
        d_chipIdentifier = identifier;
    }
 
    ChipPowerStatus getPowerStatus() const
    {
        return d_powerStatus;
    }
 
    void setPowerStatus(ChipPowerStatus powerStatus)
    {
        d_powerStatus = powerStatus;
    }
 
    unsigned char getReceptionLevel() const
    {
        return d_receptionLevel;
    }
 
    void setReceptionLevel(unsigned char receptionLevel)
    {
        d_receptionLevel = receptionLevel;
    }
 
    virtual std::shared_ptr<AccessInfo> createAccessInfo() const;
 
    virtual std::shared_ptr<Location> createLocation() const;
 
    std::shared_ptr<CardService> getService(CardServiceType serviceType) override;
 
    template<typename T>
    std::shared_ptr<T> getService() {
        return std::dynamic_pointer_cast<T>(getService(T::service_type_));
    }
 
    bool operator<(const Chip &chip) const
    {
        return d_receptionLevel < chip.getReceptionLevel();
    }
 
  protected:
    std::string d_cardtype;
 
    ByteVector d_chipIdentifier;
 
    ChipPowerStatus d_powerStatus;
 
    std::shared_ptr<Commands> d_commands;
 
    unsigned char d_receptionLevel;
};
}
 
#endif /* LOGICALACCESS_CHIP_H */