openrtb/openrtb.h

#pragma once

#include <string>
#include <memory>
#include <vector>
#include "soa/types/id.h"
#include "soa/types/string.h"
#include "soa/types/url.h"
#include "jml/utils/compact_vector.h"
#include "soa/jsoncpp/value.h"
#include <iostream>

namespace OpenRTB {

using std::string;
using std::vector;
using std::unique_ptr;
using Datacratic::Id;
using Datacratic::Utf8String;
using Datacratic::Url;

typedef std::string CSList;  // comma-separated list

template<typename T>
struct Optional: public std::unique_ptr<T> {
    Optional()
    {
    }
    
    Optional(Optional && other)
        : std::unique_ptr<T>(std::move(other))
    {
    }

    Optional(const Optional & other)
    {
        if (other)
            this->reset(new T(*other));
    }

    Optional & operator = (const Optional & other)
    {
        Optional newMe(other);
        swap(newMe);
        return *this;
    }

    Optional & operator = (Optional && other)
    {
        Optional newMe(other);
        swap(newMe);
        return *this;
    }

    void swap(Optional & other)
    {
        std::unique_ptr<T>::swap(other);
    }
};

template<typename Cls, int defValue = -1>
struct TaggedEnum {
    TaggedEnum()
        : val(-1)
    {
    }

    int val;

    int value() const
    {
        return val;
    }


#if 0
    operator typename Cls::Vals () const
    {
        return static_cast<typename Cls::Vals>(val);
    }
#endif
};

template<typename E, int def>
bool operator == (const TaggedEnum<E, def> & e1, const TaggedEnum<E, def> & e2)
{
    return e1.val == e2.val;
}

template<typename E, int def>
bool operator != (const TaggedEnum<E, def> & e1, const TaggedEnum<E, def> & e2)
{
    return e1.val != e2.val;
}

template<typename E, int def>
bool operator > (const TaggedEnum<E, def> & e1, const TaggedEnum<E, def> & e2)
{
    return e1.val > e2.val;
}

template<typename E, int def>
bool operator < (const TaggedEnum<E, def> & e1, const TaggedEnum<E, def> & e2)
{
    return e1.val < e2.val;
}

template<typename E, int def>
inline Json::Value jsonPrint(const TaggedEnum<E, def> & e)
{
    return e.val;
}

template<typename E, int def>
inline void jsonParse(const Json::Value & j, TaggedEnum<E, def> & e)
{
    e.val = j.asInt();
}

struct TaggedBool {
    TaggedBool()
        : val(-1)
    {
    }

    int val;
};

template<int defValue = -1>
struct TaggedBoolDef : public TaggedBool {
    TaggedBoolDef()
        : val(defValue)
    {
    }

    int val;
};

struct TaggedInt {
    TaggedInt()
        : val(-1)
    {
    }

    int value() const { return val; }

    int val;
};

template<int defValue = -1>
struct TaggedIntDef : TaggedInt {
    TaggedIntDef()
        : val(defValue)
    {
    }

    int val;
};

struct TaggedFloat {
    TaggedFloat()
        : val(std::numeric_limits<float>::quiet_NaN())
    {
    }

    float val;
};

template<int num = -1, int den = 1>
struct TaggedFloatDef : public TaggedFloat {
    TaggedFloatDef()
        : val(1.0f * num / den)
    {
    }

    float val;
};

#if 0 // c++11 templated typedefs
template<typename T>
using List = compact_vector<T, 3>;

#else
template<typename T>
struct List: public ML::compact_vector<T, 3> {

#if 0
    typedef ML::compact_vector<T, 3> Base;

    List()
    {
        using namespace std;
        cerr << "default construct" << endl;
    }

    List(const List & other)
        : Base(std::move(other))
    {
        using namespace std;
        cerr << "copy construct" << endl;
    }
    
    List & operator = (const List & other)
    {
        using namespace std;
        cerr << "assignment" << endl;
        *(Base *)this = (Base &)other;
        return *this;
    }

