Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

SoBase Class Reference

The SoBase class is the top-level superclass for a number of class-hierarchies. More...

#include <Inventor/misc/SoBase.h>

Inheritance diagram for SoBase::

SoFieldContainer SoPath SoEngine SoNode SoFullPath SoNodeKitPath SoBoolOperation SoCalculator SoComposeMatrix SoComposeRotation SoComposeRotationFromTo SoComposeVec2f SoComposeVec3f SoComposeVec4f SoComputeBoundingBox SoConcatenate SoCounter SoDecomposeMatrix SoDecomposeRotation SoDecomposeVec2f SoDecomposeVec3f SoDecomposeVec4f SoElapsedTime SoFieldConverter SoGate SoInterpolate SoOneShot SoOnOff SoSelectOne SoTimeCounter SoTransformVec3f SoTriggerAny SoBaseColor SoBaseKit SoCallback SoCamera SoClipPlane SoColorIndex SoComplexity SoCoordinate3 SoCoordinate4 SoDrawStyle SoEnvironment SoEventCallback SoFile SoFont SoGroup SoInfo SoLabel SoLight SoLightModel SoMaterial SoMaterialBinding SoNodeKitListPart SoNormal SoNormalBinding SoPackedColor SoPickStyle SoPolygonOffset SoProfile SoProfileCoordinate2 SoProfileCoordinate3 SoShape SoShapeHints SoTexture2 SoTexture2Transform SoTextureCoordinate2 SoTextureCoordinateBinding SoTextureCoordinateFunction SoTransformation SoVertexProperty SoWWWInline List of all members.

Public Methods

void ref (void) const
void unref (void) const
void unrefNoDelete (void) const
int32_t getRefCount (void) const
void touch (void)
virtual SoType getTypeId (void) const=0
SbBool isOfType (SoType type) const
virtual SbName getName (void) const
virtual void setName (const SbName &newname)
virtual void startNotify (void)
virtual void notify (SoNotList *l)
void addAuditor (void *const auditor, const SoNotRec::Type type)
void removeAuditor (void *const auditor, const SoNotRec::Type type)
const SoAuditorListgetAuditors (void) const
virtual void addWriteReference (SoOutput *out, SbBool isfromfield=FALSE)
SbBool shouldWrite (void)

Static Public Methods

void initClass (void)
SoType getClassTypeId (void)
void addName (SoBase *const base, const char *const name)
void removeName (SoBase *const base, const char *const name)
void incrementCurrentWriteCounter (void)
void decrementCurrentWriteCounter (void)
SoBase * getNamedBase (const SbName &name, SoType type)
int getNamedBases (const SbName &name, SoBaseList &baselist, SoType type)
SbBool read (SoInput *in, SoBase *&base, SoType expectedtype)
void setInstancePrefix (const SbString &c)
void setTraceRefs (SbBool trace)
SbBool getTraceRefs (void)

Protected Types

enum  BaseFlags { IS_ENGINE = 0x01, IS_GROUP = 0x02 }

Protected Methods

 SoBase (void)
virtual ~SoBase ()
virtual void destroy (void)
SbBool hasMultipleWriteRefs (void) const
SbBool writeHeader (SoOutput *out, SbBool isgroup, SbBool isengine) const
void writeFooter (SoOutput *out) const
virtual const char * getFileFormatName (void) const
virtual SbBool readInstance (SoInput *in, unsigned short flags)=0

Static Protected Methods

uint32_t getCurrentWriteCounter (void)

Detailed Description

The SoBase class is the top-level superclass for a number of class-hierarchies.

SoBase provides the basic interfaces and methods for doing reference counting, type identification and import/export. All classes in Coin which uses these mechanisms are descendent from this class.


Member Enumeration Documentation

enum SoBase::BaseFlags [protected]
 

For internal use only.


Constructor & Destructor Documentation

SoBase::SoBase void [protected]
 

Constructor. The initial reference count will be set to zero.

SoBase::~SoBase [protected, virtual]
 

Destructor. There should not be any normal circumstance where you need to explicitly delete an object derived from the SoBase class, as the reference counting should take care of deallocating unused objects.

See also:
unref(), unrefNoDelete()


Member Function Documentation

void SoBase::initClass void [static]
 

Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.

