Fix typo in declaration of 'create' in Section 8.3 (#659)
[dyninst.git] / symtabAPI / doc / API / Types / Type.tex
1 \subsection{Class Type}
2
3 The class \code{Type} represents the types of variables, parameters, return values, and functions. Instances of this class can represent language predefined types (e.g. \code{int}, \code{float}), already defined types in the Object File or binary (e.g., structures compiled into the binary), or newly created types (created using the create factory methods of the corresponding type classes described later in this section) that are added to SymtabAPI by the user. 
4
5 As described in Section \ref{subsec:typeInterface}, this class serves as a base class for all the other classes in this interface. An object of this class is returned from type look up operations performed through the Symtab class described in Section \ref{sec:symtabAPI}. The user can then obtain the specific type object from the generic Type class object. The following example shows how to get the specific object from a given \code{Type} object returned as part of a look up operation.
6
7 \begin{lstlisting}
8 //Example shows how to retrieve a structure type object from a given ``Type'' object
9 using namespace Dyninst;
10 using namespace SymtabAPI;
11
12 //Obj represents a handle to a parsed object file using symtabAPI
13 //Find a structure type in the object file
14 Type *structType = obj->findType(``structType1'');
15
16 // Get the specific typeStruct object
17 typeStruct *stType = structType->isStructType();
18 \end{lstlisting}
19
20 \begin{apient}
21 string &getName()
22 \end{apient}
23 \apidesc{
24 This method returns the name associated with this type.
25 Each of the types is represented by a symbolic name. This method retrieves the
26 name for the type. For example, in the example above "structType1"
27 represents the name for the \code{structType} object.
28 }
29
30 \begin{apient}
31 bool setName(string zname)
32 \end{apient}
33 \apidesc{
34 This method sets the name of this type to name. Returns \code{true} on success and \code{false} on failure.
35 }
36
37 \begin{apient}
38 typedef enum{ 
39     dataEnum,
40     dataPointer,
41     dataFunction,
42     dataSubrange,
43     dataArray,
44     dataStructure,
45     dataUnion,
46     dataCommon,
47     dataScalar,
48     dataTypedef,
49     dataReference,
50     dataUnknownType,
51     dataNullType,
52     dataTypeClass
53 } dataClass;
54 \end{apient}
55
56 \begin{apient}
57 dataClass getType()
58 \end{apient}
59 \apidesc{
60 This method returns the data class associated with the type. 
61 This value should be used to convert this generic type object to a specific type object which offers more functionality by using the corresponding query function described later in this section. For example, if this method returns \code{dataStructure} then the \code{isStructureType()} should be called to dynamically cast the \code{Type} object to the \code{typeStruct} object.
62 }
63
64 \begin{apient}
65 typeId_t getID()
66 \end{apient}
67 \apidesc{
68 This method returns the ID associated with this type.
69 Each type is assigned a unique ID within the object file. For example an integer scalar built-in type is assigned an ID -1.
70 }
71
72 \begin{apient}
73 unsigned getSize()
74 \end{apient}
75 \apidesc{
76 This method returns the total size in bytes occupied by the type.
77 }
78
79 \begin{apient}
80 typeEnum *getEnumType()
81 \end{apient}
82 \apidesc{
83 If this \code{Type} hobject represents an enum type, then return the object casting the \code{Type} object to \code{typeEnum} otherwise return \code{NULL}.
84 }
85
86 \begin{apient}
87 typePointer *getPointerType()
88 \end{apient}
89 \apidesc{
90 If this \code{Type} object represents an pointer type, then return the object casting the \code{Type} object to \code{typePointer} otherwise return \code{NULL}.
91 }
92
93 \begin{apient}
94 typeFunction *getFunctionType()
95 \end{apient}
96 \apidesc{
97 If this \code{Type} object represents an \code{Function} type, then return the object casting the \code{Type} object to \code{typeFunction} otherwise return \code{NULL}.
98 }
99
100 \begin{apient}
101 typeRange *getSubrangeType()
102 \end{apient}
103 \apidesc{
104 If this \code{Type} object represents a \code{Subrange} type, then return the object casting the \code{Type} object to \code{typeSubrange} otherwise return \code{NULL}.
105 }
106
107 \begin{apient}
108 typeArray *getArrayType()
109 \end{apient}
110 \apidesc{
111 If this \code{Type} object represents an \code{Array} type, then return the object casting the \code{Type} object to \code{typeArray} otherwise return \code{NULL}.
112 }
113
114 \begin{apient}
115 typeStruct *getStructType()
116 \end{apient}
117 \apidesc{
118 If this \code{Type} object represents a \code{Structure} type, then return the object casting the \code{Type} object to \code{typeStruct} otherwise return \code{NULL}.
119 }
120
121 \begin{apient}
122 typeUnion *getUnionType()
123 \end{apient}
124 \apidesc{
125 If this \code{Type} object represents a \code{Union} type, then return the object casting the \code{Type} object to \code{typeUnion} otherwise return \code{NULL}.
126 }
127
128 \begin{apient}
129 typeScalar *getScalarType()
130 \end{apient}
131 \apidesc{
132 If this \code{Type} object represents a \code{Scalar} type, then return the object casting the \code{Type} object to \code{typeScalar} otherwise return \code{NULL}.
133 }
134
135 \begin{apient}
136 typeCommon *getCommonType()
137 \end{apient}
138 \apidesc{
139 If this \code{Type} object represents a \code{Common} type, then return the object casting the \code{Type} object to \code{typeCommon} otherwise return \code{NULL}.
140 }
141
142 \begin{apient}
143 typeTypedef *getTypeDefType()
144 \end{apient}
145 \apidesc{
146 If this \code{Type} object represents a \code{TypeDef} type, then return the object casting the \code{Type} object to \code{typeTypedef} otherwise return \code{NULL}.
147 }
148
149 \begin{apient}
150 typeRef *getRefType()
151 \end{apient}
152 \apidesc{
153 If this \code{Type} object represents a \code{Reference} type, then return the object casting the \code{Type} object to \code{typeRef} otherwise return \code{NULL}.
154 }
155
156 \subsection{Class typeEnum}
157 This class represents an enumeration type containing a list of constants with values. This class is derived from \code{Type}, so all those member functions are applicable. \code{typeEnum} inherits from the \code{Type} class.
158
159 \begin{apient}
160 static typeEnum *create(string &name,
161                         vector<pair<string, int> *> &consts, 
162                         Symtab *obj = NULL) 
163 static typeEnum *create(string &name,
164                         vector<string> &constNames,
165                         Symtab *obj)
166 \end{apient}
167 \apidesc{
168 These factory methods create a new enumerated type. There are two variations to this function. \code{consts} supplies the names and Id\92s of the constants of the enum. The first variant is used when user-defined identifiers are required; the second variant is used when system-defined identifiers will be used. 
169 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
170 }
171
172 \begin{apient}
173 bool addConstant(const string &constname,
174                  int value)
175 \end{apient}
176 \apidesc{
177 This method adds a constant to an enum type with name \code{constName} and value \code{value}. 
178 Returns \code{true} on success and \code{false} on failure.
179 }
180
181 \begin{apient}
182 std::vector<std::pair<std::string, int> > &getConstants();
183 \end{apient}
184 \apidesc{
185 This method returns the vector containing the enum constants represented by a (name, value) pair of the constant.
186 }
187
188 \begin{apient}
189 bool setName(const char* name)
190 \end{apient}
191 \apidesc{
192 This method sets the new name of the enum type to \code{name}. 
193 Returns \code{true} if it succeeds, else returns \code{false}.
194 }
195
196 \begin{apient}
197 bool isCompatible(Type *type)
198 \end{apient}
199 \apidesc{
200  This method returns \code{true} if the enum type is compatible with the given type \code{type} or else returns \code{false}. 
201  }
202
203  \subsection{Class typeFunction}
204 This class represents a function type, containing a list of parameters and a return type. This class is derived from \code{Type}, so all the member functions of class \code{Type} are applicable. \code{typeFunction} inherits from the \code{Type} class.
205
206
207 \begin{apient}
208 static typeFunction *create(string &name,
209                             Type *retType, 
210                             vector<Type *> &paramTypes,
211                             Symtab *obj = NULL)
212 \end{apient}
213 \apidesc{
214 This factory method creates a new function type with name \code{name}. \code{retType} represents the return type of the function and \code{paramTypes} is a vector of the types of the parameters in order. 
215 The the newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
216 }
217
218 \begin{apient}
219 bool isCompatible(Type *type)
220 \end{apient}
221 \apidesc{
222 This method returns \code{true} if the function type is compatible with the given type \code{type} or else returns \code{false}. 
223 }
224
225 \begin{apient}
226 bool addParam(Type *type)
227 \end{apient}
228 \apidesc{
229 This method adds a new function parameter with type \code{type} to the function type. 
230 Returns \code{true} if it succeeds, else returns \code{false}.
231 }
232
233 \begin{apient}
234 Type *getReturnType() const
235 \end{apient}
236 \apidesc{
237  This method returns the return type for this function type. Returns \code{NULL} if there is no return type associated with this function type.
238 }
239
240 \begin{apient}
241 bool setRetType(Type *rtype)
242 \end{apient}
243 \apidesc{
244 This method sets the return type of the function type to \code{rtype}. Returns \code{true} if it succeeds, else returns \code{false}.
245 }
246
247 \begin{apient}
248 bool setName(string &name)
249 \end{apient}
250 \apidesc{
251 This method sets the new name of the function type to \code{name}. Returns \code{true} if it succeeds, else returns \code{false}.
252 }
253
254 \begin{apient}
255 vector< Type *> &getParams() const
256 \end{apient}
257 \apidesc{
258 This method returns the vector containing the individual parameters represented by their types in order. Returns \code{NULL} if there are no parameters to the function type.
259 }
260
261 \subsection{Class typeScalar}
262
263 This class represents a scalar type. This class is derived from \code{Type}, so all the
264 member functions of class \code{Type} are applicable. \code{typeScalar} inherits from the Type
265 class.  
266
267 \begin{apient}
268 static typeScalar *create(string &name, int size, Symtab *obj = NULL)
269 \end{apient}
270 \apidesc{
271 This factory method creates a new scalar type. The \code{name} field is used to specify
272 the name of the type, and the \code{size} parameter is used to specify the size in
273 bytes of each instance of the type.  The newly created type is added to the
274 \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but
275 it will be available for further queries.
276 }
277
278 \begin{apient}
279 bool isSigned()
280 \end{apient}
281 \apidesc{
282 This method returns \code{true} if the scalar type is signed or else returns \code{false}.
283 }
284
285 \begin{apient}
286 bool isCompatible(Type *type)
287 \end{apient}
288 \apidesc{
289 This method returns \code{true} if the scalar type is compatible with the given type \code{type} or else returns \code{false}. 
290 }
291
292 \subsection{Class Field}
293 This class represents a field in a container. For e.g. a field in a structure/union type.
294
295
296 \begin{apient}
297 typedef enum {  
298     visPrivate, 
299     visProtected,
300     visPublic,
301     visUnknown
302 } visibility_t;
303 \end{apient}
304 \apidesc{
305 A handle for identifying the visibility of a certain \code{Field} in a container type. This can represent private, public, protected or unknown(default) visibility.
306 }
307
308 \begin{apient}
309 Field(string &name,
310       Type *type,
311       visibility_t vis = visUnknown)
312 \end{apient}
313 \apidesc{
314 This constructor creates a new field with name \code{name}, type \code{type} and visibility \code{vis}. This newly created \code{Field} can be added to a container type.
315 }
316
317 \begin{apient}
318 const string &getName()
319 \end{apient}
320 \apidesc{
321 This method returns the name associated with the field in the container.
322 }
323
324 \begin{apient}
325 Type *getType()
326 \end{apient}
327 \apidesc{
328  This method returns the type associated with the field in the container.
329 }
330
331 \begin{apient}
332 int getOffset()
333 \end{apient}
334 \apidesc{
335 This method returns the offset associated with the field in the container.
336 }
337
338 \begin{apient}
339 visibility_t getVisibility()
340 \end{apient}
341 \apidesc{
342 This method returns the visibility associated with a field in a container.
343 This returns \code{visPublic} for the variables within a common block.
344 }
345
346 \subsection{Class fieldListType}
347
348 This class represents a container type. It is one of the three categories of types as described in Section \ref{subsec:typeInterface}. The structure and the union types fall under this category. This class is derived from \code{Type}, so all the member functions of class \code{Type} are applicable. \code{fieldListType} inherits from the \code{Type} class.
349
350
351 \begin{apient}
352 vector<Field *> *getComponents()
353 \end{apient}
354 \apidesc{
355 This method returns the list of all fields present in the container. 
356 This gives information about the name, type and visibility of each of the fields. Returns \code{NULL} of there are no fields.
357 }
358
359 \begin{apient}
360 void addField(std::string fieldname,
361               Type *type,
362               int offsetVal = -1, 
363               visibility_t vis = visUnknown)
364 \end{apient}
365 \apidesc{
366 This method adds a new field at the end to the container type with field name \code{fieldname}, type \code{type} and type visibility \code{vis}.
367 }
368
369 \begin{apient}
370 void addField(unsigned num,
371               std::string fieldname,
372               Type *type,
373               int offsetVal = -1, 
374               visibility_t vis = visUnknown)         
375 \end{apient}
376 \apidesc{
377 This method adds a field after the field with number \code{num} with field name \code{fieldname}, type \code{type} and type visibility \code{vis}.
378 }
379
380 \begin{apient}
381 void addField(Field *fld)
382 \end{apient}
383 \apidesc{
384 This method adds a new field \code{fld} to the container type.}
385
386 \begin{apient}
387 void addField(unsigned num,
388               Field *fld)
389 \end{apient}
390 \apidesc{
391 This method adds a field \code{fld} after field \code{num} to the container type.
392 }
393
394 \subsubsection{Class typeStruct : public fieldListType}
395 \mbox{ }\\
396
397 This class represents a structure type. The structure type is a special case of
398 the container type. The fields of the structure represent the fields in this
399 case. As a subclass of class \code{fieldListType}, all methods in \code{fieldListType} are
400 applicable.
401
402
403 \begin{apient}
404 static typeStruct *create(string &name,
405                           vector<pair<string, Type *>*> &flds,
406                           Symtab *obj = NULL)
407 \end{apient}
408 \apidesc{
409 This factory method creates a new struct type. The name of the structure is specified in the \code{name} parameter. The \code{flds} vector specifies the names and types of the fields of the structure type. 
410 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
411 }
412
413 \begin{apient}
414 static typeStruct *create(string &name,
415                           vector<Field *> &fields,
416                           Symtab *obj = NULL)
417 \end{apient}
418 \apidesc{
419 This factory method creates a new struct type. The name of the structure is specified in the \code{name} parameter. The \code{fields} vector specifies the fields of the type. 
420 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
421 }
422
423 \begin{apient}
424 bool isCompatible(Type *type)
425 \end{apient}
426 \apidesc{
427 This method returns \code{true} if the struct type is compatible with the given type \code{type} or else returns \code{false}. 
428 }
429
430 \subsubsection{Class typeUnion}
431 \mbox{ }\\
432
433 This class represents a union type, a special case of the container type. The fields of the union type represent the fields in this case. As a subclass of class \code{fieldListType}, all methods in \code{fieldListType} are applicable. \code{typeUnion} inherits from the \code{fieldListType} class.
434
435
436 \begin{apient}
437 static typeUnion *create(string &name,
438                          vector<pair<string, Type *>*> &flds,
439                          Symtab *obj = NULL)
440 \end{apient}
441 \apidesc{
442  This factory method creates a new union type. The name of the union is specified in the \code{name} parameter. The \code{flds} vector specifies the names and types of the fields of the union type. 
443 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
444 }
445
446 \begin{apient}
447 static typeUnion *create(string &name,
448                          vector<Field *> &fields, 
449                          Symtab *obj = NULL)
450 \end{apient}
451 \apidesc{
452 This factory method creates a new union type. The name of the structure is specified in the \code{name} parameter. The \code{fields} vector specifies the fields of the type.
453 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
454 }
455
456 \begin{apient}
457 bool isCompatible(Type *type)
458 \end{apient}
459 \apidesc{
460 This method returns \code{true} if the union type is compatible with the given type \code{type} or else returns \code{false}. 
461 }
462
463 \subsubsection{Class typeCommon}
464 \mbox{ }\\
465
466 This class represents a common block type in fortran, a special case of the container type. The variables of the common block represent the fields in this case. As a subclass of class \code{fieldListType}, all methods in \code{fieldListType} are applicable. \code{typeCommon} inherits from the \code{Type} class.
467
468
469 \begin{apient}
470 vector<CBlocks *> *getCBlocks()
471 \end{apient}
472 \apidesc{
473 This method returns the common block objects for the type. 
474 The methods of the \code{CBlock} can be used to access information about the members of a common block. The vector returned by this function contains one instance of \code{CBlock} for each unique definition of the common block.
475 }
476
477 \subsubsection{Class CBlock}
478 \mbox{ }\\
479
480 This class represents a common block in Fortran. Multiple functions can share a common block.
481
482 \begin{apient}
483 bool getComponents(vector<Field *> *vars)
484 \end{apient}
485 \apidesc{
486 This method returns the vector containing the individual variables of the common block. 
487 Returns \code{true} if there is at least one variable, else returns \code{false}.
488 }
489
490 \begin{apient}
491 bool getFunctions(vector<Symbol *> *funcs)
492 \end{apient}
493 \apidesc{
494 This method returns the functions that can see this common block with the set of variables described in \code{getComponents} method above.
495 Returns \code{true} if there is at least one function, else returns \code{false}.
496 }
497
498 \subsection{Class derivedType}
499 This class represents a derived type which is a reference to another type. It is one of the three categories of types as described in Section \ref{subsec:typeInterface}. The pointer, reference and the typedef types fall under this category. This class is derived from \code{Type}, so all the member functions of class \code{Type} are applicable.
500
501
502 \begin{apient}
503 Type *getConstituentType() const
504 \end{apient}
505 \apidesc{
506  This method returns the type of the base type to which this type refers to.
507 }
508
509 \subsubsection{Class typePointer}
510 \mbox{ }\\
511
512 This class represents a pointer type, a special case of the derived type. The base type in this case is the type this particular type points to. As a subclass of class \code{derivedType}, all methods in \code{derivedType} are also applicable. 
513
514
515 \begin{apient}
516 static typePointer *create(string &name,
517                            Type *ptr,
518                            Symtab *obj = NULL)
519 static typePointer *create(string &name,
520                            Type *ptr,
521                            int size,
522                            Symtab *obj = NULL)
523 \end{apient}
524 \apidesc{
525 These factory methods create a new type, named \code{name}, which points to objects of type \code{ptr}. The first form creates a pointer whose size is equal to sizeof(void*) on the target platform where the application is running. In the second form, the size of the pointer is the value passed in the \code{size} parameter. 
526 The newly created type is added to the \code{Symtab} object \code{obj}. If obj is \code{NULL} the type is not added to any object file, but it will be available for further queries.
527 }
528
529 \begin{apient}
530 bool isCompatible(Type *type)
531 \end{apient}
532 \apidesc{
533 This method returns \code{true} if the Pointer type is compatible with the given type \code{type} or else returns \code{false}. 
534 }
535
536 \begin{apient}
537 bool setPtr(Type *ptr)
538 \end{apient}
539 \apidesc{
540 This method sets the pointer type to point to the type in \code{ptr}. Returns \code{true} if it succeeds, else returns \code{false}.
541 }
542
543 \subsubsection{Class typeTypedef}
544 \mbox{ }\\
545
546 This class represents a \code{typedef} type, a special case of the derived type. The base type in this case is the \code{Type}. This particular type is typedefed to. As a subclass of class \code{derivedType}, all methods in \code{derivedType} are also applicable.
547
548
549 \begin{apient}
550 static typeTypedef *create(string &name,
551                            Type *ptr,
552                            Symtab *obj = NULL) 
553 \end{apient}
554 \apidesc{
555 This factory method creates a new type called \code{name} and having the type \code{ptr}.
556 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
557 }
558
559 \begin{apient}
560 bool isCompatible(Type *type)
561 \end{apient}
562 \apidesc{
563 This method returns \code{true} if the typedef type is compatible with the given type \code{type} or else returns \code{false}. 
564 }
565
566 \subsubsection{Class typeRef }
567 \mbox{ }\\
568
569 This class represents a reference type, a special case of the derived type. The base type in this case is the \code{Type} this particular type refers to. As a subclass of class \code{derivedType}, all methods in \code{derivedType} are also applicable here. 
570
571
572 \begin{apient}
573 static typeRef *create(string &name,
574                        Type *ptr,
575                        Symtab * obj = NULL)
576 \end{apient}
577 \apidesc{
578 This factory method creates a new type, named \code{name}, which is a reference to objects of type \code{ptr}. The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
579 }
580
581 \begin{apient}
582 bool isCompatible(Type *type)
583 \end{apient}
584 \apidesc{
585 This method returns \code{true} if the ref type is compatible with the given type \code{type} or else returns \code{false}. 
586 }
587
588 \subsection{Class rangedType}
589 This class represents a range type with a lower and an upper bound. It is one of the three categories of types as described in section \ref{subsec:typeInterface}. The sub-range and the array types fall under this category. This class is derived from \code{Type}, so all the member functions of class \code{Type} are applicable.
590
591
592 \begin{apient}
593 unsigned long getLow() const
594 \end{apient}
595 \apidesc{
596 This method returns the lower bound of the range. 
597 This can be the lower bound of the range type or the lowest index for an array type.
598 }
599
600 \begin{apient}
601 unsigned long getHigh() const
602 \end{apient}
603 \apidesc{
604 This method returns the higher bound of the range. 
605 This can be the higher bound of the range type or the highest index for an array type.
606 }
607
608 \subsubsection{Class typeSubrange}
609 \mbox{ }\\
610
611 This class represents a sub-range type. As a subclass of class \code{rangedType}, all methods in \code{rangedType} are applicable here. This type is usually used to represent a sub-range of another type. For example, a \code{typeSubrange} can represent a sub-range of the array type or a new integer type can be declared as a sub range of the integer using this type.
612
613
614 \begin{apient}
615 static typeSubrange *create(string &name,
616                             int size,
617                             int low,
618                             int hi, 
619                             symtab *obj = NULL) 
620 \end{apient}
621 \apidesc{
622 This factory method creates a new sub-range type. The name of the type is \code{name}, and the size is \code{size}. The lower bound of the type is represented by \code{low}, and the upper bound is represented by \code{high}. 
623 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
624 }
625
626 \begin{apient}
627 bool isCompatible(Type *type)
628 \end{apient}
629 \apidesc{
630 This method returns \code{true} if this sub range type is compatible with the given type \code{type} or else returns \code{false}. 
631 }
632
633 \subsubsection{Class typeArray}
634 \mbox{ }\\
635
636 This class represents an \code{Array} type. As a subclass of class \code{rangedType}, all methods in \code{rangedType} are applicable. 
637
638 \begin{apient}
639 static typeArray *create(string &name,
640                          Type *type,
641                          int low,
642                          int hi,
643                          Symtab *obj = NULL) 
644 \end{apient}
645 \apidesc{
646 This factory method creates a new array type. The name of the type is \code{name}, and the type of each element is \code{type}. The index of the first element of the array is \code{low}, and the last is \code{high}. 
647 The newly created type is added to the \code{Symtab} object \code{obj}. If \code{obj} is \code{NULL} the type is not added to any object file, but it will be available for further queries.
648 }
649
650 \begin{apient}
651 bool isCompatible(Type *type)
652 \end{apient}
653 \apidesc{
654 This method returns \code{true} if the array type is compatible with the given type \code{type} or else returns \code{false}. 
655 }
656
657 \begin{apient}
658 Type *getBaseType() const
659 \end{apient}
660 \apidesc{
661 This method returns the base type of this array type.
662 }