    ~List()
    {
        using namespace std;
        cerr << "destructor length " << this->size() << endl;
    }

    List & operator = (List && other)
    {
        using namespace std;
        cerr << "move assignment" << endl;
        *(Base *)this = (Base &&)other;
        return *this;
    }
    
    List(List && other)
        : Base(std::move(other))
    {
        using namespace std;
        cerr << "move constructor from length " << this->size() << endl;
    }
#endif
};

#endif

/*****************************************************************************/
/* MIME TYPES                                                                */
/*****************************************************************************/

struct MimeType {
    MimeType(const std::string & type = "")
        : type(type)
    {
    }

    std::string type;
    //int val;
};


/*****************************************************************************/
/* CONTENT CATEGORIES                                                        */
/*****************************************************************************/

struct ContentCategory {

    ContentCategory(const std::string & val = "")
        : val(val)
    {
    }

    string val;

#if 0    
    ContentCategory(int l1 = -1, int l2 = -1)
        : l1(l1), l2(l2)
    {
    }

    int l1;
    int l2;
#endif
};


/*****************************************************************************/
/* BANNER AD TYPES                                                           */
/*****************************************************************************/

struct BannerAdType: public TaggedEnum<BannerAdType> {
    enum Vals {
        UNSPECIFIED = -1,  

        XHTML_TEXT = 1,    
        XHTML_BANNER = 2,  
        JAVASCRIPT = 3,    
        IFRAME = 4         
    };
};

/*****************************************************************************/
/* CREATIVE ATTRIBUTES                                                       */
/*****************************************************************************/

struct CreativeAttribute: public TaggedEnum<CreativeAttribute> {
    enum Vals {
        UNSPECIFIED = -1,  
    };
};


/*****************************************************************************/
/* API FRAMEWORKS                                                            */
/*****************************************************************************/

struct ApiFramework: public TaggedEnum<ApiFramework> {
    enum Vals {
        UNSPECIFIED = -1,  

        VPAID_1 = 1,    
        VPAID_2 = 2,    
        MRAID = 3,      
        ORMMA = 4       
    };
};


/*****************************************************************************/
/* AD POSITION                                                               */
/*****************************************************************************/

struct AdPosition: public TaggedEnum<AdPosition, 0> {
    enum Vals {
        UNSPECIFIED = -1,  

        UNKNOWN = 0,
        ABOVE = 1,
        BETWEEN_DEPRECATED = 2,
        BELOW = 3,
        HEADER = 4,
        FOOTER = 5,
        SIDEBAR = 6,
        FULLSCREEN = 7
    };
};


/*****************************************************************************/
/* VIDEO LINEARITY                                                           */
/*****************************************************************************/

struct VideoLinearity: public TaggedEnum<VideoLinearity> {
    enum Vals {
        UNSPECIFIED = -1,  

        IN_STREAM = 1,
        OVERLAY = 2
    };
};


/*****************************************************************************/
/* VIDEO BID RESPONSE PROTOCOLS                                              */
/*****************************************************************************/

struct VideoBidResponseProtocol: public TaggedEnum<VideoBidResponseProtocol> {
    enum Vals {
        UNSPECIFIED = -1,  

        VAST1 = 1,
        VAST2 = 2,
        VAST3 = 3,
        VAST1_WRAPPER = 4,
        VAST2_WRAPPER = 5,
        VAST3_WRAPPER = 6
    };
};

/*****************************************************************************/
/* VIDEO PLAYBACK METHODS                                                    */
/*****************************************************************************/

struct VideoPlaybackMethod: public TaggedEnum<VideoPlaybackMethod> {
    enum Vals {
        UNSPECIFIED = -1,  

        AUTO_PLAY_SOUND_ON = 1,
        AUTO_PLAY_SOUND_OFF = 2,
        CLICK_TO_PLAY = 3,
        MOUSE_OVER = 4
    };
};


/*****************************************************************************/
/* VIDEO START DELAY                                                         */
/*****************************************************************************/

struct VideoStartDelay: public TaggedEnum<VideoStartDelay> {
    enum Vals {
        UNSPECIFIED = -1,  