Reimplemented in SoNode, SoCamera, SoPerspectiveCamera, SoOrthographicCamera, SoShape, SoAsciiText, SoCone, SoCube, SoCylinder, SoText3, SoTransformation, SoAntiSquish, SoMatrixTransform, SoRotation, SoPendulum, SoRotor, SoResetTransform, SoRotationXYZ, SoScale, SoTranslation, SoShuttle, SoSurroundScale, SoTransform, SoUnits, SoBaseColor, SoCallback, SoClipPlane, SoComplexity, SoCoordinate3, SoCoordinate4, SoLight, SoDirectionalLight, SoSpotLight, SoPointLight, SoDrawStyle, SoEnvironment, SoFile, SoFont, SoFontStyle, SoInfo, SoLabel, SoLightModel, SoProfile, SoLinearProfile, SoNurbsProfile, SoMaterial, SoMaterialBinding, SoNormal, SoNormalBinding, SoPackedColor, SoPickStyle, SoPolygonOffset, SoProfileCoordinate2, SoProfileCoordinate3, SoShapeHints, SoAnnotation, SoArray, SoBlinker, SoColorIndex, SoEventCallback, SoExtSelection, SoFaceSet, SoGroup, SoImage, SoIndexedFaceSet, SoIndexedLineSet, SoIndexedNurbsCurve, SoIndexedNurbsSurface, SoIndexedShape, SoIndexedTriangleStripSet, SoLOD, SoLevelOfDetail, SoLineSet, SoLocateHighlight, SoMarkerSet, SoMultipleCopy, SoNonIndexedShape, SoNurbsCurve, SoNurbsSurface, SoPathSwitch, SoPointSet, SoQuadMesh, SoSelection, SoSeparator, SoSphere, SoSwitch, SoText2, SoTexture2, SoTexture2Transform, SoTextureCoordinate2, SoTextureCoordinateBinding, SoTextureCoordinateDefault, SoTextureCoordinateEnvironment, SoTextureCoordinateFunction, SoTextureCoordinatePlane, SoTransformSeparator, SoTriangleStripSet, SoVertexProperty, SoVertexShape, SoWWWAnchor, SoWWWInline, SoPath, SoFieldContainer, SoEngine, SoBoolOperation, SoCalculator, SoComputeBoundingBox, SoConcatenate, SoCounter, SoElapsedTime, SoFieldConverter, SoGate, SoInterpolate, SoOnOff, SoOneShot, SoSelectOne, SoTimeCounter, SoTransformVec3f, SoTriggerAny, SoNodeKitListPart, SoBaseKit, SoInteractionKit, SoSeparatorKit, SoShapeKit, SoWrapperKit, SoAppearanceKit, SoCameraKit, SoLightKit, SoSceneKit, SoDragger, SoCenterballDragger, SoDirectionalLightDragger, SoDragPointDragger, SoHandleBoxDragger, SoJackDragger, SoPointLightDragger, SoRotateCylindricalDragger, SoRotateDiscDragger, SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger, SoScale2UniformDragger, SoScaleUniformDragger, SoSpotLightDragger, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger, SoTranslate2Dragger, SoCenterballManip, SoClipPlaneManip, SoDirectionalLightManip, SoHandleBoxManip, SoJackManip, SoPointLightManip, SoSpotLightManip, SoTabBoxManip, SoTrackballManip, SoTransformBoxManip, SoTransformManip, and SoTransformerManip.

void SoBase::ref void const
 

Increase the reference count of the object. This might be necessary to do explicitly from user code for certain situations (chiefly to avoid premature deletion), but is usually called from other instances within the Coin library when objects are made dependent on each other.

See also:
unref(), unrefNoDelete()

void SoBase::unref void const
 

Decrease the reference count of an object. If the reference count reaches zero, the object will delete itself. Be careful when explicitly calling this method, beware that you usually need to match user level calls to ref() with calls to either unref() or unrefNoDelete() to avoid memory leaks.

See also:
ref(), unrefNoDelete()

void SoBase::unrefNoDelete void const
 

Decrease reference count, but do not delete ourself if the count reaches zero.

See also:
unref()

int32_t SoBase::getRefCount void const
 

Returns number of objects referring to this object. NB: this method should not be called during ordinary use, it should only be necessary to use for debugging purposes.

void SoBase::touch void
 

Force an update, in the sense that all objects connected to this will have to re-check the values of their inter-dependent data.

This is often used as an effective way of manually triggering a redraw by application programmers.

