devatlas.h

#ifndef DEVATLAS_CPP_H
#define DEVATLAS_CPP_H
#if !defined(APINOCACHE) && !defined(XXH_DATLAS)
#include "import/cache.hpp"
#include "import/lru_cache_policy.hpp"
#define XXH_NAMESPACE DATLAS
#define XXH_IMPLEMENTATION
#define XXH_INLINE_ALL
#if defined(__x86_64__)
#define XXH_VECTOR XXH_SSE2
#elif defined(__aarch64__)
#define XXH_VECTOR XXH_NEON
#endif
#include "import/xxhash.h"
#define XXH_DATLAS
#endif
#include "dac.h"
#include "dadwcurl.h"
#include "dadwarc.h"
#include "ci.h"
#include "util.h"


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

namespace com {
namespace deviceatlas {
namespace da {
    inline size_t
    p_read_fn(void *a, size_t max, char *buf) {
       std::ifstream *s = static_cast<std::ifstream *>(a);
       s->read(buf, max);
       return s->gcount();
    }

    inline da_status_t
    p_setpos_fn(void *a, off_t pos) {
       std::ifstream *s = static_cast<std::ifstream *>(a);
       s->seekg(pos, s->beg);
       return (s->tellg() == -1 ? DA_SYS : DA_OK);
    }

    class DeliveryContext;
    class HttpHeaders;
#if !defined(APINOCACHE)
    using DaCachePair = std::pair<std::map<size_t, PVPair>, std::map<std::string, size_t>>;
    using DaCache = caches::fixed_sized_cache<XXH64_hash_t, DaCachePair, caches::LRUCachePolicy>;
#endif

    constexpr const char *const defaultCl = "DAPROPS";
    static da_property_decl_t defaultep[1] = {{nullptr, da_type_t(0)}};

    struct DeviceDwConfig {
        std::string path;
        std::string url;
        DwProcFn dwproc;
        DwExtractFn dwextract;
        DwNotifyFn dwnotify;
        DwLogFn dwlog;
        DwMode mode;
        dw_config inst;
        DeviceDwConfig(std::string _path = std::string(), std::string _url = std::string(),
            std::chrono::time_point<std::chrono::system_clock> *_sc = nullptr,
            da_property_decl_t *_ep = defaultep, DwProcFn _dwproc = nullptr,
            DwExtractFn _dwextract = nullptr, DwNotifyFn _dwnotify = nullptr,
            DwLogFn _dwlog = nullptr) :
              path(_path)
            , url(_url)
            , dwproc(_dwproc)
            , dwextract(_dwextract)
            , dwnotify(_dwnotify)
            , dwlog(_dwlog)
            , mode(DwNone) {
                if (path != "" && url != "") {
                    mode = DwSgl;
                    if (_sc) {
                        auto time = std::chrono::system_clock::to_time_t(*_sc);
                        gmtime_r(&time, &inst.info.rtm);
                        inst.info.chksum = 1;
                        inst.info.reload = 1;
                        inst.info.datatm = 1;
                        mode = DwSch;
                    }

                    inst.info.url = strdup(url.c_str());
                    inst.info.path = strdup(path.c_str());
                    inst.ep = _ep;

                    if (dwproc)
                        inst.dwproc = *dwproc.target<dw_proc_fn>();
                    else
                        inst.dwproc = curldwproc;
                    if (dwextract)
                        inst.dwextract = *dwextract.target<dw_extract_fn>();
                    else
                        inst.dwextract = dadwextract;
                    if (dwnotify)
                        inst.dwnotify_n = *dwnotify.target<dw_notify_n_fn>();
                    if (dwlog)
                        inst.dwlog = *dwlog.target<dw_log_fn>();
                }
        }
    };

    struct DeviceConfig {
        const char *clname;
        DeviceDwConfig dwcfg;
        da_config inst;
        size_t cache_size;
        DeviceConfig(const char *_clname = defaultCl, size_t _cache_size = 0) :
            clname(_clname), cache_size(_cache_size) { 
                memset(&inst, 0, sizeof(inst));
        }
    };

    class DeviceAtlas : public CommonDeviceAtlas {
        friend class DeliveryContext;
        friend class HttpHeaders;
        size_t len;
        da_dwatlas_t inst;
        DeviceConfig cfg;
#if !defined(APINOCACHE)
        std::shared_ptr<DaCache> ccache;
#endif
    public:
        DeviceAtlas(const DeviceConfig &_cfg = DeviceConfig(), da_read_fn _rfn = &p_read_fn, da_setpos_fn _sfn = &p_setpos_fn) :
            CommonDeviceAtlas()
            , cfg(_cfg) {
            da_init();
            inst.dcfg = cfg.dwcfg.inst;
            inst.rfn = _rfn;
            inst.posfn = _sfn;
#if !defined(APINOCACHE)
            if (cfg.cache_size > 0) {
                if (cfg.cache_size > DA_CACHE_MAX)
                    cfg.cache_size = DA_CACHE_MAX;
                ccache = std::shared_ptr<DaCache>(new DaCache(cfg.cache_size, caches::LRUCachePolicy<XXH64_hash_t>()));
            } else {
                ccache = nullptr;
            }
#endif
        }
        ~DeviceAtlas();
        void loadDataFromFile(const char *) override; 
        void loadDataFromMem(const char *) noexcept(false);
        void download() noexcept(false);
        time_t getDataGeneration() const noexcept;
        std::string getDataGenerationIso8601() const noexcept;
        bool dump(const char *);
        const da_dwatlas_t atlas() { return inst; }
    };