        PRE_ROLL = 0,
        GENERIC_MID_ROLL = -1,
        GENERIC_POST_ROLL = -2
    };
};


/*****************************************************************************/
/* CONNECTION TYPE                                                           */
/*****************************************************************************/

struct ConnectionType: public TaggedEnum<ConnectionType> {
    enum Vals {
        UNSPECIFIED = -1,  

        UNKNOWN = 0,
        ETHERNET = 1,
        WIFI = 2,
        CELLULAR_UNKNOWN = 3,
        CELLULAR_2G = 4,
        CELLULAR_3G = 5,
        CELLULAR_4G = 6
    };
};


/*****************************************************************************/
/* EXPANDABLE DIRECTION                                                      */
/*****************************************************************************/

struct ExpandableDirection: public TaggedEnum<ExpandableDirection> {
    enum Vals {
        UNSPECIFIED = -1,  

        LEFT = 1,
        RIGHT = 2,
        UP = 3,
        DOWN = 4,
        FULLSCREEN = 5
    };
};


/*****************************************************************************/
/* CONTENT DELIVERY METHOD                                                   */
/*****************************************************************************/

struct ContentDeliveryMethod: public TaggedEnum<ContentDeliveryMethod> {
    enum Vals {
        UNSPECIFIED = -1,  

        STREAMING = 1,
        PROGRESSIVE = 2
    };
};


/*****************************************************************************/
/* CONTENT CONTEXT                                                           */
/*****************************************************************************/

struct ContentContext: public TaggedEnum<ContentContext> {
    enum Vals {
        UNSPECIFIED = -1,  

        VIDEO = 1,
        GAME = 2,
        MUSIC = 3,
        APPLICATION = 4,
        TEXT = 5,
        OTHER = 6,
        UNKNOWN = 7
    };
};


/*****************************************************************************/
/* VIDEO QUALITY                                                             */
/*****************************************************************************/

struct VideoQuality: public TaggedEnum<VideoQuality> {
    enum Vals {
        UNSPECIFIED = -1,  

        UNKNOWN = 0,
        PROFESSIONAL = 1,
        PROSUMER = 2,
        USER_GENERATED = 3
    };
};


/*****************************************************************************/
/* LOCATION TYPE                                                             */
/*****************************************************************************/

struct LocationType: public TaggedEnum<LocationType> {
    enum Vals {
        UNSPECIFIED = -1,  

        GPS = 1,        
        IP_ADDRESS = 2, 
        USER = 3        
    };
};


/*****************************************************************************/
/* DEVICE TYPE                                                               */
/*****************************************************************************/

struct DeviceType: public TaggedEnum<DeviceType> {
    enum Vals {
        UNSPECIFIED = -1,  

        MOBILE_OR_TABLET = 1,
        PC = 2,
        TV = 3
    };
};


/*****************************************************************************/
/* VAST COMPANION TYPES                                                      */
/*****************************************************************************/

struct VastCompanionType: public TaggedEnum<VastCompanionType> {
    enum Vals {
        UNSPECIFIED = -1,  

        STATIC_RESOURCE = 1,
        HTML_RESOURCE = 2,
        IFRAME_RESOURCE = 3
    };
};


/*****************************************************************************/
/* QAG MEDIA RATINGS                                                         */
/*****************************************************************************/

struct MediaRating: public TaggedEnum<MediaRating> {
    enum Vals {
        UNSPECIFIED = -1,  

        ALL_AUDIENCES = 1,
        OVER_12 = 2,
        MATURE_AUDIENCES =3 
    };
};


/*****************************************************************************/
/* FRAME POSITION                                                            */
/*****************************************************************************/

struct FramePosition: public TaggedEnum<FramePosition, 0> {
    enum Vals {
        UNSPECIFIED = -1,  

