devatlas.h

#ifndef MOBI_MTLD_DA
#define MOBI_MTLD_DA
#include <mtld/common.h>

#define DA_CONTEXT_HAS_REFINE   1
#define API_MAJOR_VERSION          2
#define API_MINOR_VERSION          3
#define API_REVISION_VERSION       0

/*
 * Copyright (c) DeviceAtlas Limited 2021. All Rights Reserved.
 */

namespace Mobi { namespace Mtld { namespace Da {
using namespace std;
/*
 * Forward declarations of classes.
 */

class Node;
class NodeParse;
class REInfo;
class RuleGroup;
class RuleSet;
class UAR;
class CPR;
struct ChildrenParse;
struct ValueParse;


enum TreeID {
    UA,
    UAPROF,
    TREEID_MAX = 16 // space for 16 trees without having to recompile.
};

enum LangID {
    Default = 0,
    PHP = 1,
    Java = 2,
    DotNET = 3,
    Cplusplus = 4,
    Python = 5,
    Ruby = 6
};

/*
 * Basic information from the Version Descriptor
 */
struct VersionInfo {
    std::string ver;
    std::string gen;
    std::string rev;
    std::string usr;
    std::string tm;
    time_t utc;
};

struct DaConfig {
    bool include_ua_props;
    bool include_lang_props;
    bool include_matched_props;
    DaConfig()
      : include_ua_props(true)
      , include_lang_props(true)
      , include_matched_props(false) {}
    DaConfig(bool include_ua_props_, bool include_lang_props_,
             bool include_matched_props_)
      : include_ua_props(include_ua_props_)
      , include_lang_props(include_lang_props_)
      , include_matched_props(include_matched_props_) {}
};

DA_EXPORT extern const char *languageHeader;
DA_EXPORT extern const char *defaultHeaderTreePriorities[];

struct DA_EXPORT HttpHeaders : public CommonHttpHeaders{
    std::string evidence[TREEID_MAX];
    std::string userlanguage;
    size_t uaindex;
    size_t uajsontreewalk;
    HttpHeaders(const char *userAgent, const char *acceptLanguage = 0);
    HttpHeaders(const HeaderMap & headers, const char ***priorities = defaultHeaderPriorities);
};

typedef std::map<LangID, std::vector<REInfo *> > TaggedRegexMap;
typedef std::map<size_t, std::string> ResetWalkMap;
class DA_EXPORT DeviceAtlas : public CommonDeviceAtlas {
    friend class DAParse;
    friend class NodeParse;
    friend class ReplacementStringParser;
    friend class RuleGroup;
    friend struct CPRParser;
    friend struct RGParser;
    friend struct UARParser;
    friend struct AttrVecParser;
    friend struct CPRulesParser;
    friend struct UAStockParser;
    friend struct ResetWalkParser;
    friend struct DataParse;
    friend struct ValueParse;

    VersionInfo vi;
    const std::vector<REInfo *> *languageReplacementStrings;

    CPR *cpr;
    const Property *propid;
    TaggedRegexMap replacementStrings;
    ResetWalkMap resetWalkStrings;

    vector<string> stockUaFromTree;

    void initAtlas(std::istream &, const char *[]);
    void resetRoots();
    void resetPriorities();

public:
    const Property *getpropId() const { return propid; }

    Node *roots[TREEID_MAX];
    unsigned long flags;
private:
    DaConfig dcfg;
    UAR *uar;
public:
    unsigned maxDepth;
    void doReplacements(const std::vector<size_t> *, char *, size_t) const;

    struct {
        size_t _user_agent_matched;
        size_t _user_agent_unmatched;
        // dynamic language properties
        size_t _language_locale;
        size_t _language;
    } synthetic;

    void setConfig(DaConfig &_dcfg) { dcfg = _dcfg; }
    bool hasUAProps() const { return dcfg.include_ua_props == true; }
    bool hasLangProps() const { return dcfg.include_lang_props == true; }
    bool hasMatchedProps() const { return dcfg.include_matched_props == true; }