    class HttpHeaders {
        friend class DeviceAtlas;
        friend class DeliveryContext;
        const HeaderMap &map; 
        size_t evl;
        bool set;
#if !defined(APINOCACHE)
        uint64_t h;
#endif
        std::array<da_evidence_t, 64> ev;
    public:
        HttpHeaders(const HttpHeaders &);
        HttpHeaders(const HeaderMap &);
        HttpHeaders(const DeviceAtlas &, const HeaderMap &);
    };

    class DeliveryContext : public CommonDeliveryContext {
        friend class DeviceAtlas;
        friend class HttpHeaders;
        da_deviceinfo_t dv;
        bool lkp;
#if !defined(APINOCACHE)
        std::shared_ptr<DaCache> ccache;
        size_t cache_size;
        uint64_t h;
        std::mutex mtx;
#endif
        std::map<size_t, PVPair> ires;
        void pvpfill() const {
            if (!empty() && vres.size() == 0) {
                size_t i = 0;
                for (auto e = begin(); e != end(); ++e, ++i) {
                    auto it = *e;
                    if (!it.first) {
                        Exception e;
                        e << "invalid property at ";
                        e << i;
                        __throw(e);
                    }
                }
            }
        }
    public:
        DeliveryContext(const DeviceAtlas &, const HttpHeaders &);
        DeliveryContext(const DeviceAtlas &, std::string &id, std::string &cs = emptys);
#if __cplusplus >= 201703L

        DeliveryContext(const DeviceAtlas &, std::string_view id, std::optional<std::string_view> cs);
#endif
        ~DeliveryContext();
        class const_iterator;
        friend class const_iterator;
        size_t sz;

        class const_iterator {
        private:
            DeliveryContext &props;
            size_t idx;
            size_t propcount;
            friend class DeliveryContext;
            PVPair builtin;
            const PVPair propdict() const;
        public:
            const_iterator(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;
        };

        const_iterator begin() const;
        const_iterator end() const;
        const_iterator find(const Property &) const;
        const_iterator find(const char *) const;
        size_t size() const { return sz; }
        bool empty() const { return size() == 0; }
        bool contains(const char *propname) {
            return find(propname) != this->end();
        }
        template<typename T>
        bool contains(const char *propname, const T value) {
            static_assert(std::is_integral<T>::value, "invalid type");
            auto p = find(propname);
            if (p == this->end())
                return false;
            return p->second->u.longval == value;
        }
        const Value *operator[](const Property &) const noexcept;
        const Value *operator[](const char *) const noexcept;
#if __cplusplus >= 201703L

        std::optional<const Value *> operator[](std::string_view) const noexcept;
#endif
    };
    template<>
    inline bool DeliveryContext::contains<const char *>(const char *propname, const char *value) {
        auto p = find(propname);
        if (p == this->end())
            return false;
        return strcmp(p->second->u.strval, value) == 0;
    }
}

namespace ci {
    class DeliveryContext;
    class HttpHeaders;
    struct dropreq {
        void operator()(ci_searchrequest_t *o) const {
            delete []o;
        }
    };

    struct dropres {
        void operator()(ci_searchresult_t *o) const {
            delete []o;
        }
    };

    class Carrier : public CommonDeviceAtlas {
        friend class DeliveryContext;
        friend class HttpHeaders;
        std::shared_ptr<ci_atlas_t> inst;
    public:
        Carrier() : CommonDeviceAtlas()  {
            ci_init();
            auto ptr = new char[ci_atlas_size()];
            inst = std::shared_ptr<ci_atlas_t>(new (ptr) ci_atlas_t, [](ci_atlas_t *o) { delete [] o; });
        }
        ~Carrier();
        void loadDataFromFile(const char *) override; 
    };

    class HttpHeaders {
        friend class Carrier;
        friend class DeliveryContext;
        const HeaderMap &map; 
        std::unique_ptr<ci_searchrequest_t, dropreq> ev;
    public:
        HttpHeaders(const Carrier &, const HeaderMap &);
        ~HttpHeaders();
    };

    class DeliveryContext : public CommonDeliveryContext {
        friend class Carrier;
        friend class HttpHeaders;
        const Carrier &ci;
        std::unique_ptr<ci_searchresult_t, dropres> dv;
        std::map<size_t, PVPairSet> ires;
        void pvpfill() const {
            if (!empty() && vres.size() == 0) {
                size_t i = 0;
                for (auto e = begin(); e != end(); ++e, ++i) {
                    auto it = *e;
                    if (!it.first) {
                        Exception e;
                        e << "invalid property at";
                        e << i;
                        __throw(e);
                    }
                }
            }
        }
    public:
        DeliveryContext(const Carrier &, const HttpHeaders &);
        class const_iterator;
        friend class const_iterator;

        class const_iterator {
        private:
            DeliveryContext &props;
            size_t idx;
            size_t propcount;
            friend class DeliveryContext;
            PVPairSet builtin;
            const PVPairSet propdict() const;
        public:
            const_iterator(DeliveryContext &props_, size_t idx_);
            const PVPairSet operator * () const;
            const PVPairSet *operator -> ();
            const_iterator &operator++();
            bool operator==(const const_iterator &rhs) const;
            bool operator!=(const const_iterator &rhs) const;
        };

        const_iterator begin() const;
        const_iterator end() const;
        const_iterator find(const Property &) const;
        const_iterator find(const char *) const;
        size_t size() const { return set ? ci.inst.get()->property_count : 0; }
        bool empty() const { return size() == 0; }
        bool contains(const char *propname) {
            return find(propname) != this->end();
        }
        const std::string realip() const { return dv->u.ei; }
        const valueset operator[](const Property &) const noexcept;
        const valueset operator[](const char *) const noexcept;
#if __cplusplus >= 201703L

        std::optional<const valueset> operator[](std::string_view) const noexcept;
#endif
    };
}
}
}
#endif