|
Purpose:
|
Attaches the subportion of a lump.
|
|
|
Derivation:
|
CELL : ENTITY : ACIS_OBJECT : -
|
|
|
SAT Identifier:
|
"cell"
|
|
|
Filename:
|
ct/ct_husk/classes/cell.hxx
|
|
|
Description:
|
The
CELL is an abstract class for
CELL2D and
CELL3D. It provides the data and member functions for the list pointers, the lump back pointer, the supercell pointer, and the bounding box. It should never be instanced.
|
|
|
The cell is a minimal connected subportion of a lump. Usually a lump consists of a single cell,which is bounded by an outer cshell and zero, one, or more inner cshells representing voids within the cell. However, when an operation that leaves internal faces in a lump returns a lump with fully enclosed internal regions, each region is represented by a cell.
|
|
|
References:
|
CT
|
SUPERCELL
|
|
by CT
|
ATTRIB_CELL, SUPERCELL
|
|
BASE
|
SPAbox
|
|
KERN
|
LUMP
|
|
|
Constructor:
|
public: CELL::CELL
();
|
|
|
C++ allocation constructor 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 inherited from the
ENTITY class (for example,
x=new CELL), because this reserves the memory on the heap, a requirement to support roll back and history management.
|
|
|
|
|
|
|
public: CELL::CELL
(
|
|
|
CELL*,
|
// next cell
|
|
|
LUMP*,
|
// lump
|
|
|
SPAbox*
|
// bounding box
|
|
|
);
|
|
|
C++ initialize constructor requests memory for this object and populates it with the data supplied as arguments. Applications should call this constructor only with the overloaded
new operator inherited from the
ENTITY class (for example,
x=new CELL(...)), because this reserves the memory on the heap, a requirement to support roll back and history management.
|
|
|
|
|
|
Destructor:
|
public: virtual void CELL::lose
();
|
|
|
Posts a delete bulletin to the bulletin board indicating the instance is no longer used in the active model. The
lose methods for attached attributes are also called.
|
|
|
|
|
|
|
protected: virtual CELL::~CELL
();
|
|
|
This
C++ destructor should never be called directly. Instead, applications should use the overloaded
lose method inherited from the
ENTITY class, because this supports history management. (For example,
x=new CELL(...) then later
x->lose.)
|
|
|
|
|
Methods:
|
public: SPAbox* CELL::bound
() const;
|
|
|
Returns the bound pointer.
|
|
|
|
|
|
|
public: virtual void CELL::debug_ent
(
|
|
|
FILE*
|
// file pointer
|
|
|
) const;
|
|
|
Prints the type and address of this object, roll back pointer, attributes, and any unknown subtype information to the specified file. Refer to the
ENTITY class for more details.
|
|
|
|
|
|
|
public: virtual logical CELL::deletable
() const;
|
|
|
Returns
TRUE if the
CELL is deletable; otherwise, it returns
FALSE.
|
|
|
|
|
|
|
public: virtual int CELL::identity
(
|
|
|
int
|
|
// level
|
|
|
|
= 0
|
|
|
) const;
|
|
|
If
level is unspecified or 0, returns the type identifier
CELL_TYPE. If
level is specified, returns
CELL_TYPE for that level of derivation from
ENTITY. The level of this class is defined as
CELL_LEVEL.
|
|
|
|
|
|
|
public: void CELL::invalidate
();
|
|
|
Validates the update data.
|
|
|
|
|
|
|
public: virtual logical
|
|
|
CELL::is_deepcopyable () const;
|
|
|
Returns
TRUE if this can be deep copied.
|
|
|
|
|
|
|
protected: void CELL::kill_bound
();
|
|
|
Sets the bounding pointer to
NULL.
|
|
|
|
|
|
|
public: LUMP* CELL::lump
() const;
|
|
|
Returns the pointer to the owning lump.
|
|
|
|
|
|
|
public: CELL* CELL::next
() const;
|
|
|
Returns the next pointer.
|
|
|
|
|
|
|
public: CELL* CELL::next_in_list
() const;
|
|
|
Returns a pointer to the next in the list.
|
|
|
|
|
|
|
public: virtual ENTITY* CELL::owner
() const;
|
|
|
Returns the entity that owns the cell.
|
|
|
|
|
|
|
public: void CELL::restore_common
();
|
|
|
The
RESTORE_DEF macro expands to the
restore_common method, which is used in reading information from a SAT file. This method is never called directly. It is called by a higher hierarchical function if an item in the SAT file is determined to be of this class type. An instance of this class will already have been created through the allocation constructor. This method then populates the class instance with the appropriate data from the SAT file.
|
|
|
read_ptr
|
Pointer to record in save file for next cell
|
|
read_ptr
|
Pointer to record in save file for lump containing cell
|
|
read_ptr
|
Pointer to record in save file for supercell containing cell
|
|
read_int
|
|
|
|
|
validity data
|
|
|
|
|
|
|
public: void CELL::set_bound
(
|
|
|
SPAbox*
|
// bounding box
|
|
|
);
|
|
|
Changes the data for the bounding box. This method checks that the record has been posted on the bulletin board before performing the change. If not, the method returns an error, so that the omission (forgetting to call
backup first) can be rectified in the program.
|
|
|
|
|
|
|
public: void CELL::set_lump
(
|
|
|
LUMP*
|
// lump
|
|
|
);
|
|
|
Changes the data for the lump. This method checks that the record has been posted on the bulletin board before performing the change. If not, the method returns an error, so that the omission (forgetting to call
backup first) can be rectified in the program.
|
|
|
|
|
|
|
public: void CELL::set_next
(
|
|
|
CELL*
|
// cell
|
|
|
);
|
|
|
Changes the data for the next cell. This method checks that the record has been posted on the bulletin board before performing the change. If not, the method returns an error, so that the omission (forgetting to call
backup first) can be rectified in the program.
|
|
|
|
|
|
|
public: void CELL::set_supercell
(
|
|
|
SUPERCELL*
|
// supercell
|
|
|
);
|
|
|
Changes the data for the next cell. This method checks that the record has been posted on the bulletin board before performing the change. If not, the method returns an error, so that the omission (forgetting to call
backup first) can be rectified in the program.
|
|
|
|
|
|
|
public: SUPERCELL* CELL::supercell
() const;
|
|
|
Returns the pointer to the supercell.
|
|
|
|
|
|
|
public: virtual const char*
|
|
|
CELL::type_name () const;
|
|
|
Returns the string "cell".
|
|
|
|
|
|
|
public: logical CELL::valid
() const;
|
|
|
Returns
TRUE if the
CELL is valid; otherwise, it returns
FALSE.
|
|
|
|
|
|
|
public: void CELL::validate
();
|
|
|
Invalidates the update data.
|
|
|
Internal Use:
|
full_size
|
|
|
|
|
|
Related Fncs:
|
is_CELL
|