        IFRAME = 0,
        TOP_FRAME = 1
    };
};

/*****************************************************************************/
/* SOURCE RELATIONSHIP                                                       */
/*****************************************************************************/

struct SourceRelationship: public TaggedEnum<SourceRelationship> {
    enum Vals {
        UNSPECIFIED = -1,  

        INDIRECT = 0,
        DIRECT = 1
    };
};

/*****************************************************************************/
/* AUCTION TYPE                                                              */
/*****************************************************************************/

struct AuctionType: public TaggedEnum<AuctionType, 2> {
    enum Vals {
        UNSPECIFIED = -1,  

        FIRST_PRICE = 1,
        SECOND_PRICE = 2
    };

    AuctionType(Vals val = UNSPECIFIED)
    {
        this->val = val;
    }
};


/*****************************************************************************/
/* BANNER                                                                    */
/*****************************************************************************/

struct Banner {
    ~Banner();

    List<int> w;                     
    List<int> h;                     

    Id id;                           
    AdPosition pos;                  
    List<BannerAdType> btype;        
    List<CreativeAttribute> battr;   
    List<MimeType> mimes;            
    FramePosition topframe;          
    List<ExpandableDirection> expdir;
    List<ApiFramework> api;          
};


/*****************************************************************************/
/* VIDEO                                                                     */
/*****************************************************************************/

struct Video {
    ~Video();
    List<MimeType> mimes;       
    VideoLinearity linearity;   
    TaggedInt minduration;      
    TaggedInt maxduration;      
    List<VideoBidResponseProtocol> protocol;  
    TaggedInt w;                
    TaggedInt h;                
    TaggedInt startdelay;       
    TaggedIntDef<1> sequence;   
    List<CreativeAttribute> battr; 
    TaggedIntDef<0> maxextended;
    TaggedInt minbitrate;       
    TaggedInt maxbitrate;       
    TaggedBoolDef<1> boxingallowed;           
    List<VideoPlaybackMethod> playbackmethod; 
    List<ContentDeliveryMethod> delivery;     
    AdPosition pos;             
    vector<Banner> companionad; 
    List<ApiFramework> api;     
};


/*****************************************************************************/
/* PRODUCER / PUBLISHER                                                      */
/*****************************************************************************/

struct Publisher {
    ~Publisher();
    Id id;                       
    string name;                 
    List<ContentCategory> cat; 
    string domain;               
};

typedef Publisher Producer;  

    
/*****************************************************************************/
/* IMPRESSION                                                                */
/*****************************************************************************/

struct Impression {
    ~Impression();
    Id id;                             
    Optional<Banner> banner;           
    Optional<Video> video;             
    string displaymanager;             
    string displaymanagerver;          
    TaggedBoolDef<0> instl;            
    string tagid;                      
    TaggedFloatDef<0> bidfloor;        
    string bidfloorcur;                
    List<string> iframebuster;         
    Json::Value ext;                   
};


/*****************************************************************************/
/* CONTENT                                                                   */
/*****************************************************************************/

struct Content {
    ~Content();
    Id id;                   
    TaggedInt episode;       
    Utf8String title;        
    Utf8String series;       
    Utf8String season;       
    Url url;                 
    List<ContentCategory> cat; 
    VideoQuality videoquality; 
    CSList keywords;         
    string contentrating;    
    string userrating;       
    string context;          
    TaggedBool livestream;   
    SourceRelationship sourcerelationship;  
    Optional<Producer> producer;  
    TaggedInt len;           
};


/*****************************************************************************/
/* CONTEXT                                                                   */
/*****************************************************************************/

struct Context {
    ~Context();
    Id id;        
    Utf8String name;  
    Utf8String domain;
    List<ContentCategory> cat;        
    List<ContentCategory> sectioncat; 
    List<ContentCategory> pagecat;    
    TaggedBool privacypolicy;           
    Optional<Publisher> publisher;    
    Optional<Content> content;        
    CSList keywords;                    
    Json::Value ext;
};


/*****************************************************************************/
/* SITE                                                                      */
/*****************************************************************************/

struct SiteInfo {
    Url page;          
    Url ref;           
    Utf8String search; 
};

struct Site: public Context, public SiteInfo {
};


/*****************************************************************************/
/* APP                                                                       */
/*****************************************************************************/

struct AppInfo {
    string ver;         
    string bundle;      
    TaggedBool paid;    
};

struct App: public Context, public AppInfo {
};


/*****************************************************************************/
/* GEO                                                                       */
/*****************************************************************************/

struct Geo {
    ~Geo();
    TaggedFloat lat;        
    TaggedFloat lon;        
    TaggedBool latlonconsent;  
    string country;         
    string region;          
    string regionfips104;   
    string metro;           
    Utf8String city;        
    string zip;             
    string dma;             
    LocationType type;      
};


/*****************************************************************************/
/* DEVICE                                                                    */
/*****************************************************************************/

struct Device {
    ~Device();
    TaggedBool dnt;        
    string ua;             
    string ip;             
    Optional<Geo> geo;     
    string didsha1;        
    string didmd5;         
    string dpidsha1;       
    string dpidmd5;        
    string ipv6;           
    string carrier;        
    string language;       
    string make;           
    string model;          
    string os;             
    string osv;            
    TaggedBool js;         
    ConnectionType connectiontype;    
    DeviceType devicetype; 
    string flashver;       
    Json::Value ext;       
};


/*****************************************************************************/
/* SEGMENT                                                                   */
/*****************************************************************************/

struct Segment {
    Id id;                         
    string name;                   
    string value;                  
    TaggedFloat segmentusecost;    
};


/*****************************************************************************/
/* DATA                                                                      */
/*****************************************************************************/

struct Data {
    Id id;                           
    string name;                     
    vector<Segment> segment;         

