summaryrefslogtreecommitdiffstats
path: root/lib/ldb/_ldb_text.py
blob: e0505e177913256c0d9cf86c58d535675cb32c61 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# Text wrapper for ldb bindings
#
# Copyright (C) 2015 Petr Viktorin <pviktori@redhat.com>
# Published under the GNU LGPLv3 or later

import ldb


def _recursive_encode(obj):
    if isinstance(obj, bytes):
        return obj
    elif isinstance(obj, str):
        return obj.encode('utf-8')
    else:
        return [_recursive_encode(o) for o in obj]


class _WrapBase(object):

    @classmethod
    def _wrap(cls, wrapped):
        self = cls.__new__(cls)
        self._wrapped = wrapped
        return self

    def __len__(self):
        return len(self._wrapped)

    def __eq__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped == other._wrapped
        else:
            return self._wrapped == other

    def __ne__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped != other._wrapped
        else:
            return self._wrapped != other

    def __lt__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped < other._wrapped
        else:
            return self._wrapped < other

    def __le__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped >= other._wrapped
        else:
            return self._wrapped >= other

    def __gt__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped > other._wrapped
        else:
            return self._wrapped > other

    def __ge__(self, other):
        if hasattr(other, '_wrapped'):
            return self._wrapped >= other._wrapped
        else:
            return self._wrapped >= other

    def __repr__(self):
        return '%s.text' % repr(self._wrapped)


class MessageElementTextWrapper(_WrapBase):

    """Text interface for a LDB message element"""

    def __iter__(self):
        for item in self._wrapped:
            yield item.decode('utf-8')

    def __getitem__(self, key):
        result = self._wrapped[key]
        if result is None:
            return None
        else:
            return result.decode('utf-8')

    @property
    def flags(self):
        return self._wrapped.flags

    @property
    def set_flags(self):
        return self._wrapped.set_flags


_wrap_element = MessageElementTextWrapper._wrap


class MessageTextWrapper(_WrapBase):

    """Text interface for a LDB message"""

    def __getitem__(self, key):
        result = self._wrapped[key]
        if result is None:
            return None
        else:
            return _wrap_element(result)

    def get(self, *args, **kwargs):
        result = self._wrapped.get(*args, **kwargs)
        if isinstance(result, ldb.MessageElement):
            return _wrap_element(result)
        elif isinstance(result, bytes):
            return result.decode('utf-8')
        else:
            return result

    def __setitem__(self, key, item):
        self._wrapped[key] = _recursive_encode(item)

    def __delitem__(self, key):
        del self._wrapped[key]

    def elements(self):
        return [_wrap_element(el) for el in self._wrapped.elements()]

    def items(self):
        return [(attr, _wrap_element(el)) for attr, el in self._wrapped.items()]

    @property
    def keys(self):
        return self._wrapped.keys

    @property
    def remove(self):
        return self._wrapped.remove

    @property
    def add(self):
        return self._wrapped.add

    @property
    def dn(self):
        return self._wrapped.dn

    @dn.setter
    def dn(self, new_value):
        self._wrapped.dn = new_value