    const UAR *getUAR() const { return uar; }
    const CPR *getCPR() const { return cpr; }

    static const char *treeUA[];
    static const char *treeAll[];
    static const char **getTreeUA();
    static const char **getTreeAll();

    enum {
        NoREFold = 1 << 0
      , Debug = 1 << 1
      , OverwriteUnconflicted = 1 << 2
    };
    DeviceAtlas() : CommonDeviceAtlas(), cpr(0), uar(0) { resetRoots(); }
    DeviceAtlas(DaConfig &_dcfg) : CommonDeviceAtlas(), cpr(0), uar(0), dcfg(_dcfg) { resetRoots(); }
    DeviceAtlas(std::istream &, const char *treeFields[] = getTreeUA(), unsigned long flags = 0);
    ~DeviceAtlas();
    void loadDataFromFile(const char *, const char *treeFields[] = getTreeUA(), unsigned long flags = 0);
    void loadDataFromStream(std::istream &, const char *treeFields[] = getTreeUA(), unsigned long flags = 0);
    const Value *getValue(size_t) const;
    const std::string &getResetWalkString(size_t) const;
    int getTreeRevision() const;
    time_t getTreeGeneration() const;
    int getDataRevision() const { return getTreeRevision(); }
    time_t getDataGeneration() const { return getTreeGeneration(); }
};

class LocalProperties;

class DA_EXPORT DeliveryContext : public CommonDeliveryContext {
private:
    Value user_agent_matched;
    Value user_agent_unmatched;
    const DeviceAtlas &da;
    size_t dapropcount;
    size_t dalocalcount;


    bool doConflicts;


    // the node in the atlas where the search terminated.
    const Node *node;
    LocalProperties *localProperties;

    // The number of properties currently in conflict
    unsigned conflictCount;

    // indexed by property: indicates a found-but-conflicted property.
    bool *conflicts;

    void getRulesetWithProps(const char *&uastrng);
    void getRuleset(const char *&uastrng);
    void runRules(const char *txt, const RuleSet &rules);

public:
    // Create a context reflecting the properties of the device
    // identified by the HttpHeaders object.
    DeliveryContext(const DeviceAtlas &da_, const HttpHeaders &);
    ~DeliveryContext();

    const Property &getPropertyDescr(const char *propname, PropertyType *addAs);
    const Property &getPropertyDescr(size_t idx) const;
    void setProperty(const Property &, const Value*);
    void setProperty(size_t, const Value *);
    const Value *findProperty(const Property &p) const;
    const Value *findProperty(size_t) const;

    const DeviceAtlas &getAtlas() const { return da; }

    // Refine the tree with retrieved client-side properties.
    void refine(const std::vector<const Value *> &clientprops);

    // this variant does ad-hoc decoding similar to the other .mobi APIs.
    void refine(const char *cookieprops);
    const Value *findGlobalProperty(size_t) const;
    const Value *findLocalProperty(size_t) const;

    class const_iterator;
    friend class const_iterator;
    class const_iterator {
    public:
        typedef std::pair<const Property *, const Value *> PVPair;
    private:
        const DeliveryContext &props;
        size_t idx;
        size_t propcount;
        friend class DeliveryContext;
        PVPair builtin;
    public:
        const_iterator(const DeliveryContext &props_, size_t idx_);
        const PVPair operator * () const;
        const PVPair *operator -> ();
        const_iterator &operator++();
        bool operator==(const const_iterator &rhs) const;
        bool operator!=(const const_iterator &rhs) const;
    };

    // called for each node during the search, from the find() template on Node
    bool operator()(const Node &cur, char *str, size_t offset);
    // std-style const iterator for all properties.
    const_iterator begin() const;
    const_iterator end() const;
    const_iterator find(const Property &) const;
    const_iterator find(const char *) const;
    size_t size() const;
    size_t totalsize() const;
    bool empty();
    const Value *operator[](const Property &) const;
    const Value *operator[](const char *propname) const;
};

}}}

// pretty-printer for stream output
#endif