AbstractDataProviderRecordIterator.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
// assume local scope for variables, do not use "$" signs
// require type definitions everywhere
// enable all warnings
 
namespace DataProvider {
const DP_OP_AND = "AND";
 
const DP_OP_OR = "OR";
 
 
const DP_SEARCH_OP_REGEX = "regex";
 
 
const DP_SEARCH_OP_LT = "<";
 
 
const DP_SEARCH_OP_LE = "<=";
 
 
const DP_SEARCH_OP_GT = ">";
 
 
const DP_SEARCH_OP_GE = ">=";
 
 
const DP_SEARCH_OP_NE = "!=";
 
 
const DP_SEARCH_OP_EQ = "=";
 
 
const DP_SEARCH_OP_BETWEEN = "between";
 
 
const DP_SEARCH_OP_IN = "in";
 
 
const DP_SEARCH_OP_NOT = "not";
 
public hashdecl SearchOperatorInfo {
    string op;   
    auto arg;    
};
 
const DefaultGenericSearchOpMap = {
    DP_SEARCH_OP_REGEX: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return regex(field_value.toString(), cmd.arg.pattern, cmd.arg.options);
        },
    ),
    DP_SEARCH_OP_LT: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value < cmd.arg;
        },
    ),
    DP_SEARCH_OP_LE: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value <= cmd.arg;
        },
    ),
    DP_SEARCH_OP_GT: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value > cmd.arg;
        },
    ),
    DP_SEARCH_OP_GE: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value >= cmd.arg;
        },
    ),
    DP_SEARCH_OP_NE: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value != cmd.arg;
        },
    ),
    DP_SEARCH_OP_EQ: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value == cmd.arg;
        },
    ),
    DP_SEARCH_OP_BETWEEN: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return field_value >= cmd.arg[0] && field_value <= cmd.arg[1];
        },
    ),
    DP_SEARCH_OP_IN: (
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return cmd.arg ? (cmd.arg{field_value} ?? False) : !field_value.val();
        },
    ),
    DP_SEARCH_OP_NOT: (
        "recursive": True,
        "code": bool sub (hash<auto> cmd, auto field_value, string field_name, hash<auto> rec) {
            return !field_value;
        },
    ),
};
 
 hash<SearchOperatorInfo> dp_make_op(string op, auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_regex(string str);
 
 
 
 hash<SearchOperatorInfo> dp_op_like(string str);
 
 
 
 hash<SearchOperatorInfo> dp_op_lt(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_le(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_gt(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_ge(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_ne(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_eq(auto arg);
 
 
 
 hash<SearchOperatorInfo> dp_op_between(auto l, auto r);
 
 
 
 hash<SearchOperatorInfo> dp_op_in();
 
 
 
 hash<SearchOperatorInfo> dp_op_in(list<auto> args);
 
 
 
 hash<SearchOperatorInfo> dp_op_not(hash<auto> arg);
 
 
 
class AbstractDataProviderRecordIterator : public AbstractIterator {
 
public:
 
    bool supportsBulkApi();
 
 
 
    *AbstractDataProviderBulkRecordInterface getBulkApi();
 
 
 
    *hash<string, AbstractDataField> getRecordType();
 
 
 
    abstract hash<auto> getValue();
 
 
protected:
     auto doMemberGate(string key);
public:
 
 
 
protected:
      static bool matchGeneric(hash<auto> record, hash<DataProviderExpression> where_cond);
public:
 
 
 
protected:
      static bool matchGeneric(hash<auto> record, *hash<auto> where_cond);
public:
 
 
protected:
      static bool evalOperator(string field, hash<auto> cmd, hash<auto> op, hash<auto> record);
public:
 
 
 
protected:
      static bool matchGenericValue(auto expects, auto val);
public:
 
};
};