common.h

#ifndef MOBI_MTLD_COMMON
#define MOBI_MTLD_COMMON
#include <string>
#include <limits.h> // need the macros rather than C++ numeric_limits so we can use as template args.
#include <float.h>
#include <set>
#include <ctype.h>
#include <string.h>
#include <map>
#include <functional>
#include <sys/types.h>
#include <vector>
#include <time.h>
#include <mtld/util.h>
#include <mtld/exception.h>
#include <stdio.h>

#if defined(WIN32) || defined(WIN64)
#define     strcasecmp      _stricmp
#define     strncasecmp     _strnicmp
#define     strtok_r        strtok_s
#define     strtoll         _strtoi64
#define     strtoull        _strtoui64
#define     snprintf        _snprintf
#endif

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

namespace Mobi { namespace Mtld { namespace Da {
using namespace std;

/*
 * Forward declarations of classes.
 */

class Value;
class Values;

struct attrvec : public std::map<size_t, const Value *> {
    attrvec() : std::map<size_t, const Value *>() {}
};

/*
 * Exceptions
 */


/*
 * Thrown by DeviceAtlas constructor if JSON database does not
 * match expected format
 */
class DataFormatException : public Mtld::Exception { };

/*
 * Thrown by getPropertyDescr methods when the property does not exist
 * in the atlas's vocabulary.
 */
class NoSuchProperty : public Mtld::Exception {
public:
    NoSuchProperty(std::string name) { *this << "no such property \"" << name << "\""; }
    NoSuchProperty(int idx) { *this << "no property at index " << idx; }
};

/*
 * Thrown by getProperty() methods when the given property does not have a
 * value in the device context.
 */
class NoSuchValue : public Mtld::Exception {
public:
    NoSuchValue(std::string name)
        : Mtld::Exception(std::string("no value for property ") + name)
    {}
};

/*
 * Thrown when the type of a property differs from that requested
 * with one of the overloaded getProperty() methods of delivery context.
 */
class PropertyTypeMismatch : public Mtld::Exception {
public:
    PropertyTypeMismatch(std::string name) : Mtld::Exception(name) {}
};

/*
 * Thrown when an incompatible conversion routine is called on a Value
 * (eg, calling strval() on a Value that has a type of JSON::Integer
 */
class ValueTypeMismatch : public Mtld::Exception {
public:
    ValueTypeMismatch() : Mtld::Exception("value type mismatch") {}
};

/*
 * Thrown when parsing client properties if key name is not a known type
 * identifying character.
 */
class InvalidPropertyType : public Mtld::Exception {
public:
    char typec;
    InvalidPropertyType(char typec_) : Mtld::Exception("invalid property type") , typec(typec_) {
        *this << ": " << typec;
    }
};

class MissingDataException : public Mtld::Exception {
public:
    MissingDataException() : Mtld::Exception("no data file loaded") {}
};

// Thrown for ill-formed Data content.
class FormatError : public Mtld::Exception {};
class OverflowError : public FormatError {};

/*
 * Possible types of a property, as encoded in the first character of the
 * properties name in the Data property name, or implied by the Data type.
 * For values, we only distinguish ints and strings, as bools are recorded
 * as 0 and 1 for false and true.
 *
 * Note we only record the type for values to deal with discrepancies in
 * the data
 */
enum PropertyType { Integer, String, Bool, Float, Set };

/*
 * Represents the value of a property extracted from the atlas.
 * The type of a value comes from the underlying Data type: it
 * should be possible to avoid representing this here, and just
 * store it in the property, but some values have types that don't
 * match the type in the property in some data files.
 */

typedef std::vector<Value *> valueset;

std::ostream &
operator<<(ostream &, const valueset &);

class DA_EXPORT Value {
public:
    union {
        const char *strval;
        float floatval;
        long longval;
    } u;
    valueset set;
    PropertyType type;
    Value()
        : set(0), 
        type(String)
    {
        u.strval = 0;
    }
    const char *strval() const {
        if (type != String)
            throw ValueTypeMismatch();
        return u.strval;
    }
    float floatval() const {
        if (type != Float)
            throw ValueTypeMismatch();
        return u.floatval;
    }
    const valueset setval() const {
        if (type != Set)
            throw ValueTypeMismatch();
        return set;
    }
    long longval() const {
        if (type != Integer)
            throw ValueTypeMismatch();
        return u.longval;
    }
    operator bool() const;
    operator std::string() const;
    operator long() const;
    operator float() const;
    int compare(const Value &) const;
    // compat
    std::string toString() const { return std::string(*this); }
};


/*
 * A property is a combination of type and name.
 * The index represents the offset in the JSON array that this property
 * was retrieved from.
 */
class DA_EXPORT Property {
public:
    size_t index;
    const char *name;
    PropertyType type;
};

struct DA_EXPORT ValueChecker {
    template<typename signedT>
    static signedT atoi(const char *);
    template<typename unsignedT>
    static unsignedT atou(const char *);
    template<typename realT>
    static realT atof(const char *);
};

struct DA_EXPORT CaseInsensitiveLess : public binary_function<std::string, std::string, bool> {
    bool operator()(const std::string & a, const std::string & b) const {
        return strncasecmp(a.c_str(), b.c_str(), b.size()) < 0;
    }
};
// Case-insensitive map of string->string, used for header values.
typedef std::map<std::string, std::string, CaseInsensitiveLess> HeaderMap;

/*
 * defaultHeaderPriorities[n] is a null-terminated array of header names,
 * in most-significant to least significant order, representing the actual
 * HTTP header names to use as a lookup for tree "n" for properties for
 * that device. This is overrideable when constructing the HttpHeaders
 * object
 */
DA_EXPORT extern const char **defaultHeaderPriorities[];

/*
 * HttpHeaders represents the evidence used to look up the DeviceAtlas
 * for properties of a specific client. Each field of the evidence array
 * represents the value of the header used for the lookup of the tree
 * at the same index in the DeviceAtlas. e.g., HttpHeaders::evidence[UA]
 * is used to match against DeviceAtlas::tree[UA]
 */
struct DA_EXPORT CommonHttpHeaders {
    CommonHttpHeaders() {}
};

/*
 * Represents the content of the DeviceAtlas JSON data. Once constructed
 * this object should be considered const: all methods are reentrant.
 */

typedef std::vector<const Property *> propvec;
class DA_EXPORT CommonDeviceAtlas {
    explicit CommonDeviceAtlas(const CommonDeviceAtlas &) {/* no copy construction */}
protected:
    Values *values;

