Update more core classes to use OVERRIDE / FINAL when needed

Source/core/frame/animation/CSSPropertyAnimation.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 336 matching lines @@
 
     virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
     {
         (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<T>::m_getter)(), (b->*PropertyWrapperGetter<T>::m_getter)(), progress));
     }
 
 protected:
     void (RenderStyle::*m_setter)(T);
 };
 
-class NonNegativeLengthWrapper : public PropertyWrapper<Length> {
+class NonNegativeLengthWrapper FINAL : public PropertyWrapper<Length> {
 public:
     NonNegativeLengthWrapper(CSSPropertyID prop, Length (RenderStyle::*getter)() const, void (RenderStyle::*setter)(Length))
     : PropertyWrapper<Length>(prop, getter, setter)
     {
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         Length from = (a->*PropertyWrapperGetter<Length>::m_getter)();
         Length to = (b->*PropertyWrapperGetter<Length>::m_getter)();
         (dst->*PropertyWrapper<Length>::m_setter)(to.blend(from, progress, ValueRangeNonNegative));
     }
 };
 
 template <typename T>
 class RefCountedPropertyWrapper : public PropertyWrapperGetter<T*> {
 public:
@@ skipping 37 matching lines @@
 };
 
 class PropertyWrapperShape : public RefCountedPropertyWrapper<ShapeValue> {
 public:
     PropertyWrapperShape(CSSPropertyID prop, ShapeValue* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<ShapeValue>))
         : RefCountedPropertyWrapper<ShapeValue>(prop, getter, setter)
     {
     }
 };
 
-class StyleImagePropertyWrapper : public RefCountedPropertyWrapper<StyleImage> {
+class StyleImagePropertyWrapper FINAL : public RefCountedPropertyWrapper<StyleImage> {
 public:
     StyleImagePropertyWrapper(CSSPropertyID prop, StyleImage* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<StyleImage>))
         : RefCountedPropertyWrapper<StyleImage>(prop, getter, setter)
     {
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
        // If the style pointers are the same, don't bother doing the test.
        // If either is null, return false. If both are null, return true.
        if (a == b)
            return true;
        if (!a || !b)
             return false;
 
         StyleImage* imageA = (a->*m_getter)();
         StyleImage* imageB = (b->*m_getter)();
         return StyleImage::imagesEquivalent(imageA, imageB);
     }
 };
 
-class PropertyWrapperColor : public PropertyWrapperGetter<Color> {
+class PropertyWrapperColor FINAL : public PropertyWrapperGetter<Color> {
 public:
     PropertyWrapperColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&))
         : PropertyWrapperGetter<Color>(prop, getter)
         , m_setter(setter)
     {
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<Color>::m_getter)(), (b->*PropertyWrapperGetter<Color>::m_getter)(), progress));
     }
 
 protected:
     void (RenderStyle::*m_setter)(const Color&);
 };
 
-class PropertyWrapperAcceleratedOpacity : public PropertyWrapper<float> {
+class PropertyWrapperAcceleratedOpacity FINAL : public PropertyWrapper<float> {
 public:
     PropertyWrapperAcceleratedOpacity()
         : PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity)
     {
     }
 
-    virtual bool animationIsAccelerated() const { return true; }
+    virtual bool animationIsAccelerated() const OVERRIDE { return true; }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         float fromOpacity = a->opacity();
 
         // This makes sure we put the object being animated into a RenderLayer during the animation
         dst->setOpacity(blendFunc(anim, (fromOpacity == 1) ? 0.999999f : fromOpacity, b->opacity(), progress));
     }
 };
 
-class PropertyWrapperAcceleratedTransform : public PropertyWrapper<const TransformOperations&> {
+class PropertyWrapperAcceleratedTransform FINAL : public PropertyWrapper<const TransformOperations&> {
 public:
     PropertyWrapperAcceleratedTransform()
         : PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform)
     {
     }
 
-    virtual bool animationIsAccelerated() const { return true; }
+    virtual bool animationIsAccelerated() const OVERRIDE { return true; }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         dst->setTransform(blendFunc(anim, a->transform(), b->transform(), progress));
     }
 };
 
-class PropertyWrapperAcceleratedFilter : public PropertyWrapper<const FilterOperations&> {
+class PropertyWrapperAcceleratedFilter FINAL : public PropertyWrapper<const FilterOperations&> {
 public:
     PropertyWrapperAcceleratedFilter()
         : PropertyWrapper<const FilterOperations&>(CSSPropertyWebkitFilter, &RenderStyle::filter, &RenderStyle::setFilter)
     {
     }
 
-    virtual bool animationIsAccelerated() const { return true; }
+    virtual bool animationIsAccelerated() const OVERRIDE { return true; }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         dst->setFilter(blendFunc(anim, a->filter(), b->filter(), progress));
     }
 };
 