SoType SoBase::getTypeId void const [pure virtual]
 

Returns the type identification of an object derived from a class inheriting SoBase. This is used for run-time type checking and "downward" casting.

Usage example:

  void foo(SoNode * node)
  {
    if (node->getTypeId() == SoFile::getClassTypeId()) {
    }
    else if (node->getTypeId().isOfType(SoGroup::getClassTypeId())) {
      SoGroup * group = (SoGroup *)node;  // safe downward cast, know the type
      // then something else
    }
  }

For application programmers wanting to extend the library with new nodes, engines, nodekits, draggers or others: this method needs to be overloaded in all subclasses. This is typically done as part of setting up the full type system for extension classes, which is usually accomplished by using the pre-defined macros available through for instance Inventor/nodes/SoSubNode.h (SO_NODE_INIT_CLASS and SO_NODE_CONSTRUCTOR for node classes), Inventor/engines/SoSubEngine.h (for engine classes) and so on.

For more information on writing Coin extensions, see the class documentation of the toplevel superclasses for the various class groups.

Reimplemented in SoPath.

SbBool SoBase::isOfType SoType type const
 

Returns TRUE if the type of this object is either of the same type or inherited from type.

SoType SoBase::getClassTypeId void [static]
 

This static method returns the SoType object associated with objects of this class.

Reimplemented in SoNode, SoPath, SoFieldContainer, and SoEngine.

SbName SoBase::getName void const [virtual]
 

Returns name of object. If no name has been given to this object, the returned SbName will contain the empty string.

void SoBase::setName const SbName & newname [virtual]
 

Set the name of this object.

Characters that are invalid to use as parts of names for SoBase derived objects will be automatically replaced by underscore characters. If the name starts with an invalid character, the new name will be preceded by an underscore character.

See also:
getName(), SbName::isBaseNameStartChar(), SbName::isBaseNameChar()

void SoBase::addName SoBase *const b,
const char *const name
[static]
 

Adds a name<->object mapping to the global dictionary.

void SoBase::removeName SoBase *const b,
const char *const name
[static]
 

Removes a name<->object mapping from the global dictionary.

void SoBase::startNotify void [virtual]
 

This is the method which starts the notification sequence after changes.

At the end of a notification sequence, all "immediate" sensors (i.e. sensors set up with a zero priority) are triggered.

Reimplemented in SoNode.

void SoBase::notify SoNotList * list [virtual]
 

Notifies all auditors for this instance when changes are made.

Reimplemented in SoNode, SoAsciiText, SoText3, SoMaterial, SoPackedColor, SoBlinker, SoImage, SoSeparator, SoTexture2, SoVertexProperty, SoVertexShape, SoFieldContainer, and SoEngine.

void SoBase::addAuditor void *const auditor,
const SoNotRec::Type type
 

Add an auditor to notify whenever the object changes in any significant way.

See also:
removeAuditor()

void SoBase::removeAuditor void *const auditor,
const SoNotRec::Type type
 

Remove an auditor from the list. auditor will then no longer be notified whenever any updates are made to this object.

See also:
addAuditor()

const SoAuditorList & SoBase::getAuditors void const
 

Returns list of objects auditing this object.

See also:
addAuditor(), removeAuditor()

void SoBase::addWriteReference SoOutput * out,
SbBool isfromfield = FALSE
[virtual]
 

This method is used during the first write pass of a write action to count the number of references to this object in the scene graph.

Reimplemented in SoFieldContainer, and SoBaseKit.

SbBool SoBase::shouldWrite void
 

Returns TRUE if this object should be written out during a write action. Will return FALSE if no references to this object has been made in the scene graph.

Note that connections from the fields of fieldcontainer objects is not alone a valid reason for writing out the object -- there must also be at least one reference directly from another SoBase (like a parent/child relationship, for instance).

This method will return a valid result only during the second pass of write actions.

void SoBase::incrementCurrentWriteCounter void [static]
 

For internal use only.

void SoBase::decrementCurrentWriteCounter void [static]
 

For internal use only.

SoBase * SoBase::getNamedBase const SbName & name,
SoType type
[static]
 

Returns the object of type, or derived from type, registered under name. If several has been registered under the same name with the same type, returns the last one which was registered.

If no object of a valid type or subtype has been registered with the given name, returns NULL.

int SoBase::getNamedBases const SbName & name,
SoBaseList & baselist,
SoType type
[static]
 

