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
|
/* This may look like C, but it's really -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ACE
//
// = DESCRIPTION
// Template to encapsulate getting a value from an environment variable
// and using a supplied default value if not in the environment.
//
// = AUTHOR
// Chris Cleeland (derived from work by Carlos O'Ryan)
//
// ============================================================================
#if !defined (ACE_ENV_VALUE_T_H)
#define ACE_ENV_VALUE_T_H
#include "ace/OS.h" // Need to get ACE_static_cast definition
#if !defined (ACE_LACKS_PRAGMA_ONCE)
#pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
template <class T>
class ACE_Env_Value
{
// = TITLE
// Enviroment Variable Value
//
// = DESCRIPTION
// Reads a variable from the user enviroment, providing a default
// value.
//
// = AUTHOR
// Chris Cleeland, Carlos O'Ryan
public:
ACE_Env_Value (void);
// Default constructor which isn't bound to a specific environment
// variable name or a default value. Before being useful it must
// <open()>ed.
ACE_Env_Value (const char *varname,
const T &vardefault);
// Constructor that calls <open>.
~ACE_Env_Value (void);
// Destroy the value.
operator T (void);
// Returns the value as type T.
void open (const char *varname, const T &defval);
// The constructor, read <varname> from the enviroment, using
// <vardefault> as its value if it is not defined.
const char *varname (void) const;
// Returns the name of the variable being tracked.
private:
ACE_UNIMPLEMENTED_FUNC(ACE_Env_Value(const ACE_Env_Value<T> &))
ACE_UNIMPLEMENTED_FUNC(ACE_Env_Value<T> operator=(const ACE_Env_Value<T> &))
// Disallow copying and assignment.
void fetch_value (void);
const char *varname_;
T value_;
};
template <class T> void ACE_Convert (const char *s, T &t);
// Function to convert a string <s> into type <T>.
#if defined (__ACE_INLINE__)
#include "ace/Env_Value_T.i"
#endif /* __ACE_INLINE__ */
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "ace/Env_Value_T.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
// Default calls a CTOR on type T of the form 'T::T(const char*)', but
// users can feel free to create their own specialized conversion
// functions if necessary, as shown below. Note that for 'char*' the
// default is used because a simple cast will be performed and no
// conversion will be necessary.
template <class T> inline void
ACE_Convert (const char *s, T &t)
{
t = T (s);
}
inline void
ACE_Convert (const char *s, char *&v)
{
v = (char *) s;
}
inline void
ACE_Convert (const char *s, short &si)
{
si = ACE_static_cast (short, ACE_OS::strtol (s, 0, 10));
}
inline void
ACE_Convert (const char *s, unsigned short &us)
{
us = ACE_static_cast (unsigned short, ACE_OS::strtol (s, 0, 10));
}
inline void
ACE_Convert (const char *s, long &l)
{
l = ACE_OS::strtol (s, 0, 10);
}
inline void
ACE_Convert (const char *s, int &i)
{
i = ACE_static_cast (int, ACE_OS::strtol (s, 0, 10));
}
inline void
ACE_Convert (const char *s, u_long &ul)
{
ul = ACE_OS::strtoul (s, 0, 10);
}
inline void
ACE_Convert (const char *s, double &d)
{
d = ACE_OS::strtod (s, 0);
}
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Env_Value_T.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#endif /* ACE_ENV_VALUE_T_H */
|
