Menu
▾
▴
python-ldap-dev
|
From: David L. <dav...@cs...> - 2000-07-26 00:07:56
|
Hey python-ldap developers!
i've been working on adding a display template object into
ldapmodule this morning. any suggestions on the API? my thought is something
like this collection of attributes and methods within the _ldap module:
init_templates_buf(buffer) -> LDAPDispTmplSeq
<LDAPDispTmplSeq>.name2template(string) -> LDAPDispTmpl or exception
.oc2template(sequence of strings) -> LDAPDispTmpl or exception
.__getitem__(int) -> LDAPDispTmpl
.__len__() -> int
<LDAPDispTmpl>.items -> LDAPDispTmplRowSeq
.tmplattrs([sequence of strings, int ,int]) -> list of strings
.appdata <-> object
.options -> string tuple ('addable', 'allowmodrdn', 'altview')
.name -> string
.pluralname -> string
.iconname -> string
.authattrname -> string
.defrdnattrname -> string
.defaddlocation -> string
.oclist -> tuple of tuple of string
.adddeflist -> tuple of LDAPadddeflist
<LDAPDispTmplRowSeq>.__getitem__(int) -> LDAPDispTmplColSeq
.__len__() -> int
<LDAPDispTmplColSeq>.__getitem__(int) -> LDAPDispTmplItem
.__len__() -> int
<LDAPDispTmplItem>.appdata <-> object
.attrname -> string
.label -> string
.args -> tuple of string
.options -> string tuple ('readonly', 'sortvalues', ...)
.syntaxid -> int
<LDAPadddeflist>.attrname -> string
.value -> string
.source -> 'constantvalue' or 'addersdn'
SYN_TYPE_TEXT -> int
SYN_TYPE_IMAGE -> int
SYN_TYPE... -> int
TemplateError -> base exception class
TemplateVersionError -> exception class
TemplateSyntaxError -> exception class
--
David Leonard Dav...@cs...
Dept of Comp. Sci. and Elec. Engg _ Room:78-640 Ph:+61 7 336 51187
The University of Queensland |+| http://www.csee.uq.edu.au/~leonard/
QLD 4072 AUSTRALIA ~` '~ E2A24DC6446E5779D7AFC41AA04E6401
Curses! - Mojo Jojo
|
|
From: Michael <mi...@st...> - 2000-07-26 07:48:37
|
David Leonard wrote: > > i've been working on adding a display template object into > ldapmodule this morning. Into the Python part or the C part based on the OpenLDAP libs? Ciao, Michael. |
|
From: David L. <dav...@cs...> - 2000-07-26 09:19:16
|
On Wed, 26 Jul 2000, Michael Ströder typed thusly:
> > i've been working on adding a display template object into
> > ldapmodule this morning.
> Into the Python part or the C part based on the OpenLDAP libs?
the c part
/* David Leonard <dav...@cs...>, 2000. Public domain. */
/*
* DispTmplObject - wrapper around an LDAP Display Template (disptmpl)
* $Id$
*/
#include "common.h"
#if defined(HAVE_LDAP_INIT_TEMPLATES)
#include "lber.h"
#include "ldap.h"
#include "disptmpl.h"
#include "linkedlist.h"
#include "template.h"
PyObject *DispTmpl_Error;
PyObject *DispTmpl_VersionError;
PyObject *DispTmpl_SyntaxError;
LinkedListType DispTmplSeq_Type;
LinkedListType DispTmplRowSeq_Type;
LinkedListType DispTmplColSeq_Type;
static PyObject *DispTmplSeq_new(struct ldap_disptmpl *);
static PyObject *DispTmplRowSeq_new(DispTmplObject *);
static PyObject *DispTmplColSeq_new(DispTmplRowSeqObject *,
struct ldap_tmplitem *);
static PyObject *DispTmplItem_new(DispTmplObject *, struct ldap_tmplitem *);
static PyObject *DispTmpl_new(struct ldap_disptmpl *, DispTmplSeqObject *);
static PyObject *
makestring(s)
char *s;
{
if (s != NULL)
return PyString_FromString(s);
Py_INCREF(Py_None);
return Py_None;
}
/*------------------------------------------------------------
* DispTmplSeq: a sequence of templates
*/
static PyObject *
DispTmplSeq_new(tmpllist)
struct ldap_disptmpl *tmpllist;
{
DispTmplSeqObject *seq;
struct ldap_disptmpl *t;
struct ldap_tmplitem *r, *c;
seq = (DispTmplSeqObject *)LinkedList_new(&DispTmplSeq_Type);
seq->tmpllist = tmpllist;
/* clear all the application data fields */
for (t = ldap_first_disptmpl(tmpllist);
t;
t = ldap_next_disptmpl(tmpllist, t))
{
LDAP_SET_DISPTMPL_APPDATA(t, NULL);
for (r = ldap_first_tmplrow(t);
r;
r = ldap_next_tmplrow(t, r))
for (c = ldap_first_tmplcol(t, r);
c;
c = ldap_next_tmplcol(t, r, c))
LDAP_SET_TMPLITEM_APPDATA(c, NULL);
}
return (PyObject *)seq;
}
/* Deallocate */
static void
DispTmplSeq_dealloc(self)
DispTmplSeqObject *self;
{
struct ldap_disptmpl *t;
struct ldap_tmplitem *r, *c;
/* Deallocate any application data */
for (t = ldap_first_disptmpl(self->tmpllist);
t;
t = ldap_next_disptmpl(self->tmpllist, t))
{
Py_XDECREF(LDAP_GET_DISPTMPL_APPDATA(t, PyObject *));
for (r = ldap_first_tmplrow(t);
r;
r = ldap_next_tmplrow(t, r))
for (c = ldap_first_tmplcol(t, r);
c;
c = ldap_next_tmplcol(t, r, c))
Py_XDECREF(LDAP_GET_TMPLITEM_APPDATA(c,
PyObject *));
}
ldap_free_templates(self->tmpllist);
PyMem_DEL((PyObject *)self);
}
/* first in list */
static struct ldap_disptmpl *
DispTmplSeq_first(self)
DispTmplSeqObject *self;
{
return ldap_first_disptmpl(self->tmpllist);
}
/* next in list */
static struct ldap_disptmpl *
DispTmplSeq_next(self, tmpl)
DispTmplSeqObject *self;
struct ldap_disptmpl *tmpl;
{
return ldap_next_disptmpl(self->tmpllist, tmpl);
}
/* create object from pointer into list */
static PyObject *
DispTmplSeq_item(self, tmpl)
DispTmplSeqObject *self;
struct ldap_disptmpl *tmpl;
{
return DispTmpl_new(tmpl, self);
}
/* retrieve a template by name */
static PyObject *
DispTmplSeq_name2template(self, args)
DispTmplSeqObject *self;
PyObject *args;
{
struct ldap_disptmpl *t;
char *s;
if (!PyArg_ParseTuple(args, "s", &s))
return NULL;
t = ldap_name2template(s, self->tmpllist);
if (t == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return DispTmpl_new(t, self);
}
static char DispTmplSeq_name2template_doc[] =
"name2template(name) -> template\n"
"Do stuff.";
/* retrieve a template by objectClass */
static PyObject *
DispTmplSeq_oc2template(self, args)
DispTmplSeqObject *self;
PyObject *args;
{
struct ldap_disptmpl *t;
PyObject *seq, *o;
char **strs;
int len, i;
if (!PyArg_ParseTuple(args, "O", &seq))
return NULL;
if (!PySequence_Check(seq)) {
PyErr_SetString(PyExc_TypeError, "expected list of strings");
return NULL;
}
len = PySequence_Length(seq);
strs = (char **)malloc(sizeof (char *) * (len + 1));
if (strs == NULL)
return PyErr_NoMemory();
for (i = 0; i < len; i++) {
o = PySequence_GetItem(seq, i);
if (!PyString_Check(o)) {
PyErr_SetString(PyExc_TypeError,
"expected list of strings");
free(strs);
return NULL;
}
strs[i] = PyString_AsString(o);
}
strs[len] = NULL;
t = ldap_oc2template(strs, self->tmpllist);
free(strs);
if (t == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return DispTmpl_new(t, self);
}
static char DispTmplSeq_oc2template_doc[] =
"oc2template(list of strings) -> template\n"
"Do stuff.";
static PyMethodDef DispTmplSeq_methods[] = {
{ "name2template", (PyCFunction)DispTmplSeq_name2template,
METH_VARARGS, DispTmplSeq_name2template_doc },
{ "oc2template", (PyCFunction)DispTmplSeq_oc2template,
METH_VARARGS, DispTmplSeq_oc2template_doc },
{ NULL, NULL }
};
PyObject *
DispTmplSeq_getattr(self, name)
LinkedListObject *self;
char *name;
{
return Py_FindMethod(DispTmplSeq_methods, (PyObject *)self, name);
}
/*------------------------------------------------------------
* DispTmplRowSeq: a sequence of rows
*/
/* new row sequence */
static PyObject *
DispTmplRowSeq_new(template)
DispTmplObject *template;
{
DispTmplRowSeqObject *rowseq;
rowseq = (DispTmplRowSeqObject *)LinkedList_new(
&DispTmplRowSeq_Type);
rowseq->tmplobj = template;
Py_INCREF(template);
return (PyObject *)rowseq;
}
/* deallocate */
static void
DispTmplRowSeq_dealloc(self)
DispTmplRowSeqObject *self;
{
Py_DECREF(self->tmplobj);
PyMem_DEL((PyObject *)self);
}
/* first in list */
static struct ldap_tmplitem *
DispTmplRowSeq_first(self)
DispTmplRowSeqObject *self;
{
return ldap_first_tmplrow(self->tmplobj->disptmpl);
}
/* next in list */
static struct ldap_tmplitem *
DispTmplRowSeq_next(self, row)
DispTmplRowSeqObject *self;
struct ldap_tmplitem *row;
{
return ldap_next_tmplrow(self->tmplobj->disptmpl, row);
}
/* return a row (sequence of columns) */
static PyObject *
DispTmplRowSeq_item(self, cols)
DispTmplRowSeqObject *self;
struct ldap_tmplitem *cols;
{
return DispTmplColSeq_new(self, cols);
}
/*------------------------------------------------------------
* DispTmplColSeq: a sequence of columns
*/
/* new columns */
static PyObject *
DispTmplColSeq_new(rowseq, row)
DispTmplRowSeqObject *rowseq;
struct ldap_tmplitem *row;
{
DispTmplColSeqObject *colseq;
colseq = (DispTmplColSeqObject *)LinkedList_new(
&DispTmplColSeq_Type);
colseq->tmplobj = rowseq->tmplobj;
Py_INCREF(colseq->tmplobj);
colseq->row = row;
return (PyObject *)colseq;
}
/* Deallocate */
static void
DispTmplColSeq_dealloc(self)
DispTmplColSeqObject *self;
{
Py_DECREF(self->tmplobj);
PyMem_DEL((PyObject *)self);
}
/* first in list */
static struct ldap_tmplitem *
DispTmplColSeq_first(self)
DispTmplColSeqObject *self;
{
return ldap_first_tmplcol(self->tmplobj->disptmpl,
self->row);
}
/* next in list */
static struct ldap_tmplitem *
DispTmplColSeq_next(self, col)
DispTmplColSeqObject *self;
struct ldap_tmplitem *col;
{
return ldap_next_tmplcol(self->tmplobj->disptmpl,
self->row, col);
}
/* extract item from current column */
static PyObject *
DispTmplColSeq_item(self, item)
DispTmplColSeqObject *self;
struct ldap_tmplitem *item;
{
return DispTmplItem_new(self->tmplobj, item);
}
/*------------------------------------------------------------
* template item
*/
static struct { long attr; char *name; PyObject *intern; } anam[] = {
{ LDAP_DITEM_OPT_READONLY, "readonly" },
{ LDAP_DITEM_OPT_SORTVALUES, "sortvalues" },
{ LDAP_DITEM_OPT_SINGLEVALUED, "singlevalued" },
{ LDAP_DITEM_OPT_VALUEREQUIRED, "valuerequired" },
{ LDAP_DITEM_OPT_HIDEIFEMPTY, "hideifempty" },
{ LDAP_DITEM_OPT_HIDEIFFALSE, "hideiffalse" },
};
static int nanam = sizeof anam / sizeof anam[0];
/* deallocate item */
static PyObject *
DispTmplItem_repr(self)
DispTmplItemObject *self;
{
char *label;
char buf[1024];
label = self->item->ti_label;
fprintf(stderr, "label=%p\n", label);
if (label == NULL)
return PyString_FromString("<TemplateItem>");
snprintf(buf, sizeof buf, "<TemplateItem %s>", label);
fprintf(stderr, "buf='%s'\n", buf);
return PyString_FromString(buf);
}
/* deallocate item */
static void
DispTmplItem_dealloc(self)
DispTmplItemObject *self;
{
/* Note: appdata is released later */
Py_DECREF(self->tmplobj);
PyMem_DEL((PyObject *)self);
}
/* read an attribute */
static PyObject *
DispTmplItem_getattr(self, attr)
DispTmplItemObject *self;
char *attr;
{
if (streq(attr, "__members__"))
return Py_BuildValue("[ssssss]",
"appdata", "attrname", "label",
"args", "options", "syntaxid");
if (streq(attr, "appdata")) {
PyObject *data;
data = LDAP_GET_TMPLITEM_APPDATA(self->item, PyObject *);
if (data == NULL)
data = Py_None;
Py_INCREF(data);
return data;
}
if (streq(attr, "attrname"))
return makestring(self->item->ti_attrname);
if (streq(attr, "label"))
return makestring(self->item->ti_label);
if (streq(attr, "args")) {
int i;
PyObject *tuple;
for (i = 0; self->item->ti_args[i]; i++)
;
tuple = PyTuple_New(i);
for (i = 0; self->item->ti_args[i]; i++)
PyTuple_SetItem(tuple, i, PyString_FromString(
self->item->ti_args[i]));
return tuple;
}
if (streq(attr, "options")) {
int i, len;
PyObject *tuple;
for (len = i = 0; i < nanam; i++)
if (LDAP_IS_TMPLITEM_OPTION_SET(self->item, anam[i].attr))
len++;
tuple = PyTuple_New(len);
for (len = i = 0; i < nanam; i++)
if (LDAP_IS_TMPLITEM_OPTION_SET(self->item, anam[i].attr)) {
PyTuple_SetItem(tuple, len, anam[i].intern);
Py_INCREF(anam[i].intern);
len++;
}
return tuple;
}
if (streq(attr, "syntaxid"))
return PyInt_FromLong(self->item->ti_syntaxid);
PyErr_SetString(PyExc_AttributeError, attr);
return NULL;
}
/* set an attribute */
static int
DispTmplItem_setattr(self, attr, value)
DispTmplItemObject *self;
char *attr;
PyObject *value;
{
if (streq(attr, "appdata")) {
Py_XDECREF(LDAP_GET_TMPLITEM_APPDATA(self->item, PyObject *));
LDAP_SET_TMPLITEM_APPDATA(self->item, value);
Py_INCREF(value);
return 0;
}
PyErr_SetString(PyExc_AttributeError, attr);
return -1;
}
static PyTypeObject DispTmplItem_Type = {
#ifdef WIN32
PyObject_HEAD_INIT(NULL)
#else /* ! WIN32 */
PyObject_HEAD_INIT(&PyType_Type)
#endif /* ! WIN32 */
sizeof(DispTmplItemObject),/*ob_size*/
"DispTmplItem", /*tp_name*/
0, /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)DispTmplItem_dealloc,/*tp_dealloc*/
0, /*tp_print*/
(getattrfunc)DispTmplItem_getattr, /*tp_getattr*/
(setattrfunc)DispTmplItem_setattr, /*tp_setattr*/
0, /*tp_compare*/
(reprfunc)DispTmplItem_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
};
static PyObject *
DispTmplItem_new(tmplobj, item)
DispTmplObject *tmplobj;
struct ldap_tmplitem *item;
{
DispTmplItemObject *obj;
obj = PyObject_NEW(DispTmplItemObject, &DispTmplItem_Type);
obj->tmplobj = tmplobj;
Py_INCREF(tmplobj);
obj->item = item;
return (PyObject *)obj;
}
/*------------------------------------------------------------
* Template
*/
/* deallocate item */
static void
DispTmpl_dealloc(self)
DispTmplObject *self;
{
/* Note: appdata is released later */
Py_DECREF(self->tmplseqobj);
PyMem_DEL((PyObject *)self);
}
static PyObject *
DispTmpl_tmplattrs(self, args)
PyObject *self, *args;
{
PyErr_SetNone(PyExc_NotImplementedError);
return NULL;
}
static char DispTmpl_tmplattrs_doc[] =
"tmplattrs() -> \n"
"Do stuff.";
static PyMethodDef DispTmpl_methods[] = {
{ "tmplattrs", (PyCFunction)DispTmpl_tmplattrs,
METH_VARARGS, DispTmpl_tmplattrs_doc },
{ NULL, NULL }
};
static struct { long attr; char *name; PyObject *intern; } tnam[] = {
{ LDAP_DTMPL_OPT_ADDABLE, "addable" },
{ LDAP_DTMPL_OPT_ALLOWMODRDN, "allowmodrdn" },
{ LDAP_DTMPL_OPT_ALTVIEW, "altview" },
};
static int ntnam = sizeof tnam / sizeof tnam[0];
/* get an attribute */
static PyObject *
DispTmpl_getattr(self, attr)
DispTmplObject *self;
char *attr;
{
if (streq(attr, "__members__"))
return Py_BuildValue("[sssssssssss]",
"items", "appdata", "options",
"name", "pluralname", "iconname",
"authattrname", "defrdnattrname", "defaddlocation",
"oclist", "adddeflist");
if (streq(attr, "items"))
return DispTmplRowSeq_new(self);
if (streq(attr, "appdata")) {
PyObject *data;
data = LDAP_GET_DISPTMPL_APPDATA(self->disptmpl, PyObject *);
if (data == NULL)
data = Py_None;
Py_INCREF(data);
return data;
}
if (streq(attr, "options")) {
int i, len;
PyObject *tuple;
for (len = i = 0; i < ntnam; i++)
if (LDAP_IS_DISPTMPL_OPTION_SET(self->disptmpl,
tnam[i].attr))
len++;
tuple = PyTuple_New(len);
for (len = i = 0; i < ntnam; i++)
if (LDAP_IS_DISPTMPL_OPTION_SET(self->disptmpl,
tnam[i].attr)) {
PyTuple_SetItem(tuple, len, tnam[i].intern);
Py_INCREF(tnam[i].intern);
len++;
}
return tuple;
}
if (streq(attr, "name"))
return makestring(self->disptmpl->dt_name);
if (streq(attr, "pluralname"))
return makestring(self->disptmpl->dt_pluralname);
if (streq(attr, "iconname"))
return makestring(self->disptmpl->dt_iconname);
if (streq(attr, "authattrname"))
return makestring(self->disptmpl->dt_authattrname);
if (streq(attr, "defrdnattrname"))
return makestring(self->disptmpl->dt_defrdnattrname);
if (streq(attr, "defaddlocation"))
return makestring(self->disptmpl->dt_defaddlocation);
if (streq(attr, "oclist")) {
struct ldap_oclist *ocl = self->disptmpl->dt_oclist;
struct ldap_oclist *o;
int i;
PyObject *tuple;
for (i = 0, o = ocl; o; i++, o = o->oc_next)
i++;
tuple = PyTuple_New(i);
for (i = 0, o = ocl; o; i++, o = o->oc_next) {
PyObject *names;
int j;
for (j = 0; o->oc_objclasses[j]; j++)
;
names = PyTuple_New(j);
for (j = 0; o->oc_objclasses[j]; j++)
PyTuple_SetItem(names, j,
PyString_FromString(o->oc_objclasses[j]));
PyTuple_SetItem(tuple, i, names);
}
return tuple;
}
if (streq(attr, "adddeflist")) {
}
return Py_FindMethod(DispTmpl_methods, (PyObject *)self, attr);
}
/* set an attribute */
static int
DispTmpl_setattr(self, attr, value)
DispTmplObject *self;
char *attr;
PyObject *value;
{
if (streq(attr, "appdata")) {
Py_XDECREF(LDAP_GET_DISPTMPL_APPDATA(self->disptmpl,
PyObject *));
LDAP_SET_DISPTMPL_APPDATA(self->disptmpl, value);
Py_INCREF(value);
return 0;
}
PyErr_SetString(PyExc_AttributeError, attr);
return -1;
}
static PyTypeObject DispTmpl_Type = {
#ifdef WIN32
PyObject_HEAD_INIT(NULL)
#else /* ! WIN32 */
PyObject_HEAD_INIT(&PyType_Type)
#endif /* ! WIN32 */
sizeof(DispTmplObject), /*ob_size*/
"DispTmpl", /*tp_name*/
0, /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)DispTmpl_dealloc,/*tp_dealloc*/
0, /*tp_print*/
(getattrfunc)DispTmpl_getattr, /*tp_getattr*/
(setattrfunc)DispTmpl_setattr, /*tp_setattr*/
0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
};
static PyObject *
DispTmpl_new(disptmpl, tmplseq)
struct ldap_disptmpl *disptmpl;
DispTmplSeqObject *tmplseq;
{
DispTmplObject *obj;
obj = PyObject_NEW(DispTmplObject, &DispTmpl_Type);
obj->tmplseqobj = tmplseq;
Py_INCREF(tmplseq);
obj->disptmpl = disptmpl;
return (PyObject *)obj;
}
/*------------------------------------------------------------
* module-level methods
*/
/* create a sequence of templates */
PyObject *
l_init_templates(self, args)
PyObject *self, *args;
{
struct ldap_disptmpl *tmpllist;
PyObject *bufobj;
const void *buf;
int buflen;
int err;
if (!PyArg_ParseTuple(args, "O", &bufobj))
return NULL;
if (PyObject_AsReadBuffer(bufobj, &buf, &buflen) == -1)
return NULL;
err = ldap_init_templates_buf((char *)buf, buflen, &tmpllist);
switch (err) {
case LDAP_TMPL_ERR_MEM:
return PyErr_NoMemory();
case 0:
return DispTmplSeq_new(tmpllist);
case LDAP_TMPL_ERR_SYNTAX:
PyErr_SetNone(DispTmpl_VersionError);
return NULL;
case LDAP_TMPL_ERR_VERSION:
PyErr_SetNone(DispTmpl_VersionError);
return NULL;
default:
PyErr_SetString(PyExc_SystemError,
"unexpected return value from ldap_init_templates_buf");
return NULL;
}
}
char l_init_templates_doc[] =
"init_templates_buf(buffer) -> templates\n"
"Do stuff.";
void
LDAPinit_template(dict)
PyObject *dict;
{
int i;
LinkedList_inittype(&DispTmplSeq_Type, "DispTmplSeq",
sizeof (DispTmplSeqObject),
(firstfunc)DispTmplSeq_first,
(nextfunc)DispTmplSeq_next,
(itemfunc)DispTmplSeq_item);
DispTmplSeq_Type.llt_type.tp_dealloc = DispTmplSeq_dealloc;
DispTmplSeq_Type.llt_type.tp_getattr = DispTmplSeq_getattr;
LinkedList_inittype(&DispTmplRowSeq_Type, "DispTmplRowSeq",
sizeof (DispTmplRowSeqObject),
(firstfunc)DispTmplRowSeq_first,
(nextfunc)DispTmplRowSeq_next,
(itemfunc)DispTmplRowSeq_item);
DispTmplRowSeq_Type.llt_type.tp_dealloc = DispTmplRowSeq_dealloc;
LinkedList_inittype(&DispTmplColSeq_Type, "DispTmplColSeq",
sizeof (DispTmplColSeqObject),
(firstfunc)DispTmplColSeq_first,
(nextfunc)DispTmplColSeq_next,
(itemfunc)DispTmplColSeq_item);
DispTmplColSeq_Type.llt_type.tp_dealloc = DispTmplColSeq_dealloc;
DispTmpl_Error = PyErr_NewException("ldap.TemplateError",
NULL, NULL);
PyDict_SetItemString(dict, "TemplateError", DispTmpl_Error);
DispTmpl_VersionError = PyErr_NewException(
"ldap.TemplateVersionError", DispTmpl_Error, NULL);
PyDict_SetItemString(dict, "TemplateVersionError",
DispTmpl_VersionError);
DispTmpl_SyntaxError = PyErr_NewException(
"ldap.TemplateSyntaxError", DispTmpl_Error, NULL);
PyDict_SetItemString(dict, "TemplateSyntaxError",
DispTmpl_SyntaxError);
for (i = 0; i < nanam; i++)
anam[i].intern = PyString_FromString(anam[i].name);
for (i = 0; i < ntnam; i++)
tnam[i].intern = PyString_FromString(tnam[i].name);
#define setval(n) PyDict_SetItemString(dict, #n, PyInt_FromLong(LDAP_##n))
setval(SYN_TYPE_TEXT);
setval(SYN_TYPE_IMAGE);
setval(SYN_TYPE_BOOLEAN);
setval(SYN_TYPE_BUTTON);
setval(SYN_TYPE_ACTION);
setval(SYN_OPT_DEFER);
setval(SYN_CASEIGNORESTR);
setval(SYN_MULTILINESTR);
setval(SYN_DN);
setval(SYN_BOOLEAN);
setval(SYN_JPEGIMAGE);
setval(SYN_JPEGBUTTON);
setval(SYN_FAXIMAGE);
setval(SYN_FAXBUTTON);
setval(SYN_AUDIOBUTTON);
setval(SYN_TIME);
setval(SYN_DATE);
setval(SYN_LABELEDURL);
setval(SYN_SEARCHACTION);
setval(SYN_LINKACTION);
setval(SYN_ADDDNACTION);
setval(SYN_VERIFYDNACTION);
setval(SYN_RFC822ADDR);
}
#endif /* ! HAVE_LDAP_INIT_TEMPLATES */
/*
* To Do:
* implement comparison between objects. someone is bound to
* want to compare two row/cell/template objects.
*/
--
David Leonard Dav...@cs...
Dept of Comp. Sci. and Elec. Engg _ Room:78-640 Ph:+61 7 336 51187
The University of Queensland |+| http://www.csee.uq.edu.au/~leonard/
QLD 4072 AUSTRALIA ~` '~ E2A24DC6446E5779D7AFC41AA04E6401
Curses! - Mojo Jojo
|
|
From: Michael <mi...@st...> - 2000-07-26 19:15:35
|
David Leonard wrote: > > On Wed, 26 Jul 2000, Michael Ströder typed thusly: > > > > i've been working on adding a display template object into > > > ldapmodule this morning. > > Into the Python part or the C part based on the OpenLDAP libs? > > the c part Hmm, does that make sense? I mean the Pythonish way of using string format templates for printing the entry's dictionaries is much easier and more flexible. Personally speaking, the display template of OpenLDAP are not much of use. I would prefer to have LDAP/SSL if you have some spare time for working on the C LDAP module... please, please, please...Netscape SDK, OpenLDAP 2.0... Ciao, Michael. |
|
From: David L. <dav...@cs...> - 2000-07-27 01:42:05
|
On Wed, 26 Jul 2000, Michael Ströder typed thusly: > > > > i've been working on adding a display template object into > > > > ldapmodule this morning. > Hmm, does that make sense? I mean the Pythonish way of using string > format templates for printing the entry's dictionaries is much > easier and more flexible. Personally speaking, the display template > of OpenLDAP are not much of use. well, the display templates appear to be a semi-standard way of describing templates. its not very nice, i admit, but my allow some reuse. > I would prefer to have LDAP/SSL if you have some spare time for > working on the C LDAP module... please, please, please...Netscape > SDK, OpenLDAP 2.0... ok.. hmmm d -- David Leonard Dav...@cs... Dept of Comp. Sci. and Elec. Engg _ Room:78-640 Ph:+61 7 336 51187 The University of Queensland |+| http://www.csee.uq.edu.au/~leonard/ QLD 4072 AUSTRALIA ~` '~ E2A24DC6446E5779D7AFC41AA04E6401 Curses! - Mojo Jojo |
|
From: Michael <mi...@st...> - 2000-07-27 09:22:27
|
David Leonard wrote: > > On Wed, 26 Jul 2000, Michael Ströder typed thusly: > > > Hmm, does that make sense? > > well, the display templates appear to be a semi-standard way of describing > templates. its not very nice, i admit, but my allow some reuse. I can't imagine a case where somebody seriously wants to re-use rusty C-modeled code in a Python design. Ciao, Michael. |
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X