    /*
     * Because most memory allocation is done at construction, to be released
     * at destruction, we can use a simplified allocation strategy: memory
     * allocated from this allocator is only free'd when the allocator itself
     * is destroyed.
     */

    // comparison functor for propByNameMap
    class constcharless {
    public:
        bool operator()(const char *l, const char *r) const {
            return strcmp(l, r) < 0;
        }
    };

    Util::Alloc<4096> allocator;
    // Maps a property name to its associated Property descriptor.
    typedef std::map<const char *, const Property *, constcharless> propByNameMap;
    propByNameMap propertiesByName;

    // Properties, in JSON order
    propvec properties;
    propvec &getProperties() { return properties; }
    const propvec &getProperties() const { return properties; }

public:
    const Property &addProperty(const char *name, PropertyType type);
    const Property *findPropertyDescr(const char *p) const;
    // look up a Property descriptor by name or index.
    const Property &getPropertyDescr(const char *p) const;
    const Property &getPropertyDescr(size_t off) const;
    // This allows a find without a throw.
    size_t getPropertyCount() const { return getProperties().size(); }
    const propvec& getPropertyNames() const { return getProperties(); }

    // copy C string using this atlas's allocator.
    char *strdup(const char *);
    char *strdup(const char *, size_t);

    CommonDeviceAtlas() : values(0) {}
    virtual ~CommonDeviceAtlas() {}
    virtual int getDataRevision() const = 0;
    virtual time_t getDataGeneration() const = 0;
};

class DA_EXPORT CommonDeliveryContext {
public:
        /*
         * Allocator for memory that will be required for the lifetime of
         * the DeliveryContext
         * This is first so it can be used during construction
         */
    Util::Alloc<1024 * 3> allocator;


    CommonDeliveryContext() {}  

    const Value **globalAttrs; // indexed by property id.

    // Create a context reflecting the properties of the device
    // identified by the HttpHeaders object.
    CommonDeliveryContext(const CommonDeviceAtlas &da_, const CommonHttpHeaders &);
    virtual ~CommonDeliveryContext() {}
    char *strdup(const char *from, size_t len = -1);
    // std-style const iterator for all properties.
    virtual size_t size() const = 0;
    virtual bool empty() = 0;

    // Get value of selected properties from the device.

    // This is the canonical getProperty, which all others delegate to
    void getProperty(const Property &prop, const Value *&value);

    // Get property of a specific assumed type.
    void getProperty(const Property &prop, int &value);
    void getProperty(const Property &prop, const char *&value);
    void getProperty(const Property &prop, bool &value);

    virtual const Value *findProperty(const Property &p) const = 0;
    virtual const Value *findProperty(size_t) const = 0;
    virtual void setProperty(const Property &, const Value *) = 0;
    virtual void setProperty(size_t, const Value *) = 0;
    virtual const Property &getPropertyDescr(const char *, PropertyType *) = 0;
    virtual const Property &getPropertyDescr(size_t idx) const = 0;
    /*
     * convenience methods to look up property descriptors from const char *
     * by looking up the property descriptor as required
     */
    void getProperty(const char *prop, const Value *&value)
    { getProperty(getPropertyDescr(prop, 0), value); }
    void getProperty(const char *prop, int &value)
    { getProperty(getPropertyDescr(prop, 0), value); }
    void getProperty(const char *prop, const char *&value)
    { getProperty(getPropertyDescr(prop, 0), value); }
    void getProperty(const char *prop, bool &value)
    { getProperty(getPropertyDescr(prop, 0), value); }

    bool hasProperty(const Property &prop) { return findProperty(prop.index) != 0; }
    /*
     * @brief checks presence of the requested property
     * and the equality with the value found
     * tocheck should be type compatible with underlying property value though
     * @param propname
     * @param tocheck
     */
    template <typename T>
    bool contains(const char *propname, T tocheck);

    // Accessors
    virtual const Value *operator[](const Property &) const = 0;
    virtual const Value *operator[](const char *propname) const = 0;
};
DA_EXPORT std::ostream &operator<<(std::ostream &, const PropertyType &);
DA_EXPORT std::ostream &operator<<(std::ostream &, const Property &);
static inline std::ostream &operator << (std::ostream &os, const Value &v)
{ return os << std::string(v); }
template<>
inline bool CommonDeliveryContext::contains<const char *>(const char *, const char *);

#include <mtld/common.tpp>

}}}

// pretty-printer for stream output
#endif