← Back to branch summary

~ubuntu-branches/ubuntu/edgy/sope/edgy

« back to all changes in this revision

Viewing changes to sope-core/EOControl/EOQualifier.m

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Ley
  • Date: 2005-08-19 16:53:31 UTC
  • Revision ID: james.westby@ubuntu.com-20050819165331-hs683wz1osm708pw
Tags: upstream-4.4rc.2
Import upstream version 4.4rc.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
sope-core/EOControl/EOQualifier.m
 
1
/*
 
2
  Copyright (C) 2000-2005 SKYRIX Software AG
 
3
 
 
4
  This file is part of SOPE.
 
5
 
 
6
  SOPE is free software; you can redistribute it and/or modify it under
 
7
  the terms of the GNU Lesser General Public License as published by the
 
8
  Free Software Foundation; either version 2, or (at your option) any
 
9
  later version.
 
10
 
 
11
  SOPE is distributed in the hope that it will be useful, but WITHOUT ANY
 
12
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
13
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
14
  License for more details.
 
15
 
 
16
  You should have received a copy of the GNU Lesser General Public
 
17
  License along with SOPE; see the file COPYING.  If not, write to the
 
18
  Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
19
  02111-1307, USA.
 
20
*/
 
21
 
 
22
#include <stdio.h>
 
23
#include "EOQualifier.h"
 
24
#include "EOKeyValueCoding.h"
 
25
#include "common.h"
 
26
#include "EONull.h"
 
27
#import <Foundation/NSException.h>
 
28
 
 
29
@interface NSObject(QualifierDescription)
 
30
- (NSString *)qualifierDescription;
 
31
@end
 
32
 
 
33
@implementation EOQualifier
 
34
 
 
35
static NSMapTable *operatorToSelector = NULL;
 
36
static NSMapTable *selectorToOperator = NULL;
 
37
static EONull     *null = nil;
 
38
 
 
39
+ (void)initialize {
 
40
  if (null == nil) null = [EONull null];
 
41
  
 
42
  if (operatorToSelector == NULL) {
 
43
    operatorToSelector = NSCreateMapTable(NSObjectMapKeyCallBacks,
 
44
                                          NSIntMapValueCallBacks,
 
45
                                          10);
 
46
    NSMapInsert(operatorToSelector, @"=",   EOQualifierOperatorEqual);
 
47
    NSMapInsert(operatorToSelector, @"==",  EOQualifierOperatorEqual);
 
48
    NSMapInsert(operatorToSelector, @"!=",  EOQualifierOperatorNotEqual);
 
49
    NSMapInsert(operatorToSelector, @"<>",  EOQualifierOperatorNotEqual);        
 
50
    NSMapInsert(operatorToSelector, @"<",   EOQualifierOperatorLessThan);
 
51
    NSMapInsert(operatorToSelector, @">",   EOQualifierOperatorGreaterThan);
 
52
    NSMapInsert(operatorToSelector, @"<=",  EOQualifierOperatorLessThanOrEqualTo);
 
53
    NSMapInsert(operatorToSelector, @"like",EOQualifierOperatorLike);
 
54
    NSMapInsert(operatorToSelector, @"LIKE",EOQualifierOperatorLike);
 
55
    NSMapInsert(operatorToSelector, @">=",
 
56
                EOQualifierOperatorGreaterThanOrEqualTo);
 
57
    NSMapInsert(operatorToSelector, @"caseInsensitiveLike",
 
58
                EOQualifierOperatorCaseInsensitiveLike);
 
59
  }
 
60
  if (selectorToOperator == NULL) {
 
61
    selectorToOperator = NSCreateMapTable(NSObjectMapKeyCallBacks,
 
62
                                          NSObjectMapValueCallBacks,
 
63
                                          10);
 
64
    NSMapInsert(selectorToOperator,
 
65
                NSStringFromSelector(EOQualifierOperatorEqual),
 
66
                @"=");
 
67
    NSMapInsert(selectorToOperator,
 
68
                NSStringFromSelector(EOQualifierOperatorNotEqual),
 
69
                @"<>");
 
70
    NSMapInsert(selectorToOperator,
 
71
                NSStringFromSelector(EOQualifierOperatorLessThan),
 
72
                @"<");
 
73
    NSMapInsert(selectorToOperator,
 
74
                NSStringFromSelector(EOQualifierOperatorGreaterThan),
 
75
                @">");
 
76
    NSMapInsert(selectorToOperator,
 
77
                NSStringFromSelector(EOQualifierOperatorLessThanOrEqualTo),
 
78
                @"<=");
 
79
    NSMapInsert(selectorToOperator,
 
80
                NSStringFromSelector(EOQualifierOperatorLike),
 
81
                @"like");
 
82
    NSMapInsert(selectorToOperator,
 
83
                NSStringFromSelector(EOQualifierOperatorGreaterThanOrEqualTo),
 
84
                @">=");
 
85
    NSMapInsert(selectorToOperator,
 
86
                NSStringFromSelector(EOQualifierOperatorCaseInsensitiveLike),
 
87
                @"caseInsensitiveLike");
 
88
  }
 
89
}
 
