APITypes.h

/**********************************************************\
Original Author: Richard Bateman (taxilian)

Created:    Sept 24, 2009
License:    Dual license model; choose one of two:
            New BSD License
            http://www.opensource.org/licenses/bsd-license.php
            - or -
            GNU Lesser General Public License, version 2.1
            http://www.gnu.org/licenses/lgpl-2.1.html

Copyright 2009 Richard Bateman, Firebreath development team
\**********************************************************/

#pragma once
#ifndef H_FB_APITYPES
#define H_FB_APITYPES

#include <string>
#include <vector>
#include <map>
#include <set>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant/variant_fwd.hpp>
#include "fb_stdint.h"
#include "FBPointers.h"

namespace FB
{
    FB_FORWARD_PTR(BrowserHost);
    FB_FORWARD_PTR(JSAPI);
    FB_FORWARD_PTR(JSObject);
    class variant;
    namespace variant_detail {
        // Note that null translates to returning NULL
        struct null;
        // Note that empty translates into return VOID (undefined)
        struct empty;
    }
    
    // Variant list

    typedef std::vector<variant> VariantList;

    typedef std::map<std::string, variant> VariantMap;

    typedef std::set<std::string> StringSet;
    
    // FB pointer types

    typedef boost::weak_ptr<FB::JSAPI> JSAPIWeakPtr; 
    typedef boost::shared_ptr<FB::JSAPI> JSAPIPtr; 

    typedef boost::weak_ptr<FB::JSObject> JSObjectWeakPtr;
    typedef boost::shared_ptr<FB::JSObject> JSObjectPtr;

    typedef boost::shared_ptr<FB::BrowserHost> BrowserHostPtr;
    
    // backwards compability typedefs

    typedef BrowserHost BrowserHostWrapper;

    typedef JSObject BrowserObjectAPI;

    typedef JSAPIPtr JSOutObject;
    
    // deprecation warnings
    
#if defined(_MSC_VER)
#  pragma deprecated(BrowserHostWrapper, BrowserObjectAPI, JSOutObject)
#elif defined(__GNUC__)
    typedef BrowserHost BrowserHostWrapper __attribute__((deprecated));
    typedef JSObject BrowserObjectAPI __attribute__((deprecated));
    typedef JSAPIPtr JSOutObject __attribute__((deprecated));
#endif
    
    // dynamically cast a FB pointer

    template<class T, class U> 
    boost::shared_ptr<T> ptr_cast(boost::shared_ptr<U> const & r);

    typedef variant (JSAPI::*InvokeType)(const std::string&, const std::vector<variant>&);
    typedef variant (JSAPI::*ConstructType)(const std::vector<variant>&);
    typedef void (JSAPI::*SetPropertyType)(const std::string&, const variant&);
    typedef variant (JSAPI::*GetPropertyType)(const std::string&);
    typedef void (JSAPI::*RemovePropertyType)(const std::string&);

    struct CatchAll {
        typedef FB::VariantList value_type;
        FB::VariantList value;
    };

    // Special Variant types
    typedef FB::variant_detail::empty FBVoid;
    typedef FB::variant_detail::null FBNull;
    struct FBDateString {
    public:
        FBDateString() { }
        FBDateString(const FBDateString& rhs) : date(rhs.date) { }
        FBDateString(const std::string &dstr) : date(dstr) { }

        FBDateString& operator=(const std::string& dstr) { date = dstr; return *this; }
        std::string getValue() { return date; }
        void setValue(std::string value) { date = value; }
        bool operator<(const std::string& rh) const
        {
            return date < rh;
        }
        bool operator<(const FBDateString& rh) const
        {
            return date < rh.date;
        }
        
    protected:
        std::string date;
    };

    // JSAPI methods

