Actual source code: destroy.c

  1: /*$Id: destroy.c,v 1.59 2001/03/23 23:20:38 balay Exp $*/
  2: /*
  3:      Provides utility routines for manulating any type of PETSc object.
  4: */
 5:  #include petsc.h

  7: /*@C
  8:    PetscObjectDestroy - Destroys any PetscObject, regardless of the type. 

 10:    Collective on PetscObject

 12:    Input Parameter:
 13: .  obj - any PETSc object, for example a Vec, Mat or KSP.
 14:          This must be cast with a (PetscObject), for example, 
 15:          PetscObjectDestroy((PetscObject)mat);

 17:    Level: intermediate

 19:     Concepts: destroying object
 20:     Concepts: freeing object
 21:     Concepts: deleting object

 23: @*/
 24: int PetscObjectDestroy(PetscObject obj)
 25: {


 31:   if (obj->bops->destroy) {
 32:     (*obj->bops->destroy)(obj);
 33:   } else {
 34:     SETERRQ(PETSC_ERR_SUP,"This PETSc object does not have a generic destroy routine");
 35:   }
 36:   return(0);
 37: }

 39: /*@C
 40:    PetscObjectView - Views any PetscObject, regardless of the type. 

 42:    Collective on PetscObject

 44:    Input Parameters:
 45: +  obj - any PETSc object, for example a Vec, Mat or KSP.
 46:          This must be cast with a (PetscObject), for example, 
 47:          PetscObjectView((PetscObject)mat,viewer);
 48: -  viewer - any PETSc viewer

 50:    Level: intermediate

 52: @*/
 53: int PetscObjectView(PetscObject obj,PetscViewer viewer)
 54: {

 59:   if (!viewer) viewer = PETSC_VIEWER_STDOUT_(obj->comm);

 62:   if (obj->bops->view) {
 63:     (*obj->bops->view)(obj,viewer);
 64:   } else {
 65:     SETERRQ(PETSC_ERR_SUP,"This PETSc object does not have a generic viewer routine");
 66:   }
 67:   return(0);
 68: }

 70: /*@C
 71:    PetscTypeCompare - Determines whether a PETSc object is of a particular type.

 73:    Not Collective

 75:    Input Parameters:
 76: +  obj - any PETSc object, for example a Vec, Mat or KSP.
 77:          This must be cast with a (PetscObject), for example, 
 78:          PetscObjectDestroy((PetscObject)mat);
 79: -  type_name - string containing a type name

 81:    Output Parameter:
 82: .  same - PETSC_TRUE if they are the same, else PETSC_FALSE
 83:   
 84:    Level: intermediate

 86: .seealso: VecGetType(), KSPGetType(), PCGetType(), SNESGetType()

 88:    Concepts: comparing^object types
 89:    Concepts: types^comparing
 90:    Concepts: object type^comparing

 92: @*/
 93: int PetscTypeCompare(PetscObject obj,char *type_name,PetscTruth *same)
 94: {

 98:   if (!obj) {
 99:     *same = PETSC_FALSE;
100:   } else if (type_name == PETSC_NULL && obj->type_name == PETSC_NULL) {
101:     *same = PETSC_TRUE;
102:   } else if (type_name == PETSC_NULL || obj->type_name == PETSC_NULL) {
103:     *same = PETSC_FALSE;
104:   } else {
107:     PetscStrcmp((char*)(obj->type_name),type_name,same);
108:   }
109:   return(0);
110: }

112: /*@C
113:   PetscSerializeCompare - Determines if a PETSc object has a particular serializer.

115:   Not Collective

117:   Input Parameters:
118: + obj            - The PETSc object, for example a Vec, Mat or KSP.
119: - serialize_name - string containing a serializer name

121:   Output Parameter:
122: . same           - PETSC_TRUE if they are the same, else PETSC_FALSE

124:   Note:
125:   This works for any PETSc object, and thus must be cast with a (PetscObject).

127:   Level: intermediate

129: .keywords: comparing serializers
130: .seealso: VecGetType(), KSPGetType(), PCGetType(), SNESGetType()

132:    Concepts: comparing^object serializers
133:    Concepts: serialize^comparing
134:    Concepts: object serialize^comparing
135: @*/
136: int PetscSerializeCompare(PetscObject obj, char *serialize_name, PetscTruth *same)
137: {

141:   if (!obj) {
142:     *same = PETSC_FALSE;
143:   } else if ((serialize_name == PETSC_NULL) && (obj->serialize_name == PETSC_NULL)) {
144:     *same = PETSC_TRUE;
145:   } else if ((serialize_name == PETSC_NULL) || (obj->serialize_name == PETSC_NULL)) {
146:     *same = PETSC_FALSE;
147:   } else {
150:     PetscStrcmp((char *) (obj->serialize_name), serialize_name, same);
151:   }
152:   return(0);
153: }

155: static int         PetscObjectRegisterDestroy_Count = 0;
156: static PetscObject PetscObjectRegisterDestroy_Objects[128];

158: /*@C
159:    PetscObjectRegisterDestroy - Registers a PETSc object to be destroyed when
160:      PetscFinalize() is called.

162:    Collective on PetscObject

164:    Input Parameter:
165: .  obj - any PETSc object, for example a Vec, Mat or KSP.
166:          This must be cast with a (PetscObject), for example, 
167:          PetscObjectRegisterDestroy((PetscObject)mat);

169:    Level: developer

171:    Notes:
172:       This is used by, for example, PETSC_VIEWER_XXX_() routines to free the viewer
173:     when PETSc ends.

175: .seealso: PetscObjectRegisterDestroyAll()
176: @*/
177: int PetscObjectRegisterDestroy(PetscObject obj)
178: {
181:   PetscObjectRegisterDestroy_Objects[PetscObjectRegisterDestroy_Count++] = obj;
182:   return(0);
183: }

185: /*@C
186:    PetscObjectRegisterDestroyAll - Frees all the PETSc objects that have been registered
187:      with PetscObjectRegisterDestroy(). Called by PetscFinalize()
188:      PetscFinalize() is called.

190:    Collective on individual PetscObjects

192:    Level: developer

194: .seealso: PetscObjectRegisterDestroy()
195: @*/
196: int PetscObjectRegisterDestroyAll(void)
197: {
198:   int ierr,i;

201:   for (i=0; i<PetscObjectRegisterDestroy_Count; i++) {
202:     PetscObjectDestroy(PetscObjectRegisterDestroy_Objects[i]);
203:   }
204:   return(0);
205: }