90
 
 
91
+ (EOQualifier *)qualifierToMatchAnyValue:(NSDictionary *)_values {
 
92
  /* OR qualifier */
 
93
  NSEnumerator *keys;
 
94
  NSString     *key;
 
95
  NSArray      *array;
 
96
  unsigned i;
 
97
  id qualifiers[[_values count] + 1];
 
98
  
 
99
  keys = [_values keyEnumerator];
 
100
  for (i = 0; (key = [keys nextObject]); i++) {
 
101
    id value;
 
102
    
 
103
    value = [_values objectForKey:key];
 
104
    qualifiers[i] =
 
105
      [[EOKeyValueQualifier alloc]
 
106
                            initWithKey:key
 
107
                            operatorSelector:EOQualifierOperatorEqual
 
108
                            value:value];
 
109
    qualifiers[i] = [qualifiers[i] autorelease];
 
110
  }
 
111
  array = [NSArray arrayWithObjects:qualifiers count:i];
 
112
  return [[[EOOrQualifier alloc] initWithQualifierArray:array] autorelease];
 
113
}
 
114
 
 
115
+ (EOQualifier *)qualifierToMatchAllValues:(NSDictionary *)_values {
 
116
  /* AND qualifier */
 
117
  NSEnumerator *keys;
 
118
  NSString     *key;
 
119
  NSArray      *array;
 
120
  unsigned i;
 
121
  id qualifiers[[_values count] + 1];
 
122
  
 
123
  keys = [_values keyEnumerator];
 
124
  for (i = 0; (key = [keys nextObject]); i++) {
 
125
    id value;
 
126
    
 
127
    value = [_values objectForKey:key];
 
128
    qualifiers[i] =
 
129
      [[EOKeyValueQualifier alloc]
 
130
                            initWithKey:key
 
131
                            operatorSelector:EOQualifierOperatorEqual
 
132
                            value:value];
 
133
    qualifiers[i] = [qualifiers[i] autorelease];
 
134
  }
 
135
  array = [NSArray arrayWithObjects:qualifiers count:i];
 
136
  return [[[EOAndQualifier alloc] initWithQualifierArray:array] autorelease];
 
137
}
 
138
 
 
139
+ (SEL)operatorSelectorForString:(NSString *)_str {
 
140
  SEL s;
 
141
 
 
142
  if ((s = NSMapGet(operatorToSelector, _str)))
 
143
    return s;
 
144
  else
 
145
    return NSSelectorFromString(_str);
 
146
}
 
147
 
 
148
+ (NSString *)stringForOperatorSelector:(SEL)_sel {
 
149
  NSString *s, *ss;
 
150
  
 
151
  if ((s = NSStringFromSelector(_sel)) == nil)
 
152
    return nil;
 
153
  
 
154
  if ((ss = NSMapGet(selectorToOperator, s)))
 
155
    return ss;
 
156
  
 
157
  return s;
 
158
}
 
