/* Get the size for subclasses of vtkTuple */
int vtkWrap_GetTupleSize(ClassInfo *data, HierarchyInfo *hinfo)
{
HierarchyEntry *entry;
const char *classname = NULL;
size_t m;
int size = 0;
entry = vtkParseHierarchy_FindEntry(hinfo, data->Name);
if (entry && vtkParseHierarchy_IsTypeOfTemplated(
hinfo, entry, data->Name, "vtkTuple", &classname))
{
/* attempt to get count from template parameter */
if (classname)
{
m = strlen(classname);
if (m > 2 && classname[m - 1] == '>' &&
isdigit(classname[m-2]) && (classname[m-3] == ' ' ||
classname[m-3] == ',' || classname[m-3] == '<'))
{
size = classname[m-2] - '0';
}
free((char *)classname);
}
}
return size;
}
/* Wrap a templated class */
int vtkWrapPython_WrapTemplatedClass(
FILE *fp, ClassInfo *data, FileInfo *file_info, HierarchyInfo *hinfo)
{
char classname[1024];
const char *instantiations[1024];
int ninstantiations = 0;
int i, j, k, nargs;
ClassInfo *sdata;
ValueInfo *tdef;
HierarchyEntry *entry;
const char *name;
char *cp;
const char **args;
const char **defaults;
const char *modulename;
const char *name_with_args;
int is_vtkobject = 0;
const char **types;
/* do not directly wrap vtkTypeTemplate */
if (strcmp(data->Name, "vtkTypeTemplate") == 0)
{
return 0;
}
if (hinfo == 0)
{
return 0;
}
entry = vtkParseHierarchy_FindEntry(hinfo, data->Name);
if (entry == 0)
{
return 0;
}
modulename = entry->Module;
defaults = entry->TemplateDefaults;
/* find all instantiations from derived classes */
for (j = 0; j < hinfo->NumberOfEntries; j++)
{
entry = &hinfo->Entries[j];
classname[0] = '\0';
/* skip enum entries */
if (entry->IsEnum)
{
continue;
}
/* look for typedefs of template instantiations */
if (entry->IsTypedef)
{
tdef = entry->Typedef;
if ((tdef->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_OBJECT &&
entry->NumberOfTemplateParameters == 0)
{
if (tdef->Class && tdef->Class[0] != '\0' &&
tdef->Class[strlen(tdef->Class) - 1] == '>')
{
strcpy(classname, tdef->Class);
entry = vtkParseHierarchy_FindEntry(hinfo, classname);
}
}
if (!entry || entry->IsTypedef || entry->IsEnum)
{
continue;
}
}
nargs = entry->NumberOfTemplateParameters;
args = entry->TemplateParameters;
if (strcmp(entry->Module, modulename) == 0 &&
(entry->NumberOfSuperClasses == 1 ||
strcmp(entry->Name, data->Name) == 0))
{
types = NULL;
/* only do these classes directly */
if (strcmp(entry->Name, "vtkDenseArray") == 0 ||
strcmp(entry->Name, "vtkSparseArray") == 0)
{
types = vtkParse_GetArrayTypes();
}
else if (strcmp(entry->Name, "vtkTuple") == 0)
{
static const char *tuple_types[13] = {
"unsigned char, 2", "unsigned char, 3", "unsigned char, 4",
"int, 2", "int, 3", "int, 4",
"float, 2", "float, 3", "float, 4",
"double, 2", "double, 3", "double, 4",
NULL };
types = tuple_types;
}
/* do all other templated classes indirectly */
else if (nargs > 0)
{
continue;
}
for (i = 0; i == 0 || (types && types[i] != NULL); i++)
{
/* make the classname, with template args if present */
if (classname[0] == '\0')
{
if (nargs == 0)
{
sprintf(classname, "%s", entry->Name);
}
else
{
sprintf(classname, "%s<%s>", entry->Name, types[i]);
}
}
name_with_args = NULL;
if (strcmp(data->Name, entry->Name) == 0)
{
/* entry is the same as data */
cp = (char *)malloc(strlen(classname) + 1);
strcpy(cp, classname);
name_with_args = cp;
}
else
{
/* entry is not data, see if it is a subclass, and if so,
* what template args of 'data' it corresponds to */
vtkParseHierarchy_IsTypeOfTemplated(
hinfo, entry, classname, data->Name, &name_with_args);
}
if (name_with_args)
{
/* append to the list of instantiations if not present yet */
for (k = 0; k < ninstantiations; k++)
{
if (strcmp(name_with_args, instantiations[k]) == 0) { break; }
}
if (k == ninstantiations)
{
instantiations[ninstantiations++] = name_with_args;
}
else
{
free((char *)name_with_args);
}
}
classname[0] = '\0';
}
}
}
if (ninstantiations)
{
for (k = 0; k < ninstantiations; k++)
{
entry = vtkParseHierarchy_FindEntry(hinfo, instantiations[k]);
is_vtkobject = vtkParseHierarchy_IsTypeOfTemplated(
hinfo, entry, instantiations[k], "vtkObjectBase", NULL);
nargs = data->Template->NumberOfParameters;
vtkParse_DecomposeTemplatedType(instantiations[k],
&name, nargs, &args, defaults);
sdata = (ClassInfo *)malloc(sizeof(ClassInfo));
vtkParse_CopyClass(sdata, data);
vtkParse_InstantiateClassTemplate(sdata, file_info->Strings, nargs, args);
vtkWrapText_PythonName(instantiations[k], classname);
vtkWrapPython_WrapOneClass(
fp, modulename, classname, sdata, file_info, hinfo, is_vtkobject);
vtkParse_FreeClass(sdata);
vtkParse_FreeTemplateDecomposition(name, nargs, args);
}
/* the docstring for the templated class */
fprintf(fp,
"static const char *Py%s_Doc[] = {\n",
data->Name);
vtkWrapPython_ClassDoc(fp, file_info, data, hinfo, is_vtkobject);
fprintf(fp,
" \"\\nProvided Types:\\n\\n\",\n");
for (k = 0; k < ninstantiations; k++)
{
vtkWrapPython_PyTemplateName(instantiations[k], classname);
fprintf(fp,
" \" %s => %s\\n\",\n",
classname, instantiations[k]);
}
fprintf(fp,
" NULL\n"
"};\n"
"\n");
fprintf(fp,
"PyObject *Py%s_TemplateNew()\n"
"{\n"
" PyObject *o;\n"
"\n"
" PyObject *temp = PyVTKTemplate_New(\"%sPython.%s\",\n"
" Py%s_Doc);\n"
"\n",
data->Name, modulename, data->Name, data->Name);
for (k = 0; k < ninstantiations; k++)
{
vtkWrapText_PythonName(instantiations[k], classname);
entry = vtkParseHierarchy_FindEntry(hinfo, instantiations[k]);
if (vtkParseHierarchy_IsTypeOfTemplated(
hinfo, entry, instantiations[k], "vtkObjectBase", NULL))
{
fprintf(fp,
" o = Py%s_ClassNew();\n",
classname);
}
else
{
fprintf(fp,
" o = Py%s_TypeNew();\n",
classname);
}
fprintf(fp,
" if (o && PyVTKTemplate_AddItem(temp, o) != 0)\n"
" {\n"
" Py_DECREF(o);\n"
" }\n"
"\n");
free((char *)instantiations[k]);
}
fprintf(fp,
" return temp;\n"
"}\n"
"\n");
return 1;
}
return 0;
}