    class JSAPI;
    typedef variant (JSAPI::*CallMethodPtr)(const std::vector<variant>&);
    struct MethodInfo {
        MethodInfo() : callFunc(NULL) { }
        MethodInfo(CallMethodPtr callFunc) : callFunc(callFunc) { }
        MethodInfo(const MethodInfo &rh) : callFunc(rh.callFunc) { }
        CallMethodPtr callFunc;
    };

    typedef std::map<std::string, MethodInfo> MethodMap;

    // JSAPI properties


    typedef variant (JSAPI::*GetPropPtr)();
    typedef void (JSAPI::*SetPropPtr)(const variant& value);
    struct PropertyInfo {
        PropertyInfo() : getFunc(NULL), setFunc(NULL) { }
        PropertyInfo(GetPropPtr getFunc, SetPropPtr setFunc) : getFunc(getFunc), setFunc(setFunc) { }
        PropertyInfo(const PropertyInfo &rh) : getFunc(rh.getFunc), setFunc(rh.setFunc) { }
        GetPropPtr getFunc;
        SetPropPtr setFunc;
    };

    typedef std::map<std::string, PropertyInfo> PropertyMap;

    // new style JSAPI methods
    typedef int SecurityZone;

    enum SecurityLevel {
        SecurityScope_Public = 0,
        SecurityScope_Protected = 2,
        SecurityScope_Private = 4,
        SecurityScope_Local = 6
    };

    typedef boost::function<variant (const std::vector<variant>&)> CallMethodFunctor;
    struct MethodFunctors
    {
        CallMethodFunctor call;
        SecurityZone zone;
        MethodFunctors() : call() {}
        MethodFunctors(const CallMethodFunctor& call) : call(call) {}
        MethodFunctors(const SecurityZone& zone, const CallMethodFunctor& call) : call(call), zone(zone) {}
        MethodFunctors(const MethodFunctors& m) : call(m.call) {}
        MethodFunctors& operator=(const MethodFunctors& rhs) {
            call = rhs.call;
            zone = rhs.zone;
            return *this;
        }
    };
    typedef std::map<std::string, MethodFunctors> MethodFunctorMap;

    // new style JSAPI properties

    typedef boost::function<FB::variant ()> GetPropFunctor;
    typedef boost::function<void (const FB::variant&)> SetPropFunctor;
    struct PropertyFunctors
    {
        GetPropFunctor get;
        SetPropFunctor set;
        PropertyFunctors() : get(), set() {}
        PropertyFunctors(const GetPropFunctor& get, const SetPropFunctor& set)
          : get(get), set(set) {}
        PropertyFunctors(const PropertyFunctors& p)
          : get(p.get), set(p.set) {}
        PropertyFunctors& operator=(const PropertyFunctors& rhs) {
            get = rhs.get;
            set = rhs.set;
            return *this;
        }
    };
    typedef std::map<std::string, PropertyFunctors> PropertyFunctorsMap;

    // JSAPI event handlers

    typedef std::pair<std::string, FB::JSObjectPtr> EventPair;
    typedef std::multimap<std::string, FB::JSObjectPtr> EventMultiMap;
    typedef std::map<void*, FB::JSObjectPtr> EventIFaceMap;
    typedef std::map<std::string, FB::JSObjectPtr> EventSingleMap;
    
    // implementation details
    
    template<class T, class U> 
    boost::shared_ptr<T> ptr_cast(boost::shared_ptr<U> const & r) 
    {
        return boost::dynamic_pointer_cast<T>(r);
    }

    namespace boost_variant {
        typedef boost::variant<long, int, double, std::string, FB::JSAPIPtr, FB::JSObjectPtr, FB::FBNull, FB::FBVoid> fb_compat;
        typedef boost::variant<long, int, double, float, std::string, FB::FBNull, FB::FBVoid> primitives;
        typedef boost::variant<std::string, FB::StringSet> strings;
    }

    struct Rect {
        int32_t top;
        int32_t left;
        int32_t bottom;
        int32_t right;
    };
}

// This needs to be included after all our classes are defined because it relies on types defined in this file
// TODO: can this be done better?
#include "variant.h"

#endif