Home

COEDGE Class Reference
[Topology]

Relates EDGEs to adjacent EDGEs and to owning ENTITYs. More...

#include <coedge.hxx>

Inheritance diagram for COEDGE:

Inheritance graph
[legend]
Collaboration diagram for COEDGE:

Collaboration graph
[legend]

List of all members.

Public Member Functions

virtual void add ()
 If this ENTITY is use counted, adds one to the count.
virtual logical apply_transform (SPAtransf const &, ENTITY_LIST &, logical=FALSE, logical=TRUE)
 Transforms this ENTITY.
ATTRIB * attrib () const
 Returns this ENTITY's attribute pointer, or NULL if there is no attached attribute.
ENTITY * backup ()
 Creates a duplicate record and a change bulletin, if needed, as a backup for roll back.
int bulletin_count () const
 Returns the number of bulletins referring to this ENTITY.
virtual logical call_method (METHOD_ID const &, METHOD_ARGS const &)
 Executes the implementation function for a routine virtual method.
 COEDGE (EDGE *edge, REVBIT sense, COEDGE *prev, COEDGE *next)
 Constructs a COEDGE from a specified EDGE and the next and previous COEDGES in the owning LOOP.
 COEDGE ()
 Constructs a COEDGE (default constructor).
virtual ENTITY * copy_data (ENTITY_LIST &, pointer_map *pm=NULL, logical dpcpy_skip=FALSE, SCAN_TYPE reason=SCAN_COPY) const
 Allocates a new ENTITY and calls copy_common to fill it in.
virtual void copy_scan (ENTITY_LIST &, SCAN_TYPE reason=SCAN_COPY, logical dpcpy_skip=FALSE) const
 Adds dependent ENTITYs of this ENTITY to the list of ENTITYs to be copied.
virtual void debug_ent (FILE *) const
 Prints the type and address of this ENTITY, roll back pointer, attributes, and any unknown subtype information.
virtual logical deletable () const
 Indicates whether or not this ENTITY is normally destroyed by lose.
EDGE * edge () const
 Returns a pointer to the single EDGE on which this COEDGE and all its partners lie.
VERTEX * end (REVBIT rev)
 Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense and a sense argument.
VERTEX * end () const
 Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense.
virtual SPAparameter end_param () const
 Returns either the start or end parameter of the EDGE underlying this COEDGE, depending upon the coedge's sense.
virtual SPAposition end_pos () const
 Returns either the start or end position of the EDGE underlying this COEDGE, depending upon the coedge's sense.
logical ends_at_singularity () const
 Determines if this coedge ends at a surface singularity.
virtual void fix_pointers (ENTITY *[], SCAN_TYPE reason=SCAN_COPY)
 Converts pointers from copy indices into real pointers.
virtual void full_size (SizeAccumulator &est, logical countSelf=TRUE) const
 Increments the SizeAccumulator by the size, in bytes, of everything owned by this ENTITY and, optionally, of the ENTITY itself.
PCURVE * geometry () const
 Returns the pointer to the description of the COEDGE geometry in reference to the parametric space of the FACE in which it is embedded.
HISTORY_STREAM * history () const
 Returns a pointer to the history stream for this ENTITY.
virtual int identity (int=0) const
 Returns a type identifier for this ENTITY.
virtual logical is_deepcopyable () const
 Returns TRUE if this ENTITY can be deep copied.
virtual logical is_use_counted () const
 Indicates if this ENTITY is use-counted or not.
virtual int lookup (logical) const
 Looks up this ENTITY in the appropriate debug list.
LOOP * loop () const
 Returns the owner of this COEDGE if the former is a LOOP, otherwise NULL.
virtual void lose ()
 Posts a delete bulletin to the bulletin board indicating the instance is no longer used in the active model.
TCOEDGE * make_tolerant ()
 Makes a tolerant TCOEDGE out of this COEDGE.
logical needs_rollback () const
 Checks whether or not the record is already backed up.
COEDGE * next (REVBIT rev) const
 Returns a pointer to the next COEDGE if the sense argument is FORWARD; otherwise returns a pointer to the previous COEDGE.
COEDGE * next () const
 Returns the next COEDGE in a doubly-linked list of COEDGEs.
ENTITY * owner () const
 Returns the pointer to the LOOP or WIRE that owns this COEDGE.
virtual SPAinterval param_range () const
 Returns the parameter range of the EDGE underlying this COEDGE, as an interval, adjusted for sense.
COEDGE * partner () const
 Returns the pointer to the partner COEDGE of this COEDGE.
COEDGE * previous (REVBIT rev) const
 Returns a pointer to the previous COEDGE if the sense argument is FORWARD; otherwise returns a pointer to the next COEDGE.
COEDGE * previous () const
 Returns the previous COEDGE in a doubly-linked list of COEDGEs.
virtual void remove (logical lose_if_zero=TRUE)
 Decrements the use count of this ENTITY.
void restore_common ()
 Restores data for a record from disc to memory.
void restore_end (char *id_str)
 Terminates a restore record.
void roll_notify (BULLETIN_TYPE, ENTITY *)
 Fields notifications of rollback operations.
BULLETIN *& rollback () const
 Returns the pointer to the bulletin board entry for this ENTITY.