    string usecostcurrency;          
    TaggedFloat datausecost;         
};


/*****************************************************************************/
/* USER                                                                      */
/*****************************************************************************/

struct User {
    ~User();
    Id id;                     
    Id buyeruid;               
    TaggedInt yob;             
    string gender;             
    CSList keywords;           
    string customdata;         
    vector<Data> data;         
    Geo geo;                   

    TaggedInt tz;              
    TaggedInt sessiondepth;    
};


/*****************************************************************************/
/* BID REQUEST                                                               */
/*****************************************************************************/


struct BidRequest {
    ~BidRequest();
    Id id;                             

    vector<Impression> imp;            
    //unique_ptr<Context> context;     // TODO: factor out of site and app
    Optional<Site> site;
    Optional<App> app;
    Optional<Device> device;
    Optional<User> user;

    AuctionType at;                    
    TaggedInt tmax;                    
    vector<string> wseat;              
    TaggedBool allimps;                
    vector<string> cur;                
    List<ContentCategory> bcat;        
    vector<string> badv;               
    Json::Value ext;                   
    Json::Value unparseable;           
};


/*****************************************************************************/
/* BID                                                                       */
/*****************************************************************************/

struct Bid {
    Id id;                        
    Id impid;                     
    TaggedFloat price;            
    Id adid;                      
    string nurl;                  
    string adm;                   
    vector<string> adomain;       
    string iurl;                  
    Id cid;                       
    Id crid;                      
    List<CreativeAttribute> attr; 
    Json::Value ext;              
};


/*****************************************************************************/
/* SEAT BID                                                                  */
/*****************************************************************************/

struct SeatBid {
    vector<Bid> bid;              
    Id seat;                      
    TaggedInt group;              
    Json::Value ext;              
};


/*****************************************************************************/
/* BID RESPONSE                                                              */
/*****************************************************************************/

struct BidResponse {
    Id id;
    vector<SeatBid> seatbid;
    Id bidid;
    string cur;
    string customData;
    Json::Value ext;
};

} // namespace OpenRTB