-class PropertyWrapperShadow : public AnimationPropertyWrapperBase {
+class PropertyWrapperShadow FINAL : public AnimationPropertyWrapperBase {
 public:
     PropertyWrapperShadow(CSSPropertyID prop, ShadowList* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(PassRefPtr<ShadowList>))
         : AnimationPropertyWrapperBase(prop)
         , m_getter(getter)
         , m_setter(setter)
     {
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         const ShadowList* shadowA = (a->*m_getter)();
         const ShadowList* shadowB = (b->*m_getter)();
         if (shadowA == shadowB)
             return true;
         if (shadowA && shadowB)
             return *shadowA == *shadowB;
         return false;
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         (dst->*m_setter)(ShadowList::blend((a->*m_getter)(), (b->*m_getter)(), progress));
     }
 
     ShadowList* (RenderStyle::*m_getter)() const;
     void (RenderStyle::*m_setter)(PassRefPtr<ShadowList>);
 };
 
-class PropertyWrapperMaybeInvalidColor : public AnimationPropertyWrapperBase {
+class PropertyWrapperMaybeInvalidColor FINAL : public AnimationPropertyWrapperBase {
 public:
     PropertyWrapperMaybeInvalidColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&))
         : AnimationPropertyWrapperBase(prop)
         , m_getter(getter)
         , m_setter(setter)
     {
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         Color fromColor = (a->*m_getter)();
         Color toColor = (b->*m_getter)();
 
         if (!fromColor.isValid() && !toColor.isValid())
             return true;
 
         if (!fromColor.isValid())
             fromColor = a->color();
         if (!toColor.isValid())
             toColor = b->color();
 
         return fromColor == toColor;
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         Color fromColor = (a->*m_getter)();
         Color toColor = (b->*m_getter)();
 
         if (!fromColor.isValid() && !toColor.isValid())
             return;
 
         if (!fromColor.isValid())
             fromColor = a->color();
         if (!toColor.isValid())
             toColor = b->color();
         (dst->*m_setter)(blendFunc(anim, fromColor, toColor, progress));
     }
 
 private:
     Color (RenderStyle::*m_getter)() const;
     void (RenderStyle::*m_setter)(const Color&);
 };
 
 
 enum MaybeInvalidColorTag { MaybeInvalidColor };
-class PropertyWrapperVisitedAffectedColor : public AnimationPropertyWrapperBase {
+class PropertyWrapperVisitedAffectedColor FINAL : public AnimationPropertyWrapperBase {
 public:
     PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&),
         Color (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&))
         : AnimationPropertyWrapperBase(prop)
         , m_wrapper(adoptPtr(new PropertyWrapperColor(prop, getter, setter)))
         , m_visitedWrapper(adoptPtr(new PropertyWrapperColor(prop, visitedGetter, visitedSetter)))
     {
     }
     PropertyWrapperVisitedAffectedColor(CSSPropertyID prop, MaybeInvalidColorTag, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&),
         Color (RenderStyle::*visitedGetter)() const, void (RenderStyle::*visitedSetter)(const Color&))
         : AnimationPropertyWrapperBase(prop)
         , m_wrapper(adoptPtr(new PropertyWrapperMaybeInvalidColor(prop, getter, setter)))
         , m_visitedWrapper(adoptPtr(new PropertyWrapperMaybeInvalidColor(prop, visitedGetter, visitedSetter)))
     {
     }
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         return m_wrapper->equals(a, b) && m_visitedWrapper->equals(a, b);
     }
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         m_wrapper->blend(anim, dst, a, b, progress);
         m_visitedWrapper->blend(anim, dst, a, b, progress);
     }
 
 private:
     OwnPtr<AnimationPropertyWrapperBase> m_wrapper;
     OwnPtr<AnimationPropertyWrapperBase> m_visitedWrapper;
 };
 
@@ skipping 28 matching lines @@
        if (!a || !b)
             return false;
         return (a->*m_getter)() == (b->*m_getter)();
     }
 
 protected:
     T (FillLayer::*m_getter)() const;
 };
 
 template <typename T>