Returns the number of objects of type type, or derived from type, registered under name.

All matches will also be appended to baselist.

SbBool SoBase::read SoInput * in,
SoBase *& base,
SoType expectedtype
[static]
 

Read next SoBase derived instance from the in stream, check that it is derived from expectedtype and place a pointer to the newly allocated instance in base.

FALSE is returned on read errors, mismatch with the expectedtype, or if there are attempts at referencing (through the USE keyword) unknown instances.

If we return TRUE with base equal to NULL, three things might have happened:

1. End-of-file. Use SoInput::eof() after calling this method to detect end-of-file conditions.

2. in didn't have a valid identifier name at the stream for us to read. This happens either in the case of errors, or when all child nodes of a group has been read. Check if the next character in the stream is a '}' to detect the latter case.

3. A child was given as the "NULL" keyword. This can happen when reading the contents of SoSFNode or SoMFNode fields.

If TRUE is returned and base is non-NULL upon return, the instance was allocated and initialized according the what was read from the in stream.

void SoBase::setInstancePrefix const SbString & c [static]
 

Referenced instances of SoBase are written as "DEF NamePrefixNumber" when exported. "Name" is the name of the base instance from setName(), "Prefix" is common for all objects and can be set by this method (default is "+"), and "Number" is a unique id which is necessary if multiple objects have the same name.

If you want the prefix to be something else than "+", use this method.

void SoBase::setTraceRefs SbBool trace [static]
 

Set to TRUE to activate debugging of reference counting, which could aid in finding hard to track down problems with accesses to freed memory or memory leaks. Note: this will produce lots of debug information in any "normal" running system, so use sensibly.

The reference tracing functionality will be disabled in "release versions" of the Coin library.

SbBool SoBase::getTraceRefs void [static]
 

Return the status of the reference tracing flag.

See also:
setTraceRefs()

void SoBase::destroy void [protected, virtual]
 

Cleans up all hanging references to and from this instance, and then commits suicide.

Called automatically when the reference count goes to zero.

SbBool SoBase::hasMultipleWriteRefs void const [protected]
 

Returns TRUE if this object will be written more than once upon export. Note that the result from this method is only valid during the second pass of a write action (and partly during the COUNT_REFS pass).

SbBool SoBase::writeHeader SoOutput * out,
SbBool isgroup,
SbBool isengine
const [protected]
 

Write out the header of any SoBase derived object. The header consists of the DEF keyword and the object name (if the object has a name, otherwise these will be skipped), the class name and a left bracket.

Alternatively, the object representation may be made up of just the USE keyword plus the object name, if this is the second or subsequent reference written to the file.

If the object has been completed just by writing the header (which will be the case if we're writing multiple references of an object), we return TRUE, otherwise FALSE.

If we return FALSE (i.e. there's more to write), we will increment the indentation level.

See also:
writeFooter(), SoOutput::indent()

void SoBase::writeFooter SoOutput * out const [protected]
 

This method will terminate the block representing an SoBase derived object.

const char * SoBase::getFileFormatName void const [protected, virtual]
 

Returns the class name this object should be written under. Default string returned is the name of the class from the type system.

User extensions nodes and engines override this method to return the name of the extension (instead of "UnknownNode" or "UnknownEngine").

SbBool SoBase::readInstance SoInput * in,
unsigned short flags
[protected, pure virtual]
 

This method is mainly intended for internal use during file import operations.

It reads a definition of an instance from the input stream in. The input stream state points to the start of a serialized / persistant representation of an instance of this class type.

TRUE or FALSE is returned, depending on if the instantiation and configuration of the new object of this class type went ok or not. The import process should be robust and handle corrupted input streams by returning FALSE.

flags is used internally during binary import when reading user extension nodes, group nodes or engines.

Reimplemented in SoNode, SoFile, SoNormalBinding, SoGroup, SoImage, SoSeparator, SoTexture2, SoTextureCoordinateBinding, SoWWWInline, SoFieldContainer, SoEngine, SoNodeKitListPart, SoBaseKit, and SoInteractionKit.

uint32_t SoBase::getCurrentWriteCounter void [static, protected]
 

For internal use only.


The documentation for this class was generated from the following files:
Generated at Tue Mar 5 03:31:21 2002 for Coin by doxygen1.2.9 written by Dimitri van Heesch, © 1997-2001