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
|
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
#import "LocalObject.h"
#include <exception>
#include <vector>
#include <map>
#include <string>
@class ICERuntimeException;
namespace IceSSL
{
class Certificate;
}
NSError* convertException(const std::exception_ptr&);
NSError* convertException(const std::exception&);
std::exception_ptr convertException(ICERuntimeException*);
inline NSString*
toNSString(const std::string& s)
{
return [[NSString alloc] initWithUTF8String:s.c_str()];
}
inline std::string
fromNSString(NSString* s)
{
return s == nil ? std::string() : [s UTF8String];
}
inline NSObject<NSCopying>*
toObjC(const std::string& s)
{
return [[NSString alloc] initWithUTF8String:s.c_str()];
}
inline void
fromObjC(id object, std::string& s)
{
s = object == [NSNull null] ? ::std::string() : [object UTF8String];
}
NSObject* toObjC(const std::shared_ptr<Ice::Endpoint>& endpoint);
void fromObjC(id object, std::shared_ptr<Ice::Endpoint>& endpoint);
NSObject* toObjC(const std::shared_ptr<IceSSL::Certificate>& cert);
template<typename T> NSMutableArray*
toNSArray(const std::vector<T>& seq)
{
NSMutableArray* array = [[NSMutableArray alloc] initWithCapacity:seq.size()];
for(typename std::vector<T>::const_iterator p = seq.begin(); p != seq.end(); ++p)
{
NSObject* obj = toObjC(*p);
[array addObject:obj];
}
return array;
}
template<typename T> std::vector<T>&
fromNSArray(NSArray* array, std::vector<T>& seq)
{
if(array != nil)
{
seq.reserve([array count]);
NSEnumerator* enumerator = [array objectEnumerator];
id obj = nil;
while((obj = [enumerator nextObject]))
{
T v;
fromObjC(obj, v);
seq.push_back(v);
}
}
return seq;
}
template<typename T> NSMutableData*
toNSData(const std::vector<T>& seq)
{
NSMutableData* array = [[NSMutableData alloc] initWithLength:seq.size() * sizeof(T)];
T* target = (T*)[array bytes];
for(typename std::vector<T>::const_iterator p = seq.begin(); p != seq.end(); ++p)
{
*target++ = *p;
}
return array;
}
template<typename K, typename V> NSMutableDictionary*
toNSDictionary(const std::map<K, V>& dict)
{
NSMutableDictionary* dictionary = [[NSMutableDictionary alloc] initWithCapacity:dict.size()];
for(typename std::map<K, V>::const_iterator p = dict.begin(); p != dict.end(); ++p)
{
NSObject<NSCopying>* key = toObjC(p->first);
NSObject* value = toObjC(p->second);
[dictionary setObject:value forKey:key];
}
return dictionary;
}
template<typename K, typename V> std::map<K, V>&
fromNSDictionary(NSDictionary* dictionary, std::map<K, V>& dict)
{
if(dictionary != nil)
{
NSEnumerator* enumerator = [dictionary keyEnumerator];
id obj = nil;
while((obj = [enumerator nextObject]))
{
K k;
fromObjC(obj, k);
V v;
fromObjC([dictionary objectForKey:obj], v);
dict.insert(std::pair<K, V>(k, v));
}
}
return dict;
}
|
