Package ldaptor :: Module ldapfilter
[show private | hide private]
[frames | no frames]

Module ldaptor.ldapfilter

Exceptions
InvalidLDAPFilter  

Function Summary
  parseExtensible(attr, s)
  parseFilter(s)
  parseMaybeSubstring(attrType, s)

Variable Summary
And and_ = and
And any = any
And any_value = {value Suppress:("*")}
Literal approx = "~="
Word attr = attr
Literal equal = "="
And escaped = escaped
MatchFirst extensible = extensible
And extensible_attr = extensible_attr
Optional extensible_dn = [":dn"]
And extensible_noattr = extensible_noattr
Forward filter_ = filter
MatchFirst filtercomp = filtercomp
OneOrMore filterlist = {filter}...
MatchFirst filtertype = filtertype
Combine final = final
Literal greater = ">="
Word hexdigits = hexdigits
Combine initial = initial
Or item = item
Word keystring = keystring
Literal less = "<="
MatchFirst matchingrule = matchingrule
Optional matchingrule_or_none = [{Suppress:(":") matchingrule}]
Or maybeSubString = {{Combine:({{!W:(*\) | escaped}}...) ^...
Literal maybeSubString_present = "*"
Combine maybeSubString_simple = Combine:({{!W:(*\) | escaped}}....
And maybeSubString_substring = {{[initial] any} [final]}
Combine maybeSubString_value = Combine:({{!W:(*\) | escaped}}.....
And not_ = not
Combine numericoid = numericoid
MatchFirst oid = oid
And or_ = or
And present = {attr "=*"}
And simple = simple
And substring = substring
And toplevel = toplevel
Combine value = value

Variable Details

and_

Type:
And
Value:
and                                                                    

any

Type:
And
Value:
any                                                                    

any_value

Type:
And
Value:
{value Suppress:("*")}                                                 

approx

Type:
Literal
Value:
"~="                                                                   

attr

Type:
Word
Value:
attr                                                                   

equal

Type:
Literal
Value:
"="                                                                    

escaped

Type:
And
Value:
escaped                                                                

extensible

Type:
MatchFirst
Value:
extensible                                                             

extensible_attr

Type:
And
Value:
extensible_attr                                                        

extensible_dn

Type:
Optional
Value:
[":dn"]                                                                

extensible_noattr

Type:
And
Value:
extensible_noattr                                                      

filter_

Type:
Forward
Value:
filter                                                                 

filtercomp

Type:
MatchFirst
Value:
filtercomp                                                             

filterlist

Type:
OneOrMore
Value:
{filter}...                                                            

filtertype

Type:
MatchFirst
Value:
filtertype                                                             

final

Type:
Combine
Value:
final                                                                  

greater

Type:
Literal
Value:
">="                                                                   

hexdigits

Type:
Word
Value:
hexdigits                                                              

initial

Type:
Combine
Value:
initial                                                                

item

Type:
Or
Value:
item                                                                   

keystring

Type:
Word
Value:
keystring                                                              

less

Type:
Literal
Value:
"<="                                                                   

matchingrule

Type:
MatchFirst
Value:
matchingrule                                                           

matchingrule_or_none

Type:
Optional
Value:
[{Suppress:(":") matchingrule}]                                        

maybeSubString

Type:
Or
Value:
{{Combine:({{!W:(*\) | escaped}}...) ^ "*"} ^ {{[initial] any} [final\
]}}                                                                    

maybeSubString_present

Type:
Literal
Value:
"*"                                                                    

maybeSubString_simple

Type:
Combine
Value:
Combine:({{!W:(*\) | escaped}}...)                                    

maybeSubString_substring

Type:
And
Value:
{{[initial] any} [final]}                                              

maybeSubString_value

Type:
Combine
Value:
Combine:({{!W:(*\) | escaped}}...)                                    

not_

Type:
And
Value:
not                                                                    

numericoid

Type:
Combine
Value:
numericoid                                                             

oid

Type:
MatchFirst
Value:
oid                                                                    

or_

Type:
And
Value:
or                                                                     

present

Type:
And
Value:
{attr "=*"}                                                            

simple

Type:
And
Value:
simple                                                                 

substring

Type:
And
Value:
substring                                                              

toplevel

Type:
And
Value:
toplevel                                                               

value

Type:
Combine
Value:
value                                                                  

Generated by Epydoc 2.1 on Tue Aug 17 17:08:22 2004 http://epydoc.sf.net