format.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_FORMAT_HPP
#define LOGICALACCESS_FORMAT_HPP
 
#include <memory>
#include <boost/utility.hpp>
 
#include <logicalaccess/xmlserializable.hpp>
#include <logicalaccess/services/accesscontrol/encodings/datarepresentation.hpp>
#include <logicalaccess/services/accesscontrol/encodings/datatype.hpp>
 
#include <logicalaccess/plugins/llacommon/logs.hpp>
 
#include <logicalaccess/services/accesscontrol/formats/customformat/datafield.hpp>
#include <list>
 
namespace logicalaccess
{
typedef enum {
    FT_UNKNOWN             = 0x00,
    FT_WIEGAND26           = 0x02,
    FT_WIEGAND34           = 0x03,
    FT_WIEGAND34FACILITY   = 0x04,
    FT_WIEGAND37           = 0x05,
    FT_WIEGAND37FACILITY   = 0x06,
    FT_WIEGANDFLEXIBLE     = 0x07, 
    FT_ASCII               = 0x08,
    FT_WIEGAND35           = 0x09,
    FT_DATACLOCK           = 0x0A,
    FT_FASCN200BIT         = 0x0B,
    FT_HIDHONEYWELL        = 0x0C,
    FT_GETRONIK40BIT       = 0x0D,
    FT_BARIUM_FERRITE_PCSC = 0x0E,
    FT_CUSTOM              = 0x10,
    FT_RAW                 = 0xFF
} FormatType;
 
bool LLA_CORE_API FieldSortPredicate(const std::shared_ptr<DataField> &lhs,
                                             const std::shared_ptr<DataField> &rhs);
 
class LLA_CORE_API Format : public XmlSerializable
{
  public:
    Format();
 
    Format(const Format &other) = delete;       // non construction-copyable
    Format &operator=(const Format &) = delete; // non copyable
 
    virtual ~Format() = default;
 
    virtual unsigned int getDataLength() const = 0;
 
    virtual std::string getName() const = 0;
 
    virtual ByteVector getLinearData() const = 0;
 
    virtual void setLinearData(const ByteVector &data) = 0;
 
    virtual size_t getSkeletonLinearData(ByteVector &data) const = 0;
 
    virtual void setSkeletonLinearData(const ByteVector &data) = 0;
 
    virtual FormatType getType() const = 0;
 
    static std::shared_ptr<Format> getByFormatType(FormatType type);
 
    virtual std::vector<std::string> getValuesFieldList() const;
 
    virtual unsigned int getFieldLength(const std::string &field) const;
 
    virtual bool checkSkeleton(std::shared_ptr<Format> format) const = 0;
 
    static unsigned char calculateParity(const BitsetStream &data, ParityType parityType,
                                         std::vector<unsigned int> positions);
 
    virtual ByteVector getIdentifier();
 
    virtual std::vector<std::shared_ptr<DataField>> getFieldList();
 
    virtual void setFieldList(std::vector<std::shared_ptr<DataField>> fields);
 
    std::shared_ptr<DataField> getFieldFromName(std::string field) const;
 
    bool isRepeatable() const;
 
    void setRepeatable(bool v);
 
  protected:
    std::list<std::shared_ptr<DataField>> d_fieldList;
 
    bool is_repeatable_;
};
}
 
#endif /* LOGICALACCESS_FORMAT_HPP */