PhysicsBallJointUnrecPtr PhysicsBallJoint::create(PhysicsWorldUnrecPtr w) { PhysicsBallJointUnrecPtr fc; if(getClassType().getPrototype() != NULL) { fc = dynamic_pointer_cast<PhysicsBallJoint>( getClassType().getPrototype()-> shallowCopy()); } if(fc != NULL) { fc->setWorld(w); } return fc; }
NORI_NAMESPACE_BEGIN void NoriObject::addChild(NoriObject *) { throw NoriException(QString("NoriObject::addChild() is not " "implemented for objects of type '%1'!").arg( classTypeName(getClassType()))); }
OSG_BEGIN_NAMESPACE // Documentation for this class is emitted in the // OSGImageFieldEditorBase.cpp file. // To modify it, please change the .fcd file (OSGImageFieldEditor.fcd) and // regenerate the base file. /***************************************************************************\ * Class variables * \***************************************************************************/ /***************************************************************************\ * Class methods * \***************************************************************************/ void ImageFieldEditor::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::FactoryPost) { FieldEditorFactory::the()->setSingleDefaultEditor(&FieldTraits<Image*>::getType(), &getClassType()); FieldEditorFactory::the()->setEditorType(&FieldTraits<Image*>::getType(), &getClassType(), "ImageLoader"); } }
OSG_USING_NAMESPACE // Documentation for this class is emited in the // OSGScreenLODBase.cpp file. // To modify it, please change the .fcd file (OSGScreenLOD.fcd) and // regenerate the base file. /***************************************************************************\ * Class variables * \***************************************************************************/ /***************************************************************************\ * Class methods * \***************************************************************************/ void ScreenLOD::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::SystemPost) { typedef ActionBase::ResultE (ScreenLOD::*Callback)(Action *); Callback enter = &ScreenLOD::renderEnter; RenderAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>(enter)); } }
const TypeSpec& TraceTree::getClassTypeSpec(void) { static TypeSpec revTypeSpec = TypeSpec( getClassType(), new TypeSpec( WorkspaceToCoreWrapperObject<RevBayesCore::TraceTree>::getClassTypeSpec() ) ); return revTypeSpec; }
OSG_USING_NAMESPACE /***************************************************************************\ * Description * \***************************************************************************/ /*! \class OSG::PlaneMoveManipulator * The MoveHandle is used for moving objects. It consist of three axis which * can be picked and translated and one center box to translate freely in 3D. */ /***************************************************************************\ * Class variables * \***************************************************************************/ /***************************************************************************\ * Class methods * \***************************************************************************/ void PlaneMoveManipulator::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::SystemPost) { IntersectAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>( &PlaneMoveManipulator::intersectEnter)); IntersectAction::registerLeaveDefault( getClassType(), reinterpret_cast<Action::Callback>( &PlaneMoveManipulator::intersectLeave)); RenderAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>( &PlaneMoveManipulator::renderEnter)); RenderAction::registerLeaveDefault( getClassType(), reinterpret_cast<Action::Callback>( &PlaneMoveManipulator::renderLeave)); } }
/** * Do fix ups for non-primitive behaviours, ensuring they * get all of the appropriate information from their parent * primitive behaviour types. */ void RexxBehaviour::resolveNonPrimitiveBehaviour() { if (isNotResolved()) { setResolved(); operatorMethods = getOperatorMethods(getClassType()); } }
//! create a new instance of the class PhysicsBodyUnrecPtr PhysicsBody::create(PhysicsWorldUnrecPtr World) { PhysicsBodyUnrecPtr fc; if(getClassType().getPrototype() != NULL) { fc = dynamic_pointer_cast<PhysicsBody>( getClassType().getPrototype()-> shallowCopy()); } if(fc != NULL) { fc->setWorld(World); commitChanges(); fc->initDefaults(); } return fc; }
void Geometry::initMethod(InitPhase ePhase) { if(ePhase == TypeObject::SystemPost) { IntersectAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>(&Geometry::intersect)); RenderAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>( &MaterialDrawable::renderActionEnterHandler)); RenderAction::registerLeaveDefault( getClassType(), reinterpret_cast<Action::Callback>( &MaterialDrawable::renderActionLeaveHandler)); } }
//! initialize the static features of the class, e.g. action callbacks void DVRVolume::initMethod(void) { DrawAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, DVRVolumePtr, CNodePtr, Action *>(&DVRVolume::doDraw)); IntersectAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, DVRVolumePtr, CNodePtr, Action *>(&DVRVolume::intersect)); RenderAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, DVRVolumePtr, CNodePtr, Action *>(&DVRVolume::render)); }
OSG_BEGIN_NAMESPACE // Documentation for this class is emitted in the // OSGReplicateTransformBase.cpp file. // To modify it, please change the .fcd file (OSGReplicateTransform.fcd) and // regenerate the base file. /***************************************************************************\ * Class variables * \***************************************************************************/ /***************************************************************************\ * Class methods * \***************************************************************************/ void ReplicateTransform::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::SystemPost) { #ifndef OSG_EMBEDDED IntersectAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>(&ReplicateTransform::intersectEnter)); IntersectAction::registerLeaveDefault( getClassType(), reinterpret_cast<Action::Callback>(&ReplicateTransform::intersectLeave)); #endif RenderAction::registerEnterDefault( ReplicateTransform::getClassType(), reinterpret_cast<Action::Callback>(&ReplicateTransform::renderEnter)); RenderAction::registerLeaveDefault( ReplicateTransform::getClassType(), reinterpret_cast<Action::Callback>(&ReplicateTransform::renderLeave)); } }
/*! * \brief Append new-class to container. * \param klassOop [in] New class oop. * \return New-class data. */ TObjectData *TClassContainer::pushNewClass(void *klassOop) { TObjectData *cur = NULL; /* Class info setting. */ cur = (TObjectData *)calloc(1, sizeof(TObjectData)); /* If failure allocate. */ if (unlikely(cur == NULL)) { /* Adding empty to list is deny. */ logger->printWarnMsg("Couldn't allocate counter memory!"); return NULL; } cur->tag = (uintptr_t)cur; cur->className = getClassName(getKlassFromKlassOop(klassOop)); /* If failure getting class name. */ if (unlikely(cur->className == NULL)) { /* Adding empty to list is deny. */ logger->printWarnMsg("Couldn't get class name!"); free(cur); return NULL; } cur->classNameLen = strlen(cur->className); cur->oopType = getClassType(cur->className); void *clsLoader = getClassLoader(klassOop, cur->oopType); TObjectData *clsLoaderData = NULL; /* If class loader isn't system bootstrap class loader. */ if (clsLoader != NULL) { void *clsLoaderKlsOop = getKlassOopFromOop(clsLoader); if (clsLoaderKlsOop != NULL) { /* Search classloader's class. */ clsLoaderData = this->findClass(clsLoaderKlsOop); if (unlikely(clsLoaderData == NULL)) { /* Register classloader's class. */ clsLoaderData = this->pushNewClass(clsLoaderKlsOop); } } } cur->clsLoaderTag = (clsLoaderData != NULL) ? clsLoaderData->tag : 0; cur->clsLoaderId = (uintptr_t)clsLoader; /* Chain setting. */ cur->klassOop = klassOop; TObjectData *result = this->pushNewClass(klassOop, cur); if (unlikely(result != cur)) { free(cur->className); free(cur); } return result; }
OSG_USING_NAMESPACE // Documentation for this class is emited in the // OSGGeoInstancerBase.cpp file. // To modify it, please change the .fcd file (OSGGeoInstancer.fcd) and // regenerate the base file. /***************************************************************************\ * Class variables * \***************************************************************************/ /***************************************************************************\ * Class methods * \***************************************************************************/ void GeoInstancer::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::SystemPost) { IntersectAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>(&GeoInstancer::intersectEnter)); RenderAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>( &MaterialDrawable::renderEnter)); RenderAction::registerLeaveDefault( getClassType(), reinterpret_cast<Action::Callback>( &MaterialDrawable::renderLeave)); } }
bool CSSImageGeneratorValue::isPending() const { switch (getClassType()) { case CrossfadeClass: return toCSSCrossfadeValue(this)->isPending(); case LinearGradientClass: return toCSSLinearGradientValue(this)->isPending(); case PaintClass: return toCSSPaintValue(this)->isPending(); case RadialGradientClass: return toCSSRadialGradientValue(this)->isPending(); default: ASSERT_NOT_REACHED(); } return false; }
void Group::initMethod (void) { DrawAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GroupPtr , CNodePtr , Action *>(&Group::drawEnter)); DrawAction::registerLeaveDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GroupPtr , CNodePtr , Action *>(&Group::drawLeave)); RenderAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GroupPtr , CNodePtr , Action *>(&Group::renderEnter)); RenderAction::registerLeaveDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GroupPtr , CNodePtr , Action *>(&Group::renderLeave)); IntersectAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef<Action::ResultE, GroupPtr , CNodePtr , Action *>(&Group::intersect)); }
void RigidBody::create(const Matrix44& pose, SimpleShape* shape, Real mass, Scene* scene) { if (mActor != 0) { NxOgre_ThrowError("RigidBody tried to create an actor that was already created."); return; } if (shape == 0) { NxOgre_ThrowError("RigidBody tried to create an actor that has no shape."); return; } if (scene == 0) { NxOgre_ThrowError("RigidBody tried to create an actor that has no scene."); return; } NxActorDesc actor_description; NxBodyDesc body_description; actor_description.globalPose.setRowMajor44(pose.ptr()); Functions::SimpleShapeToActorDescription(actor_description, shape); if (mass) { body_description.mass = mass; actor_description.body = &body_description; } mActor = scene->getScene()->createActor(actor_description); if (mActor == 0) { NxOgre_ThrowError("RigidBody actor was not created."); return; } for (unsigned int i=0; i < actor_description.shapes.size(); i++) { NxShapeDesc* desc = actor_description.shapes[i]; delete desc; } mActor->userData = (void*) NxOgre_New(PhysXPointer)(this, getClassType()); }
PassRefPtr<Image> CSSImageGeneratorValue::image(const LayoutObject& layoutObject, const IntSize& size) { switch (getClassType()) { case CrossfadeClass: return toCSSCrossfadeValue(this)->image(layoutObject, size); case LinearGradientClass: return toCSSLinearGradientValue(this)->image(layoutObject, size); case PaintClass: return toCSSPaintValue(this)->image(layoutObject, size); case RadialGradientClass: return toCSSRadialGradientValue(this)->image(layoutObject, size); default: ASSERT_NOT_REACHED(); } return nullptr; }
IntSize CSSImageGeneratorValue::fixedSize(const LayoutObject& layoutObject, const FloatSize& defaultObjectSize) { switch (getClassType()) { case CrossfadeClass: return toCSSCrossfadeValue(this)->fixedSize(layoutObject, defaultObjectSize); case LinearGradientClass: return toCSSLinearGradientValue(this)->fixedSize(layoutObject); case PaintClass: return toCSSPaintValue(this)->fixedSize(layoutObject); case RadialGradientClass: return toCSSRadialGradientValue(this)->fixedSize(layoutObject); default: ASSERT_NOT_REACHED(); } return IntSize(); }
bool CSSImageGeneratorValue::knownToBeOpaque(const LayoutObject& layoutObject) const { switch (getClassType()) { case CrossfadeClass: return toCSSCrossfadeValue(this)->knownToBeOpaque(layoutObject); case LinearGradientClass: return toCSSLinearGradientValue(this)->knownToBeOpaque(layoutObject); case PaintClass: return toCSSPaintValue(this)->knownToBeOpaque(layoutObject); case RadialGradientClass: return toCSSRadialGradientValue(this)->knownToBeOpaque(layoutObject); default: ASSERT_NOT_REACHED(); } return false; }
void CSSImageGeneratorValue::loadSubimages(const Document& document) { switch (getClassType()) { case CrossfadeClass: toCSSCrossfadeValue(this)->loadSubimages(document); break; case LinearGradientClass: toCSSLinearGradientValue(this)->loadSubimages(document); break; case PaintClass: toCSSPaintValue(this)->loadSubimages(document); break; case RadialGradientClass: toCSSRadialGradientValue(this)->loadSubimages(document); break; default: ASSERT_NOT_REACHED(); } }
void Switch::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::SystemPost) { RenderAction::registerEnterDefault( Switch::getClassType(), reinterpret_cast<Action::Callback>(&Switch::renderEnter)); RenderAction::registerLeaveDefault( Switch::getClassType(), reinterpret_cast<Action::Callback>(&Switch::renderLeave)); IntersectAction::registerEnterDefault( getClassType(), reinterpret_cast<Action::Callback>(&Switch::intersect)); } }
void GenericFieldContainerEditor::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::FactoryPost) { //Fill in all of the editable types UInt32 NumTypes(FieldContainerFactory::the()->getNumTypes()); UInt32 FoundTypes(0); FieldContainerType* type; for(UInt32 i(0) ; FoundTypes<NumTypes; ++i) { type = FieldContainerFactory::the()->findType(i); if(type != NULL) { ++FoundTypes; _EditableTypes.push_back(type); FieldContainerEditorFactory::the()->setEditorType(type, &getClassType(), "Generic"); } } } }
void FCPtrFieldEditor::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::FactoryPost) { //Fill in all of the editable types UInt32 NumTypes(TypeFactory::the()->getNumTypes()); FieldType* type; for(UInt32 i(0) ; i<NumTypes; ++i) { type = dynamic_cast<FieldType*>(TypeFactory::the()->findType(i)); if(type != NULL && (type->getClass() == FieldType::PtrField || type->getClass() == FieldType::ChildPtrField)) { _EditableTypes.push_back(&type->getContentType()); FieldEditorFactory::the()->setEditorType(&type->getContentType(), &getClassType(), "FieldContainerPtr"); } } } }
void GenericFieldEditor::initMethod(InitPhase ePhase) { Inherited::initMethod(ePhase); if(ePhase == TypeObject::FactoryPost) { //Fill in all of the editable types UInt32 NumTypes(TypeFactory::the()->getNumTypes()); DataType* type; for(UInt32 i(0) ; i<NumTypes; ++i) { type = dynamic_cast<DataType*>(TypeFactory::the()->findType(i)); if(type != NULL && *type != FieldTraits<AttachmentMap>::getType() && *type != FieldTraits<ChangedFunctorCallback>::getType()) { _EditableTypes.push_back(type); FieldEditorFactory::the()->setEditorType(type, &getClassType(), "Generic"); } FieldEditorFactory::the()->removeEditorType(&FieldTraits<MaterialMap>::getType(), "Generic"); } } }
void RigidBody::create(RigidBodyPrototype* prototype, Scene* scene, Shapes* final_shapes) { if (mActor != 0) { NxOgre_ThrowError("RigidBody tried to create an actor that was already created."); return; } if (prototype == 0) { NxOgre_ThrowError("RigidBody tried to create an actor that has no prototype."); return; } if (scene == 0) { NxOgre_ThrowError("RigidBody tried to create an actor that has no scene."); return; } if (prototype->mShapes.size() == 0) { NxOgre_ThrowError("RigidBody has no shapes."); return; } mScene = scene; NxActorDesc actor_description; NxBodyDesc body_description; // Copy over the prototype into the Actor and possible Body descriptions. Functions::PrototypeFunctions::RigidBodyPrototypeToNxActorAndNxBodyDesc(prototype, actor_description, body_description); // Create the shapes, and bind them to the shape that represents them - or not. for (unsigned int i=0;i < prototype->mShapes.size(); i++) { Shape* shape = prototype->mShapes[i]; NxShapeDesc* description = shape->create(); //OUAN HACK MAYBE HERE IS WHY SHAPES DIDNT GET ITS NAME description->name=prototype->mName.c_str(); if (description) { if (final_shapes) description->userData = (void*) NxOgre_New(PhysXPointer)(shape, shape->getClassType(), this); actor_description.shapes.push_back(description); } } mActor = mScene->getScene()->createActor(actor_description); if (mActor == 0) { SharedStringStream ss; ss << "RigidBody actor was not created! \n" << "Reason(s) are: \n" << Reason::whyAsStream(actor_description); NxOgre_ThrowError(ss.get()); return; } mActor->userData = (void*) NxOgre_New(PhysXPointer)(this, getClassType()); for (unsigned int i=0; i < actor_description.shapes.size(); i++) { NxShapeDesc* desc = actor_description.shapes[i]; delete desc; } if (final_shapes) { NxShape* const* shapes = mActor->getShapes(); NxU32 nbShapes = mActor->getNbShapes(); while (nbShapes--) { NxShape* physx_shape = shapes[nbShapes]; PhysXShapeBinder::BindShape(physx_shape); final_shapes->insert(pointer_representive_cast<Shape>(physx_shape->userData)); } } }
void ComponentTransform::initMethod (void) { DrawAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::drawEnter)); DrawAction::registerLeaveDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::drawLeave)); RenderAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::renderEnter)); RenderAction::registerLeaveDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::renderLeave)); IntersectAction::registerEnterDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::intersectEnter)); IntersectAction::registerLeaveDefault( getClassType(), osgTypedMethodFunctor2BaseCPtrRef< Action::ResultE, ComponentTransformPtr , CNodePtr , Action *>(&ComponentTransform::intersectLeave)); IntersectActor::regClassEnter( osgTypedMethodFunctor2BaseCPtr< NewActionTypes::ResultE, ComponentTransformPtr , NodeCorePtr , ActorBase::FunctorArgumentType &>(&ComponentTransform::intersectActorEnter), getClassType()); IntersectActor::regClassLeave( osgTypedMethodFunctor2BaseCPtr< NewActionTypes::ResultE, ComponentTransformPtr , NodeCorePtr , ActorBase::FunctorArgumentType &>(&ComponentTransform::intersectActorLeave), getClassType()); }
vector<std::string> ofxGuiInputField<Type>::getClassTypes(){ vector<std::string> types = ofxGuiElement::getClassTypes(); types.push_back(getClassType()); return types; }
/** * This method test if S is 'instanceof' T * \param classId_S The class id of S * \param classId_T The class id of T * \return true, if S is 'instanceof' T; false otherwise. */ BOOL CP_IsInstanceOf(u2 classId_S, u2 classId_T) { CLASS_TYPE type_T = getClassType(classId_T); CLASS_TYPE type_S = getClassType(classId_S); BOOL instanceOf; if (isObjectArray(classId_S) || isPrimitiveValueArray(classId_S)) { if (isObjectArray(classId_T)) { if (isObjectArray(classId_S)) { // Both are object arrays: u2 classId_SC = getArrayElementClassId(classId_S); u2 classId_TC = getArrayElementClassId(classId_T); instanceOf = CP_IsInstanceOf(classId_SC, classId_TC); } else { instanceOf = FALSE; } } else if (isPrimitiveValueArray(classId_T)) { instanceOf = (classId_T == classId_S) ? TRUE : FALSE; } else if (type_T == CT_CLASS) { instanceOf = classId_T == 0 ? TRUE : FALSE; } else { // S shall implement T: if (!is_S_implementing_T(classId_S, classId_T)) { instanceOf = FALSE; } else { instanceOf = TRUE; } consout("not tested, since arrays does not implement any interfaces ... %d\n", instanceOf); jvmexit(1); } } else if (type_S == CT_CLASS) { if (type_T == CT_CLASS) { instanceOf = classId_S == classId_T ? TRUE : FALSE; if (!instanceOf) { instanceOf = is_S_SubClassing_T(classId_S, classId_T); } } else { // S shall implement T: if (!is_S_implementing_T(classId_S, classId_T)) { instanceOf = FALSE; } else { instanceOf = TRUE; } } } else if (type_S == CT_INTERFACE) { // All objects in this VM has a class reference; so we don't support any classes having a class id which // is an interface. // This piece of code is not testable nor tested ;-) consout("not implemented\n"); jvmexit(1); } else { consout("not implemented\n"); jvmexit(1); } /* *i If S is an ordinary (nonarray) class, then: *i o If T is a class type, then S must be the same class (§2.8.1) as T or a subclass of T. *i o If T is an interface type, then S must implement (§2.13) interface T. *i If S is an interface type, then: *- o If T is a class type, then T must be Object (§2.4.7). *- o If T is an interface type, then T must be the same interface as S, or a superinterface of S (§2.13.2). * If S is a class representing the array type SC[], that is, an array of components of type SC, then: *i o If T is a class type, then T must be Object (§2.4.7). *i o If T is an array type TC[], that is, an array of components of type TC, then one of the following must be true: *i + TC and SC are the same primitive type (§2.4.1). *i + TC and SC are reference types (§2.4.6), and type SC can be cast to TC by these runtime rules. *(i) o If T is an interface type, T must be one of the interfaces implemented by arrays (§2.15). */ return instanceOf; }
void CSSValue::finalizeGarbageCollectedObject() { switch (getClassType()) { case BasicShapeCircleClass: toCSSBasicShapeCircleValue(this)->~CSSBasicShapeCircleValue(); return; case BasicShapeEllipseClass: toCSSBasicShapeEllipseValue(this)->~CSSBasicShapeEllipseValue(); return; case BasicShapePolygonClass: toCSSBasicShapePolygonValue(this)->~CSSBasicShapePolygonValue(); return; case BasicShapeInsetClass: toCSSBasicShapeInsetValue(this)->~CSSBasicShapeInsetValue(); return; case BorderImageSliceClass: toCSSBorderImageSliceValue(this)->~CSSBorderImageSliceValue(); return; case ColorClass: toCSSColorValue(this)->~CSSColorValue(); return; case CounterClass: toCSSCounterValue(this)->~CSSCounterValue(); return; case CursorImageClass: toCSSCursorImageValue(this)->~CSSCursorImageValue(); return; case FontFaceSrcClass: toCSSFontFaceSrcValue(this)->~CSSFontFaceSrcValue(); return; case FontFamilyClass: toCSSFontFamilyValue(this)->~CSSFontFamilyValue(); return; case FontFeatureClass: toCSSFontFeatureValue(this)->~CSSFontFeatureValue(); return; case FunctionClass: toCSSFunctionValue(this)->~CSSFunctionValue(); return; case LinearGradientClass: toCSSLinearGradientValue(this)->~CSSLinearGradientValue(); return; case RadialGradientClass: toCSSRadialGradientValue(this)->~CSSRadialGradientValue(); return; case CrossfadeClass: toCSSCrossfadeValue(this)->~CSSCrossfadeValue(); return; case PaintClass: toCSSPaintValue(this)->~CSSPaintValue(); return; case CustomIdentClass: toCSSCustomIdentValue(this)->~CSSCustomIdentValue(); return; case ImageClass: toCSSImageValue(this)->~CSSImageValue(); return; case InheritedClass: toCSSInheritedValue(this)->~CSSInheritedValue(); return; case InitialClass: toCSSInitialValue(this)->~CSSInitialValue(); return; case UnsetClass: toCSSUnsetValue(this)->~CSSUnsetValue(); return; case GridAutoRepeatClass: toCSSGridAutoRepeatValue(this)->~CSSGridAutoRepeatValue(); return; case GridLineNamesClass: toCSSGridLineNamesValue(this)->~CSSGridLineNamesValue(); return; case GridTemplateAreasClass: toCSSGridTemplateAreasValue(this)->~CSSGridTemplateAreasValue(); return; case PathClass: toCSSPathValue(this)->~CSSPathValue(); return; case PrimitiveClass: toCSSPrimitiveValue(this)->~CSSPrimitiveValue(); return; case IdentifierClass: toCSSIdentifierValue(this)->~CSSIdentifierValue(); return; case QuadClass: toCSSQuadValue(this)->~CSSQuadValue(); return; case ReflectClass: toCSSReflectValue(this)->~CSSReflectValue(); return; case ShadowClass: toCSSShadowValue(this)->~CSSShadowValue(); return; case StringClass: toCSSStringValue(this)->~CSSStringValue(); return; case CubicBezierTimingFunctionClass: toCSSCubicBezierTimingFunctionValue(this) ->~CSSCubicBezierTimingFunctionValue(); return; case StepsTimingFunctionClass: toCSSStepsTimingFunctionValue(this)->~CSSStepsTimingFunctionValue(); return; case UnicodeRangeClass: toCSSUnicodeRangeValue(this)->~CSSUnicodeRangeValue(); return; case URIClass: toCSSURIValue(this)->~CSSURIValue(); return; case ValueListClass: toCSSValueList(this)->~CSSValueList(); return; case ValuePairClass: toCSSValuePair(this)->~CSSValuePair(); return; case ImageSetClass: toCSSImageSetValue(this)->~CSSImageSetValue(); return; case CSSContentDistributionClass: toCSSContentDistributionValue(this)->~CSSContentDistributionValue(); return; case VariableReferenceClass: toCSSVariableReferenceValue(this)->~CSSVariableReferenceValue(); return; case CustomPropertyDeclarationClass: toCSSCustomPropertyDeclaration(this)->~CSSCustomPropertyDeclaration(); return; case PendingSubstitutionValueClass: toCSSPendingSubstitutionValue(this)->~CSSPendingSubstitutionValue(); return; } ASSERT_NOT_REACHED(); }
bool CSSValue::equals(const CSSValue& other) const { if (m_classType == other.m_classType) { switch (getClassType()) { case BasicShapeCircleClass: return compareCSSValues<CSSBasicShapeCircleValue>(*this, other); case BasicShapeEllipseClass: return compareCSSValues<CSSBasicShapeEllipseValue>(*this, other); case BasicShapePolygonClass: return compareCSSValues<CSSBasicShapePolygonValue>(*this, other); case BasicShapeInsetClass: return compareCSSValues<CSSBasicShapeInsetValue>(*this, other); case BorderImageSliceClass: return compareCSSValues<CSSBorderImageSliceValue>(*this, other); case ColorClass: return compareCSSValues<CSSColorValue>(*this, other); case CounterClass: return compareCSSValues<CSSCounterValue>(*this, other); case CursorImageClass: return compareCSSValues<CSSCursorImageValue>(*this, other); case FontFaceSrcClass: return compareCSSValues<CSSFontFaceSrcValue>(*this, other); case FontFamilyClass: return compareCSSValues<CSSFontFamilyValue>(*this, other); case FontFeatureClass: return compareCSSValues<CSSFontFeatureValue>(*this, other); case FunctionClass: return compareCSSValues<CSSFunctionValue>(*this, other); case LinearGradientClass: return compareCSSValues<CSSLinearGradientValue>(*this, other); case RadialGradientClass: return compareCSSValues<CSSRadialGradientValue>(*this, other); case CrossfadeClass: return compareCSSValues<CSSCrossfadeValue>(*this, other); case PaintClass: return compareCSSValues<CSSPaintValue>(*this, other); case CustomIdentClass: return compareCSSValues<CSSCustomIdentValue>(*this, other); case ImageClass: return compareCSSValues<CSSImageValue>(*this, other); case InheritedClass: return compareCSSValues<CSSInheritedValue>(*this, other); case InitialClass: return compareCSSValues<CSSInitialValue>(*this, other); case UnsetClass: return compareCSSValues<CSSUnsetValue>(*this, other); case GridAutoRepeatClass: return compareCSSValues<CSSGridAutoRepeatValue>(*this, other); case GridLineNamesClass: return compareCSSValues<CSSGridLineNamesValue>(*this, other); case GridTemplateAreasClass: return compareCSSValues<CSSGridTemplateAreasValue>(*this, other); case PathClass: return compareCSSValues<CSSPathValue>(*this, other); case PrimitiveClass: return compareCSSValues<CSSPrimitiveValue>(*this, other); case IdentifierClass: return compareCSSValues<CSSIdentifierValue>(*this, other); case QuadClass: return compareCSSValues<CSSQuadValue>(*this, other); case ReflectClass: return compareCSSValues<CSSReflectValue>(*this, other); case ShadowClass: return compareCSSValues<CSSShadowValue>(*this, other); case StringClass: return compareCSSValues<CSSStringValue>(*this, other); case CubicBezierTimingFunctionClass: return compareCSSValues<CSSCubicBezierTimingFunctionValue>(*this, other); case StepsTimingFunctionClass: return compareCSSValues<CSSStepsTimingFunctionValue>(*this, other); case UnicodeRangeClass: return compareCSSValues<CSSUnicodeRangeValue>(*this, other); case URIClass: return compareCSSValues<CSSURIValue>(*this, other); case ValueListClass: return compareCSSValues<CSSValueList>(*this, other); case ValuePairClass: return compareCSSValues<CSSValuePair>(*this, other); case ImageSetClass: return compareCSSValues<CSSImageSetValue>(*this, other); case CSSContentDistributionClass: return compareCSSValues<CSSContentDistributionValue>(*this, other); case CustomPropertyDeclarationClass: return compareCSSValues<CSSCustomPropertyDeclaration>(*this, other); case VariableReferenceClass: return compareCSSValues<CSSVariableReferenceValue>(*this, other); case PendingSubstitutionValueClass: return compareCSSValues<CSSPendingSubstitutionValue>(*this, other); } ASSERT_NOT_REACHED(); return false; } return false; }