-class FillLayerPropertyWrapper : public FillLayerPropertyWrapperGetter<T> {
+class FillLayerPropertyWrapper FINAL : public FillLayerPropertyWrapperGetter<T> {
 public:
     FillLayerPropertyWrapper(T (FillLayer::*getter)() const, void (FillLayer::*setter)(T))
         : FillLayerPropertyWrapperGetter<T>(getter)
         , m_setter(setter)
     {
     }
 
-    virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const
+    virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const OVERRIDE
     {
         (dst->*m_setter)(blendFunc(anim, (a->*FillLayerPropertyWrapperGetter<T>::m_getter)(), (b->*FillLayerPropertyWrapperGetter<T>::m_getter)(), progress));
     }
 
 protected:
     void (FillLayer::*m_setter)(T);
 };
 
 template <typename T>
 class FillLayerRefCountedPropertyWrapper : public FillLayerPropertyWrapperGetter<T*> {
 public:
     FillLayerRefCountedPropertyWrapper(T* (FillLayer::*getter)() const, void (FillLayer::*setter)(PassRefPtr<T>))
         : FillLayerPropertyWrapperGetter<T*>(getter)
         , m_setter(setter)
     {
     }
 
     virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const
     {
         (dst->*m_setter)(blendFunc(anim, (a->*FillLayerPropertyWrapperGetter<T*>::m_getter)(), (b->*FillLayerPropertyWrapperGetter<T*>::m_getter)(), progress));
     }
 
 protected:
     void (FillLayer::*m_setter)(PassRefPtr<T>);
 };
 
-class FillLayerStyleImagePropertyWrapper : public FillLayerRefCountedPropertyWrapper<StyleImage> {
+class FillLayerStyleImagePropertyWrapper FINAL : public FillLayerRefCountedPropertyWrapper<StyleImage> {
 public:
     FillLayerStyleImagePropertyWrapper(StyleImage* (FillLayer::*getter)() const, void (FillLayer::*setter)(PassRefPtr<StyleImage>))
         : FillLayerRefCountedPropertyWrapper<StyleImage>(getter, setter)
     {
     }
 
-    virtual bool equals(const FillLayer* a, const FillLayer* b) const
+    virtual bool equals(const FillLayer* a, const FillLayer* b) const OVERRIDE
     {
        // If the style pointers are the same, don't bother doing the test.
        // If either is null, return false. If both are null, return true.
        if (a == b)
            return true;
        if (!a || !b)
             return false;
 
         StyleImage* imageA = (a->*m_getter)();
         StyleImage* imageB = (b->*m_getter)();
         return StyleImage::imagesEquivalent(imageA, imageB);
     }
 };
 
 
-class FillLayersPropertyWrapper : public AnimationPropertyWrapperBase {
+class FillLayersPropertyWrapper FINAL : public AnimationPropertyWrapperBase {
 public:
     typedef const FillLayer* (RenderStyle::*LayersGetter)() const;
     typedef FillLayer* (RenderStyle::*LayersAccessor)();
 
     FillLayersPropertyWrapper(CSSPropertyID prop, LayersGetter getter, LayersAccessor accessor)
         : AnimationPropertyWrapperBase(prop)
         , m_layersGetter(getter)
         , m_layersAccessor(accessor)
     {
         switch (prop) {
@@ skipping 11 matching lines @@
             m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<LengthSize>(&FillLayer::sizeLength, &FillLayer::setSizeLength);
             break;
         case CSSPropertyBackgroundImage:
             m_fillLayerPropertyWrapper = new FillLayerStyleImagePropertyWrapper(&FillLayer::image, &FillLayer::setImage);
             break;
         default:
             break;
         }
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         const FillLayer* fromLayer = (a->*m_layersGetter)();
         const FillLayer* toLayer = (b->*m_layersGetter)();
 
         while (fromLayer && toLayer) {
             if (!m_fillLayerPropertyWrapper->equals(fromLayer, toLayer))
                 return false;
 
             fromLayer = fromLayer->next();
             toLayer = toLayer->next();
         }
 
         return true;
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         const FillLayer* aLayer = (a->*m_layersGetter)();
         const FillLayer* bLayer = (b->*m_layersGetter)();
         FillLayer* dstLayer = (dst->*m_layersAccessor)();
 
         while (aLayer && bLayer && dstLayer) {
             m_fillLayerPropertyWrapper->blend(anim, dstLayer, aLayer, bLayer, progress);
             aLayer = aLayer->next();
             bLayer = bLayer->next();
             dstLayer = dstLayer->next();
         }
     }
 
 private:
     FillLayerAnimationPropertyWrapperBase* m_fillLayerPropertyWrapper;
 
     LayersGetter m_layersGetter;
     LayersAccessor m_layersAccessor;
 };
 
-class ShorthandPropertyWrapper : public AnimationPropertyWrapperBase {
+class ShorthandPropertyWrapper FINAL : public AnimationPropertyWrapperBase {
 public:
     ShorthandPropertyWrapper(CSSPropertyID property, const StylePropertyShorthand& shorthand)
         : AnimationPropertyWrapperBase(property)
     {
         for (unsigned i = 0; i < shorthand.length(); ++i) {
             AnimationPropertyWrapperBase* wrapper = wrapperForProperty(shorthand.properties()[i]);
             if (wrapper)
                 m_propertyWrappers.append(wrapper);
         }
     }
 
-    virtual bool isShorthandWrapper() const { return true; }
+    virtual bool isShorthandWrapper() const OVERRIDE { return true; }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         Vector<AnimationPropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end();
         for (Vector<AnimationPropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it) {
             if (!(*it)->equals(a, b))
                 return false;
         }
         return true;
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         Vector<AnimationPropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end();
         for (Vector<AnimationPropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it)
             (*it)->blend(anim, dst, a, b, progress);
     }
 
     const Vector<AnimationPropertyWrapperBase*> propertyWrappers() const { return m_propertyWrappers; }
 
 private:
     Vector<AnimationPropertyWrapperBase*> m_propertyWrappers;
 };
 
-class PropertyWrapperFlex : public AnimationPropertyWrapperBase {
+class PropertyWrapperFlex FINAL : public AnimationPropertyWrapperBase {
 public:
     PropertyWrapperFlex()
         : AnimationPropertyWrapperBase(CSSPropertyFlex)
     {
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         // If the style pointers are the same, don't bother doing the test.
         // If either is null, return false. If both are null, return true.
         if ((!a && !b) || a == b)
             return true;
         if (!a || !b)
             return false;
 
         return a->flexBasis() == b->flexBasis() && a->flexGrow() == b->flexGrow() && a->flexShrink() == b->flexShrink();
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         dst->setFlexBasis(blendFunc(anim, a->flexBasis(), b->flexBasis(), progress));
         dst->setFlexGrow(blendFunc(anim, a->flexGrow(), b->flexGrow(), progress));
         dst->setFlexShrink(blendFunc(anim, a->flexShrink(), b->flexShrink(), progress));
     }
 };
 
-class PropertyWrapperSVGPaint : public AnimationPropertyWrapperBase {
+class PropertyWrapperSVGPaint FINAL : public AnimationPropertyWrapperBase {
 public:
     PropertyWrapperSVGPaint(CSSPropertyID prop, const SVGPaint::SVGPaintType& (RenderStyle::*paintTypeGetter)() const, Color (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&))
         : AnimationPropertyWrapperBase(prop)
         , m_paintTypeGetter(paintTypeGetter)
         , m_getter(getter)
         , m_setter(setter)
     {
     }
 
-    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const
+    virtual bool equals(const RenderStyle* a, const RenderStyle* b) const OVERRIDE
     {
         if ((a->*m_paintTypeGetter)() != (b->*m_paintTypeGetter)())
             return false;
 
         // We only support animations between SVGPaints that are pure Color values.
         // For everything else we must return true for this method, otherwise
         // we will try to animate between values forever.
         if ((a->*m_paintTypeGetter)() == SVGPaint::SVG_PAINTTYPE_RGBCOLOR) {
             Color fromColor = (a->*m_getter)();
             Color toColor = (b->*m_getter)();
 
             if (!fromColor.isValid() && !toColor.isValid())
                 return true;
 
             if (!fromColor.isValid())
                 fromColor = Color();
             if (!toColor.isValid())
                 toColor = Color();
 
             return fromColor == toColor;
         }
         return true;
     }
 
-    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const
+    virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const OVERRIDE
     {
         if ((a->*m_paintTypeGetter)() != SVGPaint::SVG_PAINTTYPE_RGBCOLOR
             || (b->*m_paintTypeGetter)() != SVGPaint::SVG_PAINTTYPE_RGBCOLOR)
             return;
 
         Color fromColor = (a->*m_getter)();
         Color toColor = (b->*m_getter)();
 
         if (!fromColor.isValid() && !toColor.isValid())
             return;
@@ skipping 306 matching lines @@
 }
 
 int CSSPropertyAnimation::getNumProperties()
 {
     ensurePropertyMap();
 
     return gPropertyWrappers->size();
 }
 
 }