virtual void save (ENTITY_LIST &) const
 Performs a save operation.
REVBIT sense (REVBIT rev) const
 Returns the sense of this COEDGE compounded with the sense argument.
REVBIT sense () const
 Returns the relationship between the direction of this COEDGE and that of the underlying EDGE.
void set_attrib (ATTRIB *attr)
 Changes the attribute pointer of this ENTITY to point to the given attribute.
void set_edge (EDGE *edge, logical reset_pattern=TRUE)
 Sets the underlying EDGE of this COEDGE.
virtual void set_geometry (PCURVE *pcrv, logical reset_pattern=TRUE)
 Sets this COEDGE's parameter-space geometry to the given PCURVE.
void set_loop (LOOP *loop, logical reset_pattern=TRUE)
 Sets the owning ENTITY of this COEDGE to the specified LOOP.
void set_next (COEDGE *next, REVBIT rev=FALSE, logical reset_pattern=TRUE)
 Sets this COEDGE's next COEDGE pointer, taking into account the specified sense.
void set_next_no_rev (COEDGE *next, logical reset_pattern=TRUE)
 Sets this COEDGE's next COEDGE pointer.
void set_owner (ENTITY *owner, logical reset_pattern=TRUE)
 Sets the owning ENTITY of this COEDGE to the specified ENTITY.
void set_partner (COEDGE *partner, logical reset_pattern=TRUE)
 Sets this COEDGE's partner to be the given COEDGE.
void set_previous (COEDGE *previous, REVBIT rev=FALSE, logical reset_pattern=TRUE)
 Sets this COEDGE's previous COEDGE pointer, taking into account the specified sense.
void set_previous_no_rev (COEDGE *previous, logical reset_pattern=TRUE)
 Sets this COEDGE's previous COEDGE pointer.
void set_sense (REVBIT sense, logical reset_pattern=TRUE)
 Sets the sense of this COEDGE with respect to the underlying EDGE.
void set_shell (SHELL *shell, logical reset_pattern=TRUE)
 Sets the owning ENTITY of this COEDGE to the specified SHELL.
virtual void set_use_count (int use)
 Sets the reference use count of this ENTITY.
void set_wire (WIRE *wire, logical reset_pattern=TRUE)
 Sets the owning ENTITY of this COEDGE to the specified WIRE.
SHELL * shell () const
 Returns the owner of this COEDGE if the former is a SHELL, otherwise NULL.
virtual unsigned size () const
 Returns the size, in bytes, of this ENTITY.
VERTEX * start (REVBIT rev)
 Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense and a sense argument.
VERTEX * start () const
 Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense.
virtual SPAparameter start_param () const
 Returns either the start or end parameter of the EDGE underlying this COEDGE, depending upon the coedge's sense.
virtual SPAposition start_pos () const
 Returns either the start or end position of the EDGE underlying this COEDGE, depending upon the coedge's sense.
logical starts_at_singularity () const
 Determines if this coedge starts at a surface singularity.
tag_id_type tag (logical assign_new=TRUE) const
 Data reading routine.
virtual const char * type_name () const
 Returns a name for this ENTITY's type.
virtual int use_count () const
 Returns the use count of this ENTITY.
WIRE * wire () const
 Returns the owner of this COEDGE if the former is a WIRE, otherwise NULL.

Static Public Member Functions

static MethodFunction add_method (METHOD_ID const &, MethodFunction)
 Registers an implementation function for a run-time virtual method.

Protected Member Functions

virtual logical bulletin_no_change_vf (ENTITY const *other, logical identical_comparator) const
 Virtual compare function for api_get_modified_faces.
void check_destroy () const
 Checks that entity deletion is legitimate.
void copy_common (ENTITY_LIST &list, const ENTITY *from, pointer_map *pm=NULL, logical dpcpy_skip=FALSE, SCAN_TYPE reason=SCAN_COPY)
 Fills in this ENTITY with data from the copied ENTITY, converting pointers into indices in the supplied ENTITY_LIST.
void fix_common (ENTITY *[], SCAN_TYPE reason=SCAN_COPY)
 Converts pointers from copy indices into real pointers.
void fixup_copy (ENTITY *rollback) const
 Fixes any pointers in the ENTITY after copying for backup.
logical holds_pattern () const
 Returns TRUE if this entity can have a pattern_holder.
logical is_unknown_entity (void) const
 Returns TRUE if this is an unknown entity.
void save_begin (logical terminator=FALSE) const
 Starts a save record.
void save_common (ENTITY_LIST &) const
 Handles the save operation.
void save_end (ENTITY_LIST &list) const
 Terminates a save record.
virtual void set_geometry_ptr (PCURVE *pcrv)
 Sets this COEDGE's parameter-space geometry to the given PCURVE.

Protected Attributes

EDGE * edge_ptr
 Pointer to the single EDGE on which this COEDGE and all its partners lie.
PCURVE * geometry_ptr
 Pointer to the description of the EDGE geometry in reference to the parametric space of the FACE in which it is embedded.
COEDGE * next_ptr
 Pointer to provide a doubly-linked list of COEDGEs in a LOOP, or circular lists at each end in a general unembedded graph.
