V8SVGPODTypeWrapper.h [plain text]
#ifndef V8SVGPODTypeWrapper_h
#define V8SVGPODTypeWrapper_h
#if ENABLE(SVG)
#include "SVGElement.h"
#include "SVGList.h"
#include "V8Proxy.h"
#include <wtf/Assertions.h>
#include <wtf/HashMap.h>
#include <wtf/RefCounted.h>
#include <wtf/StdLibExtras.h>
namespace WebCore {
template<typename PODType>
class V8SVGPODTypeWrapper : public RefCounted<V8SVGPODTypeWrapper<PODType> > {
public:
V8SVGPODTypeWrapper() { }
virtual ~V8SVGPODTypeWrapper() { }
virtual operator PODType() = 0;
virtual void commitChange(PODType, SVGElement*) = 0;
};
template<typename PODType>
class V8SVGPODTypeWrapperCreatorForList : public V8SVGPODTypeWrapper<PODType> {
public:
typedef PODType (SVGPODListItem<PODType>::*GetterMethod)() const;
typedef void (SVGPODListItem<PODType>::*SetterMethod)(PODType);
V8SVGPODTypeWrapperCreatorForList(SVGPODListItem<PODType>* creator, const QualifiedName& attributeName)
: m_creator(creator)
, m_getter(&SVGPODListItem<PODType>::value)
, m_setter(&SVGPODListItem<PODType>::setValue)
, m_associatedAttributeName(attributeName)
{
ASSERT(m_creator);
ASSERT(m_getter);
ASSERT(m_setter);
}
virtual ~V8SVGPODTypeWrapperCreatorForList() { }
virtual operator PODType() { return (m_creator.get()->*m_getter)(); }
virtual void commitChange(PODType type, SVGElement* context)
{
if (!m_setter)
return;
(m_creator.get()->*m_setter)(type);
if (context)
context->svgAttributeChanged(m_associatedAttributeName);
}
private:
RefPtr<SVGPODListItem<PODType> > m_creator;
GetterMethod m_getter;
SetterMethod m_setter;
const QualifiedName& m_associatedAttributeName;
};
template<typename PODType>
class V8SVGStaticPODTypeWrapper : public V8SVGPODTypeWrapper<PODType> {
public:
V8SVGStaticPODTypeWrapper(PODType type)
: m_podType(type)
{
}
virtual ~V8SVGStaticPODTypeWrapper() { }
virtual operator PODType() { return m_podType; }
virtual void commitChange(PODType type, SVGElement*)
{
m_podType = type;
}
private:
PODType m_podType;
};
template<typename PODType, typename ParentTypeArg>
class V8SVGStaticPODTypeWrapperWithPODTypeParent : public V8SVGStaticPODTypeWrapper<PODType> {
public:
typedef V8SVGPODTypeWrapper<ParentTypeArg> ParentType;
V8SVGStaticPODTypeWrapperWithPODTypeParent(PODType type, ParentType* parent)
: V8SVGStaticPODTypeWrapper<PODType>(type)
, m_parentType(parent)
{
}
virtual void commitChange(PODType type, SVGElement* context)
{
V8SVGStaticPODTypeWrapper<PODType>::commitChange(type, context);
m_parentType->commitChange(ParentTypeArg(type), context);
}
private:
RefPtr<ParentType> m_parentType;
};
template<typename PODType, typename ParentType>
class V8SVGStaticPODTypeWrapperWithParent : public V8SVGPODTypeWrapper<PODType> {
public:
typedef PODType (ParentType::*GetterMethod)() const;
typedef void (ParentType::*SetterMethod)(const PODType&);
V8SVGStaticPODTypeWrapperWithParent(ParentType* parent, GetterMethod getter, SetterMethod setter)
: m_parent(parent)
, m_getter(getter)
, m_setter(setter)
{
ASSERT(m_parent);
ASSERT(m_getter);
ASSERT(m_setter);
}
virtual operator PODType()
{
return (m_parent.get()->*m_getter)();
}
virtual void commitChange(PODType type, SVGElement* context)
{
(m_parent.get()->*m_setter)(type);
}
private:
RefPtr<ParentType> m_parent;
GetterMethod m_getter;
SetterMethod m_setter;
};
template<typename PODType, typename PODTypeCreator>
class V8SVGDynamicPODTypeWrapper : public V8SVGPODTypeWrapper<PODType> {
public:
typedef PODType (PODTypeCreator::*GetterMethod)() const;
typedef void (PODTypeCreator::*SetterMethod)(PODType);
typedef void (*CacheRemovalCallback)(V8SVGPODTypeWrapper<PODType>*);
V8SVGDynamicPODTypeWrapper(PODTypeCreator* creator, GetterMethod getter, SetterMethod setter, CacheRemovalCallback cacheRemovalCallback)
: m_creator(creator)
, m_getter(getter)
, m_setter(setter)
, m_cacheRemovalCallback(cacheRemovalCallback)
{
ASSERT(creator);
ASSERT(getter);
ASSERT(setter);
ASSERT(cacheRemovalCallback);
}
virtual ~V8SVGDynamicPODTypeWrapper() {
ASSERT(m_cacheRemovalCallback);
(*m_cacheRemovalCallback)(this);
}
virtual operator PODType() { return (m_creator.get()->*m_getter)(); }
virtual void commitChange(PODType type, SVGElement* context)
{
(m_creator.get()->*m_setter)(type);
if (context)
context->svgAttributeChanged(m_creator->associatedAttributeName());
}
private:
RefPtr<PODTypeCreator> m_creator;
GetterMethod m_getter;
SetterMethod m_setter;
CacheRemovalCallback m_cacheRemovalCallback;
};
template<typename PODType, typename PODTypeCreator>
struct PODTypeWrapperCacheInfo {
typedef PODType (PODTypeCreator::*GetterMethod)() const;
typedef void (PODTypeCreator::*SetterMethod)(PODType);
PODTypeWrapperCacheInfo()
: creator(0)
, getter(0)
, setter(0)
{ }
explicit PODTypeWrapperCacheInfo(WTF::HashTableDeletedValueType)
: creator(reinterpret_cast<PODTypeCreator*>(-1))
, getter(0)
, setter(0)
{
}
bool isHashTableDeletedValue() const
{
return creator == reinterpret_cast<PODTypeCreator*>(-1);
}
PODTypeWrapperCacheInfo(PODTypeCreator* _creator, GetterMethod _getter, SetterMethod _setter)
: creator(_creator)
, getter(_getter)
, setter(_setter)
{
ASSERT(creator);
ASSERT(getter);
}
bool operator==(const PODTypeWrapperCacheInfo& other) const
{
return creator == other.creator && getter == other.getter && setter == other.setter;
}
PODTypeCreator* creator;
GetterMethod getter;
SetterMethod setter;
};
template<typename PODType, typename PODTypeCreator>
struct PODTypeWrapperCacheInfoHash {
static unsigned hash(const PODTypeWrapperCacheInfo<PODType, PODTypeCreator>& info)
{
unsigned creator = reinterpret_cast<unsigned>(info.creator);
unsigned getter = reinterpret_cast<unsigned>(*(void**)&info.getter);
unsigned setter = reinterpret_cast<unsigned>(*(void**)&info.setter);
return (creator * 13) + getter ^ (setter >> 2);
}
static bool equal(const PODTypeWrapperCacheInfo<PODType, PODTypeCreator>& a, const PODTypeWrapperCacheInfo<PODType, PODTypeCreator>& b)
{
return a == b;
}
static const bool safeToCompareToEmptyOrDeleted = true;
};
template<typename PODType, typename PODTypeCreator>
struct PODTypeWrapperCacheInfoTraits : WTF::GenericHashTraits<PODTypeWrapperCacheInfo<PODType, PODTypeCreator> > {
typedef PODTypeWrapperCacheInfo<PODType, PODTypeCreator> CacheInfo;
static const bool emptyValueIsZero = true;
static const bool needsDestruction = false;
static const CacheInfo& emptyValue()
{
DEFINE_STATIC_LOCAL(CacheInfo, key, ());
return key;
}
static void constructDeletedValue(CacheInfo& slot)
{
new (&slot) CacheInfo(WTF::HashTableDeletedValue);
}
static bool isDeletedValue(const CacheInfo& value)
{
return value.isHashTableDeletedValue();
}
};
template<typename PODType, typename PODTypeCreator>
class V8SVGDynamicPODTypeWrapperCache {
public:
typedef PODType (PODTypeCreator::*GetterMethod)() const;
typedef void (PODTypeCreator::*SetterMethod)(PODType);
typedef PODTypeWrapperCacheInfo<PODType, PODTypeCreator> CacheInfo;
typedef PODTypeWrapperCacheInfoHash<PODType, PODTypeCreator> CacheInfoHash;
typedef PODTypeWrapperCacheInfoTraits<PODType, PODTypeCreator> CacheInfoTraits;
typedef V8SVGPODTypeWrapper<PODType> WrapperBase;
typedef V8SVGDynamicPODTypeWrapper<PODType, PODTypeCreator> DynamicWrapper;
typedef HashMap<CacheInfo, DynamicWrapper*, CacheInfoHash, CacheInfoTraits> DynamicWrapperHashMap;
typedef typename DynamicWrapperHashMap::const_iterator DynamicWrapperHashMapIterator;
static DynamicWrapperHashMap& dynamicWrapperHashMap()
{
DEFINE_STATIC_LOCAL(DynamicWrapperHashMap, dynamicWrapperHashMap, ());
return dynamicWrapperHashMap;
}
static WrapperBase* lookupOrCreateWrapper(PODTypeCreator* creator, GetterMethod getter, SetterMethod setter)
{
DynamicWrapperHashMap& map(dynamicWrapperHashMap());
CacheInfo info(creator, getter, setter);
if (map.contains(info))
return map.get(info);
DynamicWrapper* wrapper = new V8SVGDynamicPODTypeWrapper<PODType, PODTypeCreator>(creator, getter, setter, forgetWrapper);
map.set(info, wrapper);
return wrapper;
}
static void forgetWrapper(V8SVGPODTypeWrapper<PODType>* wrapper)
{
DynamicWrapperHashMap& map(dynamicWrapperHashMap());
DynamicWrapperHashMapIterator it = map.begin();
DynamicWrapperHashMapIterator end = map.end();
for (; it != end; ++it) {
if (it->second != wrapper)
continue;
map.remove(it->first);
break;
}
}
};
class V8SVGPODTypeUtil {
public:
template <class P>
static P toSVGPODType(V8ClassIndex::V8WrapperType type, v8::Handle<v8::Value> object, bool& ok);
};
template <class P>
P V8SVGPODTypeUtil::toSVGPODType(V8ClassIndex::V8WrapperType type, v8::Handle<v8::Value> object, bool& ok)
{
void *wrapper = V8DOMWrapper::convertToSVGPODTypeImpl(type, object);
if (wrapper == NULL) {
ok = false;
return P();
} else {
ok = true;
return *static_cast<V8SVGPODTypeWrapper<P>*>(wrapper);
}
}
}
#endif // ENABLE(SVG)
#endif // V8SVGPODTypeWrapper_h