159
 
 
160
/* bindings */
 
161
 
 
162
- (EOQualifier *)qualifierWithBindings:(NSDictionary *)_bindings
 
163
  requiresAllVariables:(BOOL)_reqAll
 
164
{
 
165
  return self;
 
166
}
 
167
 
 
168
- (NSArray *)bindingKeys {
 
169
  return nil;
 
170
}
 
171
 
 
172
- (BOOL)requiresAllQualifierBindingVariables {
 
173
  return YES;
 
174
}
 
175
 
 
176
/* keys */
 
177
 
 
178
- (NSSet *)allQualifierKeys {
 
179
  /* new in WO 4.5 */
 
180
  id set;
 
181
 
 
182
  set = [NSMutableSet setWithCapacity:64];
 
183
  [self addQualifierKeysToSet:set];
 
184
  return [[set copy] autorelease];
 
185
}
 
186
 
 
187
- (void)addQualifierKeysToSet:(NSMutableSet *)_keys {
 
188
  /* new in WO 4.5 */
 
189
}
 
190
 
 
191
/* Comparing */
 
192
 
 
193
- (BOOL)isEqual:(id)_obj {
 
194
  if ([_obj isKindOfClass:[self class]])
 
195
    return [self isEqualToQualifier:(EOQualifier *)_obj];
 
196
  
 
197
  return NO;
 
198
}
 
199
 
 
200
- (BOOL)isEqualToQualifier:(EOQualifier *)_qual {
 
201
  [self doesNotRecognizeSelector:_cmd];
 
202
  return NO;
 
203
}
 
204
 
 
205
/* remapping keys */
 
206
 
 
207
- (EOQualifier *)qualifierByApplyingTransformer:(id)_t inContext:(id)_ctx {
 
208
  if ([_t respondsToSelector:@selector(transformQualifier:inContext:)])
 
209
    return [_t transformQualifier:self inContext:_ctx];
 
210
  else
 
211
    return [[self retain] autorelease];
 
212
}
 
213
- (EOQualifier *)qualifierByApplyingKeyMap:(NSDictionary *)_key {
 
214
  return [[self copy] autorelease];
 
215
}
 
216
 
 
217
/* GDL2 compatibility */
 
218
 
 
219
- (EOQualifier *)qualifierByApplyingBindings:(NSDictionary *)_bindings {
 
220
  return [self qualifierWithBindings:_bindings 
 
221
               requiresAllVariables:
 
222
                 [self requiresAllQualifierBindingVariables]];
 
223
}
 
224
 
 
225
/* BDControl additions */
 
226
 
 
227
- (unsigned int)count {
 
228
  return [[self subqualifiers] count];
 
229
}
 
230
- (NSArray *)subqualifiers {
 
231
  return nil;
 
232
}
 
233
 
 
234
/* debugging */
 
235
 
 
236
+ (BOOL)isEvaluationDebuggingEnabled {
 
237
  static int evalDebug = -1;
 
238
  if (evalDebug == -1) {
 
239
    evalDebug = [[NSUserDefaults standardUserDefaults] 
 
240
                  boolForKey:@"EOQualifierDebugEvaluation"] ? 1 : 0;
 
241
    if (evalDebug)
 
242
      NSLog(@"WARNING: qualifier evaluation debugging is enabled !");
 
243
  }
 
244
  return evalDebug ? YES : NO;
 
245
}
 
246
 
 
247
@end /* EOQualifier */
 
248
 
 
249
@implementation EOQualifier(QuickEval)
 
250
 
 
251
- (BOOL)evaluateWithObject:(id)_object inEvalContext:(id)_ctx {
 
252
  return [(id<EOQualifierEvaluation>)self evaluateWithObject:_object];
 
253
}
 
254
 
 
255
@end /* EOQualifier(QuickEval) */