ENTITY * owner_ptr
 Pointer to the owning LOOP or WIRE.
COEDGE * partner_ptr
 Pointer to a partner COEDGE, or NULL if this COEDGE is unembedded or attached to a free EDGE.
COEDGE * previous_ptr
 Pointer to provide a doubly-linked list of COEDGEs in a LOOP, or circular lists at each end in a general unembedded graph.
REVBIT sense_data
 Relationship between the direction of this COEDGE and that of the underlying EDGE.

Detailed Description

Relates EDGEs to adjacent EDGEs and to owning ENTITYs.


Role: A coedge is closely related to an edge. A coedge stores its relationships with adjacent edges and with superior owning entities. (In some contexts, the coedge may be viewed as the use of an edge by a face or wire.) The data structures formed by these relationships (stored as pointers) and their interpretation depend upon the nature of the owning entity.

The typical case is when the coedge's associated edge is part of a well-formed, manifold, solid body shell and when that edge is adjacent to exactly two faces. This results in two coedges, each associated with a loop in one of the faces. (In principle the two faces could be the same, and even the loops could be the same.) All the coedges in each loop are linked into a doubly-linked circular list using the next and previous pointers. The two coedges for each edge are linked through their partner pointers.

Several deviations are possible from the typical case.

Constructor & Destructor Documentation

COEDGE::COEDGE (  ) 

Constructs a COEDGE (default constructor).



Role: Requests memory for this object but does not populate it. The allocation constructor is used primarily by restore. Applications should call this constructor only with the overloaded new operator, because this reserves the memory on the heap, a requirement to support roll back and history management.

COEDGE::COEDGE ( EDGE *  edge,
REVBIT  sense,
COEDGE *  prev,
COEDGE *  next 
)

Constructs a COEDGE from a specified EDGE and the next and previous COEDGES in the owning LOOP.



Role: Requests memory for this object and populates it with the data supplied as the argument. Applications should call this constructor only with the overloaded new operator, because this reserves the memory on the heap, a requirement to support roll back and history management.

The arguments initialize the EDGE (and indirectly the partner EDGE), the sense_data, the previous COEDGE, and the next COEDGE. COEDGE back-pointers are also set in the two argument COEDGEs, but are only valid if all the COEDGEs are part of a conventional simple LOOP.

Parameters:
edge the EDGE in the constructed COEDGE.
sense sense of the COEDGE relative to its EDGE.
prev previous COEDGE in the owning LOOP.
next next COEDGE in the owning LOOP.

Member Function Documentation

virtual void ENTITY::add (  )  [virtual, inherited]

If this ENTITY is use counted, adds one to the count.



Role: If this ENTITY is not use counted, signals an error.

Every held pointer to a use counted ENTITY should be declared by calling add. There should a corresponding call to remove when the user is done with the pointer. For normal ENTITYs, simply call lose when the ENTITY is no longer part of the active model. For use counted ENTITYs, the implementations of add and remove come from macros in usecount.hxx. Use counted ENTITYs implemented without the macros should implement these virtual methods manually.

Reimplemented in CURVE, EE_LIST, SPAGROUP, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SURFACE, and VERTEX_TEMPLATE.

static MethodFunction COEDGE::add_method ( METHOD_ID const &  method_id,
MethodFunction  method_func 
) [static]

Registers an implementation function for a run-time virtual method.



