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
|
// $Id$
// ****** Code generated by the The ACE ORB (TAO) IDL Compiler *******
// TAO ORB and the TAO IDL Compiler have been developed by Washington
// University Computer Science's Distributed Object Computing Group.
//
// Information on TAO is available at
// http://www.cs.wustl.edu/~schmidt/TAO.html
#include "tao/Object_KeyC.h"
#include "tao/Typecode.h"
#if !defined (__ACE_INLINE__)
#include "Object_KeyC.i"
#endif // !defined INLINE
ACE_RCSID(tao, Object_KeyC, "$Id$")
const CORBA::Long _oc_TAO__tao_seq_Octet[] =
{
TAO_ENCAP_BYTE_ORDER, // byte order
CORBA::tk_octet,
0,
};
CORBA::TypeCode _tc_TAO_tc_TAO__tao_seq_Octet (CORBA::tk_sequence, sizeof
(_oc_TAO__tao_seq_Octet), (char *)
&_oc_TAO__tao_seq_Octet, 0,
sizeof (TAO_ObjectKey));
CORBA::TypeCode_ptr TAO_tc__tao_seq_Octet = &_tc_TAO_tc_TAO__tao_seq_Octet;
const CORBA::Long _oc_TAO_ObjectKey[] =
{
TAO_ENCAP_BYTE_ORDER, // byte order
22, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x54414f2f), ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744b65), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x3000fdfd), // repository ID = IDL:TAO/ObjectKey:1.0
10, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744b65), ACE_NTOHL (0x7900fdfd), // name = ObjectKey
CORBA::tk_sequence, // typecode kind
12, // encapsulation length
TAO_ENCAP_BYTE_ORDER, // byte order
CORBA::tk_octet,
0,
};
CORBA::TypeCode _tc_TAO_tc_TAO_ObjectKey (CORBA::tk_alias, sizeof
(_oc_TAO_ObjectKey), (char *)
&_oc_TAO_ObjectKey, 0,
sizeof (TAO_ObjectKey));
CORBA::TypeCode_ptr TAO_tc_ObjectKey = &_tc_TAO_tc_TAO_ObjectKey;
void
TAO_ObjectKey::encode_sequence_to_string (char * &str,
const TAO_Unbounded_Sequence<CORBA::Octet> &seq)
{
// We must allocate a buffer which is (gag) 3 times the length
// of the sequence, which is the length required in the worst-case
// scenario of all non-printable characters.
//
// There are two strategies here...we could allocate all that space here,
// fill it up, then copy-allocate new space of just the right length.
// OR, we could just return this space. The classic time-space tradeoff,
// and for now we'll let time win out, which means that we only do the
// allocation once.
u_int len = 3 * seq.length (); /* space for zero termination not needed */;
str = CORBA::string_alloc (len);
char *cp = str;
for (u_int i = 0;
cp < (cp + len) && i < seq.length();
++i)
{
u_char byte = seq[i];
if (isprint (byte) && byte != '\\')
{
*cp++ = (char) byte;
continue;
}
*cp++ = '\\';
*cp++ = ACE::nibble2hex ((byte >> 4) & 0x0f);
*cp++ = ACE::nibble2hex (byte & 0x0f);
}
// Zero terminate
*cp = '\0';
}
void
TAO_ObjectKey::decode_string_to_sequence (TAO_Unbounded_Sequence<CORBA::Octet> &seq,
const char *str)
{
if (str == 0)
{
seq.length (0);
return;
}
u_int length = ACE_OS::strlen (str);
const char *eos = str + length;
const char *cp = str;
// Set the length of the sequence to be as long as
// we'll possibly need...we'll reset it to the actual
// length later.
seq.length (length);
u_int i = 0;
for (;
cp < eos && i < seq.length ();
i++)
{
if (*cp == '\\')
{
// This is an escaped non-printable,
// so we decode the hex values into
// the sequence's octet
seq[i] = (u_char) (ACE::hex2byte (cp[1]) << 4);
seq[i] |= (u_char) ACE::hex2byte (cp[2]);
cp += 3;
}
else
// Copy it in
seq[i] = *cp++;
}
// Set the length appropriately
seq.length (i);
}
// ****************************************************************
|
