#if !defined(CODE_GOOGLE_COM_P_V8_CONVERT_CORE_HPP_INCLUDED) #define CODE_GOOGLE_COM_P_V8_CONVERT_CORE_HPP_INCLUDED 1 /* A min-framework to simplify casting between v8 JavaScript and C++ native objects. v8: http://code.google.com/p/v8/ Author: Stephan Beal (http://wanderinghorse.net/home/stephan/) License: Dual MIT/Public Domain */ //#include // arg! Requires C++0x! #include #include // hope the client's platform is recent! #include #include #include #include #include #include #include #if !defined(CVV8_CONFIG_HAS_LONG_LONG) /* long long in C++ requires C++0x or compiler extensions. */ # define CVV8_CONFIG_HAS_LONG_LONG 0 #endif #include "signature_core.hpp" /* only needed for the Signature used by the generated code. */ #include "tmp.hpp" namespace cvv8 { /** A convenience base type for TypeInfo specializations. */ template struct TypeInfoBase { /** The unqualified type T. In some special cases, Type _may_ differ from T. */ typedef T Type; /** The "handle" type used to pass around native objects between the JS and Native worlds. In _theory_ we can also use shared/smart pointers with this typedef, but that requires custom handling in other template code (mainly because we cannot store a full-fledged shared pointer object directly inside a JS object). */ typedef NHT NativeHandle; // MAYBE to do: add a function to get a pointer to the object, e.g. // for dereferencing smart pointers. So far it's not been necessary. // static NativeHandle Pointer( NativeHandle x ) { return x; } }; /** This may optionally be specialized for client-defined types to define the type name used by some error reporting code. The default implementation is usable but not all that useful. */ template struct TypeName { /** Specializations must have a non-NULL value, and any number of specializations may legally have the same value. */ static char const * Value; }; #if 0 /** This default implementation is unfortunate, but quite a bit of error-reporting code uses this, with the assumption that if it was worth binding to JS then it's worth having a useful type name in error strings. FIXME: remove the default specialization if we can, as it will cause us problems with some planned/potential uses which cross DLL boundaries (there may be multiple definitions with different addresses). */ template char const * TypeName::Value = "T"; #endif /** @def CVV8_TypeName_DECL A convenience macro for declaring a TypeName specialization. X must be a type name with extra wrapping parenthesis, e.g.: @code CVV8_TypeName_DECL((MyType)); @endcode They are required so that we can also support template types with commas in the names, e.g. (std::map). It must be called from inside the cvv8 namespace. */ #define CVV8_TypeName_DECL(X) template <> struct TypeName< cvv8::sl::At<0,CVV8_TYPELIST(X) >::Type > \ { const static char * Value; } /** @def CVV8_TypeName_IMPL The counterpart of CVV8_TypeName_DECL, this must be called from the cvv8 namespace. The X argument is as documented for CVV8_TypeName_DECL and the NAME argument must be a C string. Example: @code CVV8_TypeName_IMPL((MyType),"MyType"); @endcode */ #define CVV8_TypeName_IMPL(X,NAME) char const * TypeName< cvv8::sl::At<0,CVV8_TYPELIST(X) >::Type >::Value = NAME /** @def CVV8_TypeName_IMPL2 Almost identical to CVV8_TypeName_IMPL(), but can be used without having first explicitly specializing TypeName. */ #define CVV8_TypeName_IMPL2(X,NAME) template <> CVV8_TypeName_IMPL(X,NAME) #if 1 template struct TypeName : TypeName {}; template struct TypeName : TypeName {}; template struct TypeName : TypeName {}; #endif /** Describes basic type information regarding a type, for purposes of static typing during JS-to/from-Native conversions. The default instantiation is suitable for most cases. Specializations may be required in certain JS/Native binding cases. */ template struct TypeInfo : TypeInfoBase { }; template struct TypeInfo : TypeInfo {}; template struct TypeInfo : TypeInfo {}; template struct TypeInfo : TypeInfo {}; template struct TypeInfo : TypeInfo {}; template struct TypeInfo : TypeInfo {}; #if 1 // this will only theoretically do what i want. Never actually tried to use a non-pointer NativeHandle type... template struct TypeInfo< v8::Handle > { typedef v8::Handle Type; typedef v8::Handle NativeHandle; }; #endif /** Base instantiation for T-to-v8::Handle conversion functor. Must be specialized or it will not compile. */ template struct NativeToJS { /** Must be specialized. The argument type may be pointer-qualified. Implementations for non-pod types are encouraged to have two overloads, one taking (NT const &) and one taking (NT const *), as this gives the underlying CastToJS() calls more leeway. **/ template v8::Handle operator()( X const & ) const; private: typedef tmp::Assertion NativeToJSMustBeSpecialized; }; /** Specialization to treat (NT*) as (NT). NativeToJS must have an operator() taking (NT const *). */ template struct NativeToJS : NativeToJS #if 1 {}; #else { v8::Handle operator()( NT const * v ) const { typedef NativeToJS Proxy; if( v ) return Proxy()(v); else return v8::Null() ; } }; #endif /** Specialization to treat (NT const *) as (NT). */ template struct NativeToJS : NativeToJS {}; // { // typedef typename TypeInfo::Type const * ArgType; // v8::Handle operator()( ArgType n ) const // { // typedef NativeToJS Proxy; // return Proxy()( n ); // } // }; /** Specialization to treat (NT const &) as (NT). */ template struct NativeToJS : NativeToJS {}; template struct NativeToJS : NativeToJS {}; #if 0 /** Specialization to treat (NT &) as (NT). */ template struct NativeToJS : NativeToJS {}; #else /** A specialization to convert from (T&) to JS. Be very careful with this, and make sure that NativeToJS has its own specialization, as this implementation uses that one as its basis. */ template struct NativeToJS { typedef typename TypeInfo::Type & ArgType; v8::Handle operator()( ArgType n ) const { typedef NativeToJS< typename TypeInfo::NativeHandle > Cast; return Cast()( &n ); } }; #endif #if 0 template <> struct NativeToJS { /** Returns v8::Undefined(). */ template v8::Handle operator()(Ignored const &) const { return ::v8::Undefined(); } }; #endif #if !defined(DOXYGEN) namespace Detail { /** Base implementation for "small" integer conversions (<=32 bits). */ template struct NativeToJS_int_small { v8::Handle operator()( IntegerT v ) const { return v8::Integer::New( static_cast(v) ); } }; /** Base implementation for "small" unsigned integer conversions (<=32 bits). */ template struct NativeToJS_uint_small { v8::Handle operator()( IntegerT v ) const { return v8::Integer::NewFromUnsigned( static_cast(v) ); } }; } #endif // if !defined(DOXYGEN) template <> struct NativeToJS : Detail::NativeToJS_int_small {}; template <> struct NativeToJS : Detail::NativeToJS_uint_small {}; template <> struct NativeToJS : Detail::NativeToJS_int_small {}; template <> struct NativeToJS : Detail::NativeToJS_uint_small {}; #if !defined(DOXYGEN) namespace Detail { /** Base implementation for "big" numeric conversions (>32 bits). */ template struct NativeToJS_int_big { /** Returns v as a double value. */ v8::Handle operator()( IntegerT v ) const { return v8::Number::New( static_cast(v) ); } }; } #endif // if !defined(DOXYGEN) template <> struct NativeToJS : Detail::NativeToJS_int_big {}; template <> struct NativeToJS : Detail::NativeToJS_int_big {}; template <> struct NativeToJS { v8::Handle operator()( double v ) const { return v8::Number::New( v ); } }; template <> struct NativeToJS { v8::Handle operator()( bool v ) const { return v8::Boolean::New( v ); } }; template struct NativeToJS< ::v8::Handle > { typedef ::v8::Handle handle_type; v8::Handle operator()( handle_type const & li ) const { return li; } }; template struct NativeToJS< ::v8::Local > { typedef ::v8::Local handle_type; v8::Handle operator()( handle_type const & li ) const { return li; } }; template struct NativeToJS< ::v8::Persistent > { typedef ::v8::Persistent handle_type; v8::Handle operator()( handle_type const & li ) const { return li; } }; template <> struct NativeToJS< ::v8::InvocationCallback > { v8::Handle operator()( ::v8::InvocationCallback const f ) const { return ::v8::FunctionTemplate::New(f)->GetFunction(); } }; template <> struct NativeToJS { v8::Handle operator()( std::string const & v ) const { /** This use of v.data() instead of v.c_str() is highly arguable. */ char const * const cstr = v.data(); return cstr ? v8::String::New( cstr, static_cast( v.size() ) ) : v8::String::New("",0); } }; template <> struct NativeToJS { v8::Handle operator()( char const * v ) const { if( ! v ) return v8::Null(); else return v8::String::New( v ); } }; /** "Casts" v to a JS value using NativeToJS. */ template inline v8::Handle CastToJS( T const & v ) { typedef NativeToJS F; return F()( v ); } /** Overload to avoid ambiguity in certain calls. */ static inline v8::Handle CastToJS( char const * v ) { typedef NativeToJS F; return F()( v ); } /** Overload to avoid mis-selection of templates. */ static inline v8::Handle CastToJS( v8::InvocationCallback v ) { typedef NativeToJS F; return F()( v ); } /** Overload to avoid ambiguity in certain calls. */ static inline v8::Handle CastToJS( char * v ) { typedef NativeToJS F; return F()( v ); } /** Convenience instance of NativeToJS. */ static const NativeToJS Int16ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS UInt16ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS Int32ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS UInt32ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS Int64ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS UInt64ToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS DoubleToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS BoolToJS = NativeToJS(); /** Convenience instance of NativeToJS. */ static const NativeToJS StdStringToJS = NativeToJS(); /** Converts a native std::exception to a JS exception and throws that exception via v8::ThrowException(). */ template <> struct NativeToJS { /** Returns v8::Exception::Error(ex.what()). ACHTUNG: on 20110717 this function was changed to NOT trigger a JS exception. Prior versions triggered a JS exception, but that was done due to a misunderstanding on my part (i didn't know v8 provided a way to create Error objects without throwing). This change is semantically incompatible with older code which uses this conversion. OLD way of doing it (don't do this!): @code catch( std::exception const & ex ) { return CastToJS(ex); } @endcode The equivalent is now: @code catch( std::exception const & ex ) { return Toss(CastToJS(ex)); } @endcode */ v8::Handle operator()( std::exception const & ex ) const { char const * msg = ex.what(); return v8::Exception::Error(v8::String::New( msg ? msg : "unspecified std::exception" )); /** ^^^ String::New() internally calls strlen(), which hates it when string==0. */ } }; template <> struct NativeToJS : NativeToJS {}; template <> struct NativeToJS : NativeToJS {}; template <> struct NativeToJS : NativeToJS {}; /** Base interface for converting from native objects to JS objects. There is no default implementation, and it must be specialized to be useful. When creating custom implementations, remember that in practice, all custom client-bound types are passed around internally by non-const pointer. This is in contrast to conversions of POD- and POD-like types (numbers and strings), which are passed around by value. It is theoretically possible to use smart pointers (with value semantics) via this API, but it is untested. */ template struct JSToNative { typedef typename TypeInfo::NativeHandle ResultType; //! Must be specialized to be useful. ResultType operator()( v8::Handle const & h ) const; }; /** Specialization to treat (JST*) as JST. */ template struct JSToNative : JSToNative {}; /** Specialization to treat (JST*) as JST. */ template struct JSToNative : JSToNative {}; /** Specialization to treat (JST const *) as (JST *). */ template struct JSToNative : JSToNative {}; /** A specialization to convert from JS to (T&). */ template struct JSToNative { /** Uses JSTNative() to try to convert a JS object to a pointer, and then dereferences that pointer to form (T&). Beware, however, that this operation throws a native exeception (deriving from std::exception) if it fails, because the only other other option is has is to dereference null and crash your app. */ typedef typename TypeInfo::Type & ResultType; ResultType operator()( v8::Handle const & h ) const { typedef JSToNative Cast; typedef typename Cast::ResultType NH; NH n = Cast()( h ); if( ! n ) { throw std::runtime_error("JSToNative could not get native pointer. Throwing to avoid dereferencing null!"); } else return *n; } }; /** Specialization to treat (JST const &) as (JST). */ template struct JSToNative { typedef typename TypeInfo::Type const & ResultType; ResultType operator()( v8::Handle const & h ) const { typedef JSToNative Cast; typedef typename Cast::ResultType NH; #if 0 NH n = Cast()( h ); if( ! n ) { throw std::runtime_error("JSToNative could not get native pointer. Throwing to avoid dereferencing null!"); } else return *n; #else return Cast()(h); #endif } }; /** Specialization which passes on v8 Handles as-is. */ template struct JSToNative > { typedef v8::Handle ResultType; ResultType operator()( v8::Handle const & h ) const { return h; } }; template struct JSToNative const &> : JSToNative< v8::Handle > {}; template struct JSToNative &> : JSToNative< v8::Handle > {}; /** Specialization which passes on v8 local Handles as-is. */ template struct JSToNative > { typedef v8::Local ResultType; ResultType operator()( v8::Local const & h ) const { return h; } }; template struct JSToNative const &> : JSToNative< v8::Local > {}; template struct JSToNative &> : JSToNative< v8::Local > {}; #if !defined(DOXYGEN) namespace Detail { template struct JSToNative_V8Type { /** If h is not empty and is of the correct type then its converted handle is returned, else an empty handle is returned. */ typedef v8::Handle ResultType; ResultType operator()( v8::Handle const & h ) const { return (h.IsEmpty() || !((*h)->*IsA)()/*man, what a construct!*/) ? v8::Handle() : v8::Handle(V8Type::Cast(*h)); } }; } #endif template <> struct JSToNative > : Detail::JSToNative_V8Type< v8::Object, &v8::Value::IsObject> {}; template <> struct JSToNative< v8::Handle &> : JSToNative< v8::Handle > {}; template <> struct JSToNative< v8::Handle const &> : JSToNative< v8::Handle > {}; template <> struct JSToNative > : Detail::JSToNative_V8Type< v8::Array, &v8::Value::IsArray> {}; template <> struct JSToNative< v8::Handle &> : JSToNative< v8::Handle > {}; template <> struct JSToNative< v8::Handle const &> : JSToNative< v8::Handle > {}; template <> struct JSToNative > : Detail::JSToNative_V8Type< v8::Function, &v8::Value::IsFunction> {}; template <> struct JSToNative< v8::Handle &> : JSToNative< v8::Handle > {}; template <> struct JSToNative< v8::Handle const &> : JSToNative< v8::Handle > {}; /** An X-to-void specialization which we cannot use in the generic case due to the syntactic limitations of void. */ template <> struct JSToNative { typedef void ResultType; ResultType operator()( ... ) const { return; } }; /** A very arguable specialization which tries to convert a JS value to native (void*) via v8::External. */ template <> struct JSToNative { typedef void * ResultType; /** If h is-a External then this return its value, else it return 0. We could arguably check if it is an object and has internal fields, and return the first one, but i think that would be going too far considering how arguably the v8-to-(void *) conversion is in the first place. */ ResultType operator()( v8::Handle const & h ) const { if( h.IsEmpty() || ! h->IsExternal() ) return 0; return v8::External::Cast(*h)->Value(); } }; /** A very arguable specialization which tries to convert a JS value to native (void*) via v8::External. */ template <> struct JSToNative { typedef void const * ResultType; /** If h is-a External then this return its value, else it return 0. We could arguably check if it is an object and has internal fields, and return the first one, but i think that would be going to far considering how arguably the v8-to-(void *) conversion is in the first place. */ ResultType operator()( v8::Handle const & h ) const { if( h.IsEmpty() || ! h->IsExternal() ) return 0; return v8::External::Cast(*h)->Value(); } }; /** A concrete JSToNative implementation intended to be used as the base class for JSToNative implementations where T is "bound to JS" in JS objects, and those JS objects meet the following requirements: - They have exactly InternalFieldCount internal fields. - They have a C/C++-native object of type (T*) (or convertible to type (T*)) stored as a v8::External value in the JS-object internal field number InternalFieldIndex. Note that the InternalFieldCount check is only a quick sanity-checking mechanism, and is by far not foolproof because the majority of JS-bound native types only use 1 internal field. It is illegal for InternalFieldCount to be equal to or smaller than InternalFieldIndex, or for either value to be negative. Violating these invariants results in a compile-time assertion. If an object to convert matches the field specification but is not a T (or publically derived from T) then results are undefined (this could lead to a crash at runtime). There are cases where very-misbehaving JS code can force this particular conversion algorithm to mis-cast the native. While they have never been seen "in the wild", they can theoretically happen. If that bothers you, and you want to be able to sleep soundly at night, use JSToNative_ObjectWithInternalFieldsTypeSafe instead of this class. @see JSToNative_ObjectWithInternalFieldsTypeSafe */ template struct JSToNative_ObjectWithInternalFields { private: typedef char AssertIndexRanges [tmp::Assertion< (InternalFieldIndex>=0) && (InternalFieldCount>0) && (InternalFieldIndex < InternalFieldCount) >::Value ? 1 : -1]; public: typedef typename TypeInfo::NativeHandle ResultType; /** If h is-a Object and it meets the requirements described in this class' documentation, then this function returns the result of static_cast(void*), using the (void*) extracted from the Object. If the requirements are not met then NULL is returned. See the class docs for more details on the requirements of the passed-in handle. If SearchPrototypeChain is true and this object does not contain a native then the prototype chain is searched. This is generally only required when bound types are subclassed. */ ResultType operator()( v8::Handle const & h ) const { if( h.IsEmpty() || ! h->IsObject() ) return NULL; else { void * ext = NULL; v8::Handle proto(h); while( !ext && !proto.IsEmpty() && proto->IsObject() ) { v8::Local const & obj( v8::Object::Cast( *proto ) ); ext = (obj->InternalFieldCount() != InternalFieldCount) ? NULL : obj->GetPointerFromInternalField( InternalFieldIndex ); if( ! ext ) { if( !SearchPrototypeChain ) break; else proto = obj->GetPrototype(); } } return ext ? static_cast(ext) : NULL; } } }; /** A concrete JSToNative implementation (to be used as a base class) which does a type-safe conversion from JS to (T*). T is the bound native type. A pointer of this type is expected in the object-internal field specified by ObjectFieldIndex. Each value to be converted is checked for an internal field (of type v8::External) at the index specified by TypeIdFieldIndex. If (and only if) that field contains a v8::External which holds the value TypeID is the conversion considered legal. If they match but the native value stored in field ObjectFieldIndex is NOT-a-T then results are undefined. Note that the TypeID value is compared by pointer address, not by its byte contents (which may legally be NULL). If SearchPrototypeChain is true and the passed-in object contains no native T then the prototype chain is checked recursively. This is normally only necessary if the native type is allowed to be subclasses from JS code (at which point the JS 'this' is not the same exact object as the one holding the native 'this' pointer, and we need to search the prototype chain). For this all to work: the class-binding mechanism being used by the client must store the TypeID value in all new JS-created instances of T by calling SetInternalField( TypeIdFieldIndex, theTypeID ) and store the native object pointer in the field internal field ObjectFieldIndex. And then they should do: @code // in the cvv8 namespace: template <> struct JSToNative : JSToNative_ObjectWithInternalFieldsTypeSafe {}; @endcode At which point CastFromJS() will take advantage of this type check. The real docs end here. What follows is pseudorandom blather... Theoretically (i haven't tried this but i know how the underlying code works), it is possible for script code to create a condition which will lead to an invalid cast if the check performed by this class (or something equivalent) is _not_ performed: @code var x = new Native1(); var y = new Native2(); // assume y.someFunc and x.otherFunc are both bound to native functions y.someFunc = x.otherFunc; y.someFunc( ... ); // here is where it will likely end badly @endcode When y.someFunc() is called, JS will look for a 'this' object of type Native1, not Native2, because the type information related to the conversion is "stored" in the callback function itself, not in the native object. (This is a side-effect of us using templates to create InvocationCallback implementations.) It will not find a Native1, but it might (depending on how both classes are bound to JS) find a Native2 pointer and _think_ it is a Native1. And by "think it is" i mean "it will try to cast it to," but the cast is illegal in that case. In any case it would be bad news. The check performed by this class can catch that condition (and similar ones) and fail gracefully (i.e. returning a NULL instead of performing an illegal cast). */ template struct JSToNative_ObjectWithInternalFieldsTypeSafe { private: typedef char AssertIndexRanges [(InternalFieldCount>=2) && (TypeIdFieldIndex != ObjectFieldIndex) && (TypeIdFieldIndex >= 0) && (TypeIdFieldIndex < InternalFieldCount) && (ObjectFieldIndex >= 0) && (ObjectFieldIndex < InternalFieldCount) ? 1 : -1]; public: typedef typename TypeInfo::NativeHandle ResultType; /** If h is-a Object and it meets the requirements described in this class' documentation, then this function returns the result of static_cast(void*), using the (void*) extracted from the Object. If the requirements are not met then NULL is returned. See the class docs for more details on the requirements of the passed-in handle. If SearchPrototypeChain is true and the object does not contain a native then the prototype chain is searched recursively. This is generally only required when bound types are subclassed from JS code. */ ResultType operator()( v8::Handle const & h ) const { if( h.IsEmpty() || ! h->IsObject() ) return NULL; else { void const * tid = NULL; void * ext = NULL; v8::Handle proto(h); while( !ext && !proto.IsEmpty() && proto->IsObject() ) { v8::Local const & obj( v8::Object::Cast( *proto ) ); tid = (obj->InternalFieldCount() != InternalFieldCount) ? NULL : obj->GetPointerFromInternalField( TypeIdFieldIndex ); ext = (tid == TypeID) ? obj->GetPointerFromInternalField( ObjectFieldIndex ) : NULL; if( ! ext ) { if( ! SearchPrototypeChain ) break; else proto = obj->GetPrototype(); } } return ext ? static_cast(ext) : NULL; } } }; /** Specialization to convert JS values to int16_t. */ template <> struct JSToNative { typedef int16_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? static_cast(h->Int32Value()) : 0; } }; /** Specialization to convert JS values to uint16_t. */ template <> struct JSToNative { typedef uint16_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? static_cast(h->Int32Value()) : 0; } }; /** Specialization to convert JS values to int32_t. */ template <> struct JSToNative { typedef int32_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? h->Int32Value() : 0; } }; /** Specialization to convert JS values to uint32_t. */ template <> struct JSToNative { typedef uint32_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? static_cast(h->Uint32Value()) : 0; } }; /** Specialization to convert JS values to int64_t. */ template <> struct JSToNative { typedef int64_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? static_cast(h->IntegerValue()) : 0; } }; /** Specialization to convert JS values to uint64_t. */ template <> struct JSToNative { typedef uint64_t ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? static_cast(h->IntegerValue()) : 0; } }; /** Specialization to convert JS values to double. */ template <> struct JSToNative { typedef double ResultType; ResultType operator()( v8::Handle const & h ) const { return h->IsNumber() ? h->NumberValue() : 0; } }; /** Specialization to convert JS values to bool. */ template <> struct JSToNative { typedef bool ResultType; ResultType operator()( v8::Handle const & h ) const { return h->BooleanValue(); } }; /** Specialization to convert JS values to std::string. */ template <> struct JSToNative { typedef std::string ResultType; ResultType operator()( v8::Handle const & h ) const { static const std::string emptyString; v8::String::Utf8Value const utf8String( h ); const char* s = *utf8String; return s ? std::string(s, utf8String.length()) : emptyString; } }; /** Specialization necessary to avoid incorrect default behaviour for this special case. Reminder to self: we'll need a specialization like this any time we want to use a type which is returned by VALUE from JSToNative() and might be passed as a const reference as a function argument type. The vast majority of bound native types are bound internally as pointers (and don't need a specialization like this one), whereas the std::string conversion uses value semantics to simplify usage. */ template <> struct JSToNative : public JSToNative {}; #if 0 // leave this unused code here for the sake of the next guy who tries to re-add it /** Nonono! This will Cause Grief when used together with CastFromJS() because the returned pointer's lifetime cannot be guaranteed. See ArgCaster for more details on the problem. */ template <> struct JSToNative { public: typedef char const * ResultType; ResultType operator()( v8::Handle const & h ); }; #else #if 0 // it turns out no current (20110627) code uses this. // We might want to leave it in b/c that will cause compile errors // in some use cases rather than link errors ("undefined ref..."). /** Not great, but a happy medium. */ template <> struct JSToNative : JSToNative {}; #endif #endif namespace Detail { /** A kludge placeholder type for a ulong-is-not-uint64 condition on some platforms. T is ignored, but is required to avoid class-redefinition errors for the templates using this class. */ template struct UselessConversionType { }; } /** This specialization is a kludge/workaround for use in cases where (unsigned long int) is: 1) The same type as the platform's pointer type. 2) Somehow NOT the same as one of the standard uintNN_t types. 3) Used in CastToJS() or CastFromJS() calls. If ulong and uint64 are the same type then this specialization is a no-op (it generates a converter for a type which will never be converted), otherwords it performs a numeric conversion. */ template <> struct NativeToJS< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, unsigned long >::Type > : Detail::NativeToJS_int_big { }; /** This is a kludge/workaround for use in cases where (unsigned long int) is: 1) The same type as the platform's pointer type. 2) Somehow NOT the same as one of the standard uintNN_t types. 3) Used in CastToJS() or CastFromJS() calls. If ulong and uint64 are the same type then this specialization is a no-op (it generates a converter for a type which will never be converted), otherwords it performs a numeric conversion. */ template <> struct JSToNative< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, unsigned long >::Type > : JSToNative { }; /** See the equivalent NativeToJS kludge for unsigned long. */ template <> struct NativeToJS< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, long >::Type > : Detail::NativeToJS_int_big { }; /** See the equivalent JSToNative kludge for unsigned long. */ template <> struct JSToNative< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, long >::Type > : JSToNative { }; #if CVV8_CONFIG_HAS_LONG_LONG /** See the equivalent JSToNative kludge for unsigned long. Added 20100606 to please the sqlite3 plugin, where sqlite3_int64 collides with (long long) on some platforms and causes an invalid conversion compile-time error. */ template <> struct JSToNative< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, long long int >::Type > : JSToNative { }; /** See the equivalent JSToNative kludge for unsigned long. Added 20101126 to please the sqlite3 plugin, where sqlite3_int64 collides with (long long) on some platforms and causes a link-time error. */ template <> struct NativeToJS< tmp::IfElse< tmp::SameType::Value, Detail::UselessConversionType, long long int >::Type > : Detail::NativeToJS_int_big { }; #endif /** Converts h to an object of type NT, using JSToNative to do the conversion. */ template typename JSToNative::ResultType CastFromJS( v8::Handle const & h ) { typedef JSToNative F; return F()( h ); } /** Convenience instance of JSToNative. */ static const JSToNative JSToInt16 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToUInt16 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToInt32 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToUInt32 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToInt64 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToUInt64 = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToDouble = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToBool = JSToNative(); /** Convenience instance of JSToNative. */ static const JSToNative JSToStdString = JSToNative(); /** A utility to add properties to a JS v8::Object or v8::ObjectTemplate. ObjectType must be either v8::Object or v8::ObjectTemplate. It _might_ work in limited context with v8::Array, but that is untested. ObjectType is intended to be v8::Object or v8::ObjectTemplate, but Object subclasses, e.g. v8::Array and v8::Function, "should" work as well. It is intended to be used like this: \code v8::Handle obj = ...; ObjectPropSetter set(obj); set("propOne", CastToJS(32) ) ("propTwo", ... ) (32, ... ) ("func1", anInvocationCallback ) ; \endcode */ template ::Value, v8::Handle, v8::Handle >::Type > class ObjectPropSetter { private: v8::Handle const target; public: /** Initializes this object to use the given array as its append target. Results are undefined if target is not a valid Object. */ explicit ObjectPropSetter( v8::Handle< ObjectType > const & obj ) :target(obj) {} ~ObjectPropSetter(){} /** Adds an arbtirary property to the target object. */ inline ObjectPropSetter & Set( KeyType const & key, v8::Handle const & v ) { this->target->Set(key->ToString(), CastToJS(v)); return *this; } /** Adds an arbtirary property to the target object. */ inline ObjectPropSetter & Set( char const * key, v8::Handle const & v ) { this->target->Set( v8::String::New(key), CastToJS(v)); return *this; } /** Adds an arbitrary property to the target object using CastToJS(v). */ template inline ObjectPropSetter & operator()( KeyType const & key, T const & v ) { this->target->Set(key, CastToJS(v)); return *this; } /** Adds a numeric property to the target object. */ template inline ObjectPropSetter & operator()( int32_t ndx, T const & v ) { return this->Set( v8::Integer::New(ndx), CastToJS(v) ); } /** Adds a string-keyed property to the target object. Note that if key is NULL, the v8::String constructor will crash your app. (Good luck with that!) */ template inline ObjectPropSetter & operator()( char const * key, T const & v ) { return this->Set( v8::String::New(key), CastToJS(v) ); } /** Adds the given function as a member of the target object. */ inline ObjectPropSetter & operator()( char const * name, v8::InvocationCallback pf ) { return this->Set( name, v8::FunctionTemplate::New(pf)->GetFunction() ); } /** Returns this object's JS object. */ v8::Handle< v8::Object > Object() const { return this->target; } }; /** NativeToJS classes which act on list types compatible with the STL can subclass this to get an implementation. */ template struct NativeToJS_list { v8::Handle operator()( ListT const & li ) const { typedef typename ListT::const_iterator IT; IT it = li.begin(); const size_t sz = li.size(); #if 1 v8::Handle rv( v8::Array::New( static_cast(sz) ) ); for( int i = 0; li.end() != it; ++it, ++i ) { rv->Set( v8::Integer::New(i), CastToJS( *it ) ); } return rv; #else ObjectPropSetter app(Array::New( static_cast(sz) )); for( int32_t i = 0; li.end() != it; ++it, ++i ) { app( i, CastToJS( *it ) ); } return app.Object(); #endif } }; /** Partial specialization for std::list<>. */ template struct NativeToJS< std::list > : NativeToJS_list< std::list > {}; /** Partial specialization for std::vector<>. */ template struct NativeToJS< std::vector > : NativeToJS_list< std::vector > {}; /** NativeToJS classes which act on map types compatible with the STL can subclass this to get an implementation. Both the key and mapped types of the given Map Type must be converitible to v8 types using CastToJS(). */ template struct NativeToJS_map { v8::Handle operator()( MapT const & li ) const { typedef typename MapT::const_iterator IT; IT it( li.begin() ); v8::Handle rv( v8::Object::New() ); for( int i = 0; li.end() != it; ++it, ++i ) { rv->Set( CastToJS( (*it).first ), CastToJS( (*it).second ) ); } return rv; } }; /** Partial specialization for std::map<>. */ template struct NativeToJS< std::map > : NativeToJS_map< std::map > {}; /** A base class for JSToNative specializations. ListT must be compatible with std::list and std::vector, namely: - Must support push_back( ListT::value_type ). - Must define value_type typedef or the second template argument must be specified for this template. It is technically legal for ValueType to differ from ListT::value_type if ListT::push_back(JSToNative::ResultType) is legal. e.g. if ListT is std::vector and we want to truncate the values we could use, e.g. int32_t as the ValueType. */ template struct JSToNative_list { typedef ListT ResultType; /** Converts jv to a ListT object. If jv->IsArray() then the returned object is populated from jv, otherwise the returned object is empty. Since it is legal for an array to be empty, it is not generically possible to know if this routine got an empty Array object or a non-Array object. */ ResultType operator()( v8::Handle jv ) const { //typedef typename ListT::value_type VALT; typedef ValueType VALT; ListT li; if( jv.IsEmpty() || ! jv->IsArray() ) return li; v8::Handle ar( v8::Array::Cast(*jv) ); uint32_t ndx = 0; for( ; ar->Has(ndx); ++ndx ) { li.push_back( CastFromJS( ar->Get(v8::Integer::New(ndx)) ) ); } return li; } }; /** Partial specialization for std::list<>. */ template struct JSToNative< std::list > : JSToNative_list< std::list > {}; /** Partial specialization for std::vector<>. */ template struct JSToNative< std::vector > : JSToNative_list< std::vector > {}; #if 0 // untested code /** UNTESTED! Intended as a base class for JSToNative specializations which proxy a std::map-like map. */ template struct JSToNative_map { typedef MapT ResultType; /** Converts jv to a MapT object. If jv->IsObject() then the returned object is populated from jv, otherwise the returned object is empty. Since it is legal for an object to be empty, it is not generically possible to know if this routine got an empty Object or a non-Object handle. */ ResultType operator()( v8::Handle jv ) const { typedef ValueType VALT; MapT map; if( jv.IsEmpty() || ! jv->IsObject() ) return map; Local