Role: (Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

Parameters:
method_id method id.
method_func method function.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual logical COEDGE::apply_transform ( SPAtransf const &  t,
ENTITY_LIST &  list,
logical  negate = FALSE,
logical  reset_pattern = TRUE 
) [virtual]

Transforms this ENTITY.



Role: The ENTITY_LIST is used to prevent sub-entities from being transformed more than once. This method is not included with the standard ENTITY methods in order to allow nontransformable ENTITYs to use the default implementation. (Supplied by the TRANSFORM_FUNCTION and TRANSFORM_DEF macros.)

Parameters:
t the transform to apply.
list list of entities to which the transform has already been applied.
negate negation flag.
reset_pattern internal use only.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

ATTRIB* ENTITY::attrib (  )  const [inline, inherited]

Returns this ENTITY's attribute pointer, or NULL if there is no attached attribute.

ENTITY* ENTITY::backup (  )  [inherited]

Creates a duplicate record and a change bulletin, if needed, as a backup for roll back.



Role: The duplication is done via the virtual function make_copy, to let each derived type do its own backup. Before performing a change, each routine checks whether the data structure is posted on the bulletin board. If not, the posting is done automatically. Called by all system change functions.

int ENTITY::bulletin_count (  )  const [inline, inherited]

Returns the number of bulletins referring to this ENTITY.

virtual logical COEDGE::bulletin_no_change_vf ( ENTITY const *  other,
logical  identical_comparator 
) const [protected, virtual]

Virtual compare function for api_get_modified_faces.



Parameters:
other other entity.
identical_comparator comparator.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual logical COEDGE::call_method ( METHOD_ID const &  method_id,
METHOD_ARGS const &  method_args 
) [virtual]

Executes the implementation function for a routine virtual method.



Role: (Supplied by the ENTITY_FUNCTIONs and UTILITY_DEF macros).

Parameters:
method_id method id.
method_args method args.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

void ENTITY::check_destroy (  )  const [inline, protected, inherited]

Checks that entity deletion is legitimate.



Role: This method complains if there is an attempt to delete an entity other than through the private member function destroy, which is carefully controlled.

void ENTITY::copy_common ( ENTITY_LIST &  list,
const ENTITY *  from,
pointer_map *  pm = NULL,
logical  dpcpy_skip = FALSE,
SCAN_TYPE  reason = SCAN_COPY 
) [protected, inherited]

Fills in this ENTITY with data from the copied ENTITY, converting pointers into indices in the supplied ENTITY_LIST.



Role: Supports the copy operation. (Supplied by the ENTITY_FUNCTIONS and COPY_DEF macros.) Whenever the operation encounters a pointer to a dependent ENTITY, it find the index of the latter in the supplied ENTITY_LIST and sets the corresponding pointer in the copy to that index.

Parameters:
list list of ENTITYs being copied.
from original ENTITY being copied.
pm pointer map.
dpcpy_skip Used only by the base ENTITY and base ATTRIB class. No other derived entity or attribute should need to utilize this value. This logical indicates how non- deepcopyable attributes are handled during a deep copy. If TRUE, the copy will continue even if it encounters attributes marked as not deep-copyable. By default (FALSE), if any attributes that are found to be not deep-copyable, a sys_error will be thrown. (This flag only effects how attributes are handled; any non-deepcopyable non-attribute entities encountered will cause a sys_error to be thrown regardless of this flag's setting.)
reason type of scan.

virtual ENTITY* COEDGE::copy_data ( ENTITY_LIST &  list,
pointer_map *  pm = NULL,
logical  dpcpy_skip = FALSE,
SCAN_TYPE  reason = SCAN_COPY 
) const [virtual]

Allocates a new ENTITY and calls copy_common to fill it in.



Role: Supports the copy operation. (Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

Parameters:
list ENTITYs to copy.
pm pointer map.
dpcpy_skip Used only by the base ENTITY and base ATTRIB class. No other derived entity or attribute should need to utilize this value. This logical indicates how non- deepcopyable attributes are handled during a deep copy. If TRUE, the copy will continue even if it encounters attributes marked as not deep-copyable. By default (FALSE), if any attributes that are found to be not deep-copyable, a sys_error will be thrown. (This flag only effects how attributes are handled; any non-deepcopyable non-attribute entities encountered will cause a sys_error to be thrown regardless of this flag's setting.)
reason scan type.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual void COEDGE::copy_scan ( ENTITY_LIST &  list,
SCAN_TYPE  reason = SCAN_COPY,
logical  dpcpy_skip = FALSE 
) const [virtual]

Adds dependent ENTITYs of this ENTITY to the list of ENTITYs to be copied.



Role: Supports the copy operation. (Supplied by the ENTITY_FUNCTIONS and SCAN_DEF macros.) The default type of scan (reason) is SCAN_COPY.

Parameters:
list ENTITYs to copy.
reason type of copy.
dpcpy_skip Used only by the base ENTITY and base ATTRIB class. No other derived entity or attribute should need to utilize this value. This logical indicates how non- deepcopyable attributes are handled during a deep copy. If TRUE, the copy will continue even if it encounters attributes marked as not deep-copyable. By default (FALSE), if any attributes that are found to be not deep-copyable, a sys_error will be thrown. (This flag only effects how attributes are handled; any non-deepcopyable non-attribute entities encountered will cause a sys_error to be thrown regardless of this flag's setting.)

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual void COEDGE::debug_ent ( FILE *  file_pointer  )  const [virtual]

Prints the type and address of this ENTITY, roll back pointer, attributes, and any unknown subtype information.



Role: This method is called by DEBUG_LIST::debug for an entirely unknown ENTITY type, or at the start of any derived class's debug_ent method. Each derived class's debug_ent method uses the debug function described in the Spatial Product Documentation to print information added at that level. (Supplied by the ENTITY_FUNCTIONS and DEBUG_DEF macros.)

Parameters:
file_pointer file pointer.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual logical ENTITY::deletable (  )  const [virtual, inherited]

Indicates whether or not this ENTITY is normally destroyed by lose.



Role: Returns FALSE if the ENTITY is shared among multiple owners by means of a use count, and so gets destroyed implicitly when every owner has been lost. Most ENTITYs are destroyed explicitly using lose, so the default returns TRUE.

Reimplemented in ANNOTATION, ATTRIB_TAG, ATTRIB, CELL, CFACE, CSHELL, CURVE, EE_LIST, SPAGROUP, ID_ATTRIB, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SUPERCELL, SURFACE, TRANSFORM, and VERTEX_TEMPLATE.

EDGE* COEDGE::edge (  )  const [inline]

Returns a pointer to the single EDGE on which this COEDGE and all its partners lie.

VERTEX* COEDGE::end ( REVBIT  rev  )  [inline]

Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense and a sense argument.



Role: Returns the edge's end VERTEX if the product of the coedge's sense and the sense argument rev is FORWARD; otherwise, returns the edge's start VERTEX.

Parameters:
rev sense argument.

VERTEX* COEDGE::end (  )  const

Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's end VERTEX if the sense is FORWARD; otherwise, returns the edge's start VERTEX.

virtual SPAparameter COEDGE::end_param (  )  const [virtual]

Returns either the start or end parameter of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's end parameter if the sense is FORWARD; otherwise, returns the edge's start parameter.

Reimplemented in TCOEDGE.

virtual SPAposition COEDGE::end_pos (  )  const [virtual]

Returns either the start or end position of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's end position if the sense is FORWARD; otherwise, returns the edge's start position.

Reimplemented in TCOEDGE.

logical COEDGE::ends_at_singularity (  )  const

Determines if this coedge ends at a surface singularity.

void COEDGE::fix_common ( ENTITY *  array[],
SCAN_TYPE  reason = SCAN_COPY 
) [protected]

Converts pointers from copy indices into real pointers.



Role: Called by fix_pointers. For ENTITY, converts the attribute pointer, and any pointers in the unknown_entity_text record. (Supplied by the ENTITY_FUNCTIONS and FIX_POINTER_DEF macros.)

Parameters:
array ENTITY pointers to fix.
reason type of scan.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual void COEDGE::fix_pointers ( ENTITY *  entity_array[],
SCAN_TYPE  reason = SCAN_COPY 
) [virtual]

Converts pointers from copy indices into real pointers.



Role: The fix_pointers method for each entity in the restore array is called, with the given array as an argument. This calls fix_common, which calls its parent's fix_common, and then corrects any pointers in the derived class. In practice there is never anything special for fix_pointers to do, but it is retained for consistency and compatibility. (Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

Parameters:
entity_array ENTITY pointers to fix.
reason type of scan.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

void ENTITY::fixup_copy ( ENTITY *  rollback  )  const [protected, inherited]

Fixes any pointers in the ENTITY after copying for backup.



Role: For ENTITY, this method has nothing to do, but because it is called by all data types, it is required to terminate the copy chain. (Supplied by the ENTITY_FUNCTIONS and SIMPLE_COPY_CONE macros.)

Parameters:
rollback the ENTITY to copy for backup.

Reimplemented in GA_WORKSPACE.

virtual void ENTITY::full_size ( SizeAccumulator &  est,
logical  countSelf = TRUE 
) const [virtual, inherited]

Increments the SizeAccumulator by the size, in bytes, of everything owned by this ENTITY and, optionally, of the ENTITY itself.



Role: If countSelf is TRUE, increments the SizeAccumulator by the size, in bytes, of the ENTITY and everything owned by the ENTITY. If countSelf is FALSE, increments the SizeAccumulator by the size, in bytes, of everything owned by the ENTITY, but not including the size of the ENTITY itself.

For example, if an ENTITY contained a character string and full_size were called with countSelf == FALSE, the SizeAccumulator would be incremented by the size, in bytes, of the character string.

Reimplemented in ATTRIB_CELL_INT_PRECEDENCE, ATTRIB_GEN_NAME, ATTRIB_GEN_STRING, ATTRIB_GEN_WSTRING, ATTRIB_BLEND, ATTRIB_FFBLEND, CELL, SPACOLLECTION, CONE, CSHELL, CURVE, EE_LIST, ELLIPSE, GA_WORKSPACE, SPAGROUP, HELIX, INTCURVE, LAW, PCURVE, PLANE, APOINT, SPHERE, SPLINE, STRAIGHT, SUPERCELL, SURFACE, TEXT_ENT, TORUS, UNDEFC, and ATTRIB_VAR_BLEND.

PCURVE* COEDGE::geometry (  )  const [inline]

Returns the pointer to the description of the COEDGE geometry in reference to the parametric space of the FACE in which it is embedded.



Role: The pointer is NULL if the COEDGE is not embedded, or if the FACE is not parametric.

HISTORY_STREAM* ENTITY::history (  )  const [inline, inherited]

Returns a pointer to the history stream for this ENTITY.

logical COEDGE::holds_pattern (  )  const [inline, protected, virtual]

Returns TRUE if this entity can have a pattern_holder.

For internal use only.

Reimplemented from ENTITY.

virtual int COEDGE::identity ( int  level = 0  )  const [virtual]

Returns a type identifier for this ENTITY.



Role: If level is unspecified or 0, returns the type identifier ENTITY_TYPE. If level is specified, returns ENTITY_TYPE for that level of derivation from ENTITY. The level of this class is defined as ENTITY_LEVEL.

A positive level specifies the level of derivation down from the ENTITY class to examine. ENTITY itself has level 0. If level is unspecified or 0, the type of the most specific class of object is returned. If level is 1, the type of the class one level down from ENTITY is returned. If level is 2, the type of the parent class 2 levels down from ENTITY is returned, and so on. If level is greater than the level of the instance, -1 ("unknown") is returned.

A negative level similarly specifies the level of derivation up from the most specific class of object returned.

(Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

Parameters:
level the derivation level at which the object is to be identified.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual logical COEDGE::is_deepcopyable (  )  const [virtual]

Returns TRUE if this ENTITY can be deep copied.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

logical ENTITY::is_unknown_entity ( void   )  const [protected, inherited]

Returns TRUE if this is an unknown entity.

An unknown entity is one that is restored from SAT/SAB but is not native to the running app.

virtual logical ENTITY::is_use_counted (  )  const [virtual, inherited]

Indicates if this ENTITY is use-counted or not.



Role: The default implementation returns FALSE.

Reimplemented in CURVE, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SURFACE, and VERTEX_TEMPLATE.

virtual int COEDGE::lookup ( logical  insert  )  const [virtual]

Looks up this ENTITY in the appropriate debug list.



Role: This method is not included among the standard ENTITY methods because often subclasses may wish to be included in their parent's debug list. This is done simply by not including a lookup method in the subclass.

When the logical argument is TRUE, the ENTITY is inserted into the debug list if it does not already exist in the list. If it is FALSE and the ENTITY does not exist in the list, a -1 is returned. (Supplied by the LOOK_FUNCTION and LOOKUP_DEF macros.)

Parameters:
insert flag to insert into debug list.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

LOOP* COEDGE::loop (  )  const

Returns the owner of this COEDGE if the former is a LOOP, otherwise NULL.

virtual void COEDGE::lose (  )  [virtual]

Posts a delete bulletin to the bulletin board indicating the instance is no longer used in the active model.



Role: The lose methods for attached attributes are also called.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

TCOEDGE* COEDGE::make_tolerant (  ) 

Makes a tolerant TCOEDGE out of this COEDGE.

logical ENTITY::needs_rollback (  )  const [inline, inherited]

Checks whether or not the record is already backed up.

COEDGE* COEDGE::next ( REVBIT  rev  )  const [inline]

Returns a pointer to the next COEDGE if the sense argument is FORWARD; otherwise returns a pointer to the previous COEDGE.



Parameters:
rev sense argument.

COEDGE* COEDGE::next (  )  const [inline]

Returns the next COEDGE in a doubly-linked list of COEDGEs.

ENTITY* COEDGE::owner (  )  const [virtual]

Returns the pointer to the LOOP or WIRE that owns this COEDGE.



Role: There is always a LOOP if the COEDGE is embedded in a FACE, or a WIRE if it is part of an unembedded graph. If the COEDGE is an unembedded one in a mixed-dimensionality SHELL, the function may return the SHELL.

Reimplemented from ENTITY.

virtual SPAinterval COEDGE::param_range (  )  const [virtual]

Returns the parameter range of the EDGE underlying this COEDGE, as an interval, adjusted for sense.



Role: If the coedge sense is REVERSED, the returned interval is the negated edge parameter range.

Reimplemented in TCOEDGE.

COEDGE* COEDGE::partner (  )  const [inline]

Returns the pointer to the partner COEDGE of this COEDGE.



Role: The return will be NULL if this COEDGE is unembedded or attached to a free EDGE.

COEDGE* COEDGE::previous ( REVBIT  rev  )  const [inline]

Returns a pointer to the previous COEDGE if the sense argument is FORWARD; otherwise returns a pointer to the next COEDGE.



Parameters:
rev sense argument.

COEDGE* COEDGE::previous (  )  const [inline]

Returns the previous COEDGE in a doubly-linked list of COEDGEs.

virtual void ENTITY::remove ( logical  lose_if_zero = TRUE  )  [virtual, inherited]

Decrements the use count of this ENTITY.



Role: If the use count reaches 0, the ENTITY's lose method is called if the argument lose_if_zero is set to TRUE. (If the entity is not use counted, an error is signaled.)

Every held pointer to a use counted ENTITY should be declared by calling add. There should a corresponding call to remove when the user is done with the pointer. For normal ENTITYs, simply call lose when the ENTITY is no longer part of the active model. For use counted ENTITYs, the implementations of add and remove come from macros in usecount.hxx. Use counted ENTITYs implemented without the macros should implement these virtual methods manually.

Parameters:
lose_if_zero flag to lose the ENTITY when the use count drops to 0.

Reimplemented in CURVE, SPAGROUP, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SURFACE, and VERTEX_TEMPLATE.

void COEDGE::restore_common (  ) 

Restores data for a record from disc to memory.



Role: Writes pointers as indices (fix_pointers turns them back into pointers) and returns a pointer to the ENTITY made. Generally, "common" functions that do the main work are protected, as they are called only from the main entry functions or by themselves up the derivation tree.

This method is public, however, because the main restore function is not a member function, and making it a friend would make it unable to be declared static, i.e., local to the defining module. (Supplied by the ENTITY_FUNCTIONS and RESTORE_DEF macros.) 

    read_ptr  Pointer to record in save file for first attribute owned by entity.
    if (restore_version_number >= ENTITY_TAGS_VERSION)
       read_int      new tag

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

void ENTITY::restore_end ( char *  id_str  )  [inherited]

Terminates a restore record.



Role: Reads any trailing text and fills in the unknown text pointer. Used only by the save/restore system.

Parameters:
id_str the id string.

void COEDGE::roll_notify ( BULLETIN_TYPE  bulletin_type,
ENTITY *  ent 
) [virtual]

Fields notifications of rollback operations.



Role: The first argument specifies the type of bulletin being rolled back (create, delete or change). In the case of a change notification, the second argument contains the information to be restored into this object. The base implementation, which is used for almost every derived class, does nothing at all.

Parameters:
bulletin_type type of bulletin being rolled back.
ent information to be restored into this argument.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

BULLETIN*& ENTITY::rollback (  )  const [inline, inherited]

Returns the pointer to the bulletin board entry for this ENTITY.

virtual void COEDGE::save ( ENTITY_LIST &  entity_list  )  const [virtual]

Performs a save operation.



Role: Calls save_begin, the particular class's save_common, and then save_end. (Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

This save method is just like any other save, except that it calls save_begin with an optional argument to suppress writing of a trailing dash, because save_common does not write out an identifier, or call any parent class's save_common.

Parameters:
entity_list ENTITYs to save.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

void ENTITY::save_begin ( logical  terminator = FALSE  )  const [protected, inherited]

Starts a save record.



Role: Writes a preamble to a save file record, which contains any subclass identifiers not known to this version of ACIS. Called by the save method.

Parameters:
terminator terminator flag.

void COEDGE::save_common ( ENTITY_LIST &  entity_list  )  const [protected]

Handles the save operation.



Role: Writes out the savable data associated with the base class. In the case of ENTITY, saveable data is simply the attribute pointer. In the case of child classes derived from ENTITY, class-specific save_common methods handle the class-specific data. Called by the save method. (Supplied by the ENTITY_FUNCTIONS and SAVE_DEF macros.)

Each derived class's save_common method first writes out that class's identifier, calls its parent class's save_common method, and then writes out data particular to the derived class. Thus the save record consists of identifiers in leaf-to-base order, followed by class data in base-to-leaf order. As it writes out any ENTITY pointers, it adds them to the ENTITY_LIST, so that any dependent data also gets written to the file.

Parameters:
entity_list ENTITYs to save

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

void ENTITY::save_end ( ENTITY_LIST &  list  )  const [protected, inherited]

Terminates a save record.



Role: Writes out any data associated with subclasses not known to this version of ACIS before terminating the record. Called by the save method.

Parameters:
list list of entities.

REVBIT COEDGE::sense ( REVBIT  rev  )  const [inline]

Returns the sense of this COEDGE compounded with the sense argument.



Role: Useful when traversing COEDGEs in the reverse direction.

REVBIT COEDGE::sense (  )  const [inline]

Returns the relationship between the direction of this COEDGE and that of the underlying EDGE.



Role: At any point on a COEDGE, if the FACE normal is upwards and the COEDGE tangent is forward, then the FACE lies to the left. This implies that the outer LOOPs are counterclockwise and the inner LOOPs are clockwise with respect to the FACE normal.

void ENTITY::set_attrib ( ATTRIB *  attr  )  [inherited]

Changes the attribute pointer of this ENTITY to point to the given attribute.



Parameters:
attr the new attribute.

void COEDGE::set_edge ( EDGE *  edge,
logical  reset_pattern = TRUE 
)

Sets the underlying EDGE of this COEDGE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
edge the new underlying EDGE.
reset_pattern internal use only.

virtual void COEDGE::set_geometry ( PCURVE *  pcrv,
logical  reset_pattern = TRUE 
) [virtual]

Sets this COEDGE's parameter-space geometry to the given PCURVE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
pcrv the new PCURVE.
reset_pattern internal use only.

Reimplemented in TCOEDGE.

virtual void COEDGE::set_geometry_ptr ( PCURVE *  pcrv  )  [protected, virtual]

Sets this COEDGE's parameter-space geometry to the given PCURVE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
pcrv the new PCURVE.

Reimplemented in TCOEDGE.

void COEDGE::set_loop ( LOOP *  loop,
logical  reset_pattern = TRUE 
)

Sets the owning ENTITY of this COEDGE to the specified LOOP.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
loop the new parent LOOP.
reset_pattern internal use only.

void COEDGE::set_next ( COEDGE *  next,
REVBIT  rev = FALSE,
logical  reset_pattern = TRUE 
)

Sets this COEDGE's next COEDGE pointer, taking into account the specified sense.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
next the new next COEDGE.
rev sense argument.
reset_pattern internal use only.

void COEDGE::set_next_no_rev ( COEDGE *  next,
logical  reset_pattern = TRUE 
)

Sets this COEDGE's next COEDGE pointer.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
next the new next COEDGE.
reset_pattern internal use only.

void COEDGE::set_owner ( ENTITY *  owner,
logical  reset_pattern = TRUE 
)

Sets the owning ENTITY of this COEDGE to the specified ENTITY.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
owner the new parent ENTITY.
reset_pattern internal use only.

void COEDGE::set_partner ( COEDGE *  partner,
logical  reset_pattern = TRUE 
)

Sets this COEDGE's partner to be the given COEDGE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
partner the new partner COEDGE.
reset_pattern internal use only.

void COEDGE::set_previous ( COEDGE *  previous,
REVBIT  rev = FALSE,
logical  reset_pattern = TRUE 
)

Sets this COEDGE's previous COEDGE pointer, taking into account the specified sense.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
previous the new previous COEDGE.
rev sense argument.
reset_pattern internal use only.

void COEDGE::set_previous_no_rev ( COEDGE *  previous,
logical  reset_pattern = TRUE 
)

Sets this COEDGE's previous COEDGE pointer.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
previous the new previous COEDGE.
reset_pattern internal use only.

void COEDGE::set_sense ( REVBIT  sense,
logical  reset_pattern = TRUE 
)

Sets the sense of this COEDGE with respect to the underlying EDGE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
sense the new sense.
reset_pattern internal use only.

void COEDGE::set_shell ( SHELL *  shell,
logical  reset_pattern = TRUE 
)

Sets the owning ENTITY of this COEDGE to the specified SHELL.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
shell the new parent SHELL.
reset_pattern internal use only.

virtual void ENTITY::set_use_count ( int  use  )  [virtual, inherited]

Sets the reference use count of this ENTITY.



Role: If the ENTITY is not use counted, this method does nothing.

Parameters:
use new use count.

Reimplemented in CURVE, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SURFACE, and VERTEX_TEMPLATE.

void COEDGE::set_wire ( WIRE *  wire,
logical  reset_pattern = TRUE 
)

Sets the owning ENTITY of this COEDGE to the specified WIRE.



Role: Before performing the change, it checks if the data structure is posted on the bulletin board. If not, the method calls backup to put an entry on the bulletin board.

Parameters:
wire the new parent WIRE.
reset_pattern internal use only.

SHELL* COEDGE::shell (  )  const

Returns the owner of this COEDGE if the former is a SHELL, otherwise NULL.

virtual unsigned COEDGE::size (  )  const [virtual]

Returns the size, in bytes, of this ENTITY.



Role: (Supplied by the ENTITY_FUNCTIONS and UTILITY_DEF macros.)

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

VERTEX* COEDGE::start ( REVBIT  rev  )  [inline]

Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense and a sense argument.



Role: Returns the edge's start VERTEX if the product of the coedge's sense and the sense argument rev is FORWARD; otherwise, returns the edge's end VERTEX.

Parameters:
rev sense argument.

VERTEX* COEDGE::start (  )  const

Returns either the start or end VERTEX of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's start VERTEX if the sense is FORWARD; otherwise, returns the edge's end VERTEX.

virtual SPAparameter COEDGE::start_param (  )  const [virtual]

Returns either the start or end parameter of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's start parameter if the sense is FORWARD; otherwise, returns the edge's end parameter.

Reimplemented in TCOEDGE.

virtual SPAposition COEDGE::start_pos (  )  const [virtual]

Returns either the start or end position of the EDGE underlying this COEDGE, depending upon the coedge's sense.



Role: Returns the edge's start position if the sense is FORWARD; otherwise, returns the edge's end position.

Reimplemented in TCOEDGE.

logical COEDGE::starts_at_singularity (  )  const

Determines if this coedge starts at a surface singularity.

tag_id_type ENTITY::tag ( logical  assign_new = TRUE  )  const [inline, inherited]

Data reading routine.



Parameters:
assign_new flag to assign a new tag number or not.

virtual const char* COEDGE::type_name (  )  const [virtual]

Returns a name for this ENTITY's type.



Role: For the ENTITY class, unknown is returned.

Reimplemented from ENTITY.

Reimplemented in TCOEDGE.

virtual int ENTITY::use_count (  )  const [virtual, inherited]

Returns the use count of this ENTITY.



Role: Returns zero if the ENTITY is not use counted.

Reimplemented in CURVE, PCURVE, PHLV5_OCC, APOINT, REFINEMENT, RH_MATERIAL, RH_TEXTURE_SPACE, SURFACE, and VERTEX_TEMPLATE.

WIRE* COEDGE::wire (  )  const

Returns the owner of this COEDGE if the former is a WIRE, otherwise NULL.

Member Data Documentation

EDGE* COEDGE::edge_ptr [protected]

Pointer to the single EDGE on which this COEDGE and all its partners lie.

PCURVE* COEDGE::geometry_ptr [protected]

Pointer to the description of the EDGE geometry in reference to the parametric space of the FACE in which it is embedded.



Role: This will be NULL if the EDGE is not embedded, or if the FACE is not parametrically described. It may be NULL even if the FACE is parametric.

COEDGE* COEDGE::next_ptr [protected]

Pointer to provide a doubly-linked list of COEDGEs in a LOOP, or circular lists at each end in a general unembedded graph.

ENTITY* COEDGE::owner_ptr [protected]

Pointer to the owning LOOP or WIRE.



Role: There is always a LOOP if the COEDGE is embedded in a FACE, or a WIRE if it is part of an unembedded graph. If this COEDGE is an unembedded one in a mixed-dimensionality SHELL, then this pointer is NULL.

COEDGE* COEDGE::partner_ptr [protected]

Pointer to a partner COEDGE, or NULL if this COEDGE is unembedded or attached to a free EDGE.

COEDGE* COEDGE::previous_ptr [protected]

Pointer to provide a doubly-linked list of COEDGEs in a LOOP, or circular lists at each end in a general unembedded graph.

REVBIT COEDGE::sense_data [protected]

Relationship between the direction of this COEDGE and that of the underlying EDGE.



Role: When embedded in a FACE, the COEDGEs must run clockwise about the (outward) FACE normal; that is, at any point on the COEDGE, if the FACE normal is "upwards" and the COEDGE tangent is "forwards", then the FACE lies to the "left".