Validators.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#include "DataRecord.h"
 
namespace ColumnStore {
class RecordValidatorInterface {
   public:
    virtual bool validate(DataRecord &record) { return true; }
 
    virtual ~RecordValidatorInterface(){};
};
 
typedef std::shared_ptr<RecordValidatorInterface> RecordValidator;
 
class ReccordValidatorMetadataInterface : public RecordValidatorInterface {
   protected:
    Metadata metadata;
 
   public:
    ReccordValidatorMetadataInterface(Metadata metadata) : metadata(metadata) {}
};
 
class NotRecordValidator : public RecordValidatorInterface {
    RecordValidator condition;
 
   public:
    NotRecordValidator(RecordValidator condition) : condition(condition) {}
 
    bool validate(DataRecord &record) { return !condition->validate(record); }
};
 
class AndRecordValidator : public RecordValidatorInterface {
    RecordValidator validator1;
    RecordValidator validator2;
 
   public:
    AndRecordValidator(RecordValidator validator1, RecordValidator validator2)
        : validator1(validator1), validator2(validator2) {}
 
    bool validate(DataRecord &record) {
        return validator1->validate(record) && validator2->validate(record);
    }
};
 
class OrRecordValidator : public RecordValidatorInterface {
    RecordValidator validator1;
    RecordValidator validator2;
 
   public:
    OrRecordValidator(RecordValidator validator1, RecordValidator validator2)
        : validator1(validator1), validator2(validator2) {}
 
    bool validate(DataRecord &record) {
        return validator1->validate(record) || validator2->validate(record);
    }
};
 
class EqualRecordValidator : public ReccordValidatorMetadataInterface {
    int columnIndex;
    std::any value;
    DataType dataType;
 
   public:
    EqualRecordValidator(std::string columnName, std::any value,
                         Metadata _metadata)
        : ReccordValidatorMetadataInterface(_metadata), value(value) {
        auto &metadata = *(this->metadata.get());
        columnIndex = metadata[columnName].index;
        dataType = metadata[columnName].type;
    }
 
    bool validate(DataRecord &record) {
        if (dataType == DataType::INT) {
            return std::any_cast<int>(value) == record[columnIndex].as<int>();
        } else if (dataType == DataType::FLOAT) {
            return std::any_cast<float>(value) ==
                   record[columnIndex].as<float>();
        } else if (dataType == DataType::STRING) {
            return std::any_cast<std::string>(value) ==
                   record[columnIndex].as<std::string>();
        }
 
        throw "Unknown DataType";
    }
};
 
class LessThanRecordValidator : public ReccordValidatorMetadataInterface {
    int columnIndex;
    std::any value;
    DataType dataType;
 
   public:
    LessThanRecordValidator(std::string columnName, std::any value,
                            Metadata _metadata)
        : ReccordValidatorMetadataInterface(_metadata), value(value) {
        columnIndex = metadata->operator[](columnName).index;
        dataType = (*metadata)[columnName].type;
    }
 
    bool validate(DataRecord &record) {
        if (dataType == DataType::INT) {
            return std::any_cast<int>(value) > record[columnIndex].as<int>();
        } else if (dataType == DataType::FLOAT) {
            return std::any_cast<float>(value) >
                   record[columnIndex].as<float>();
        } else if (dataType == DataType::STRING) {
            return std::any_cast<std::string>(value) >
                   record[columnIndex].as<std::string>();
        }
 
        throw "Unknown DataType";
    }
};
};  // namespace ColumnStore