Audacity  3.0.3
WrappedType.cpp
Go to the documentation of this file.
1 /**********************************************************************
2 
3  WrappedType.cpp
4 
5  James Crook
6  (C) Audacity Developers, 2007
7 
8  wxWidgets license. See Licensing.txt
9 
10 **********************************************************************//**********************************************************************/
27 
28 
29 #include "WrappedType.h"
30 
31 #include <wx/wxprec.h>
32 #include "Internat.h"
33 
36 {
37  return eWrappedType == eWrappedString;
38 }
39 
40 
41 
43 {
44  switch( eWrappedType )
45  {
46  case eWrappedString:
47  return *mpStr;
48  break;
49  case eWrappedInt:
50  return wxString::Format(wxT("%i"),*mpInt );
51  break;
52  case eWrappedDouble:
53  return wxString::Format(wxT("%.8g"),*mpDouble );
54  break;
55  case eWrappedBool:
56  return (* mpBool) ? wxT("true") : wxT("false" );
57  break;
58  case eWrappedEnum:
59  wxASSERT( false );
60  break;
61  default:
62  wxASSERT( false );
63  break;
64  }
65  return wxT("ERROR"); //Compiler pacifier
66 }
67 
69 {
70  switch( eWrappedType )
71  {
72  case eWrappedString:
73  {
74  long l;
75  mpStr->ToLong(&l);
76  return (int) l;
77  break;
78  }
79  case eWrappedInt:
80  return *mpInt;
81  break;
82  case eWrappedDouble:
83  return (int)*mpDouble;
84  break;
85  case eWrappedBool:
86  return (* mpBool) ? 1 : 0;
87  break;
88  case eWrappedEnum:
89  wxASSERT( false );
90  break;
91  default:
92  wxASSERT( false );
93  break;
94  }
95  return -1;//Compiler pacifier
96 }
97 
99 {
100  switch( eWrappedType )
101  {
102  case eWrappedString:
104  break;
105  case eWrappedInt:
106  return (double)*mpInt;
107  break;
108  case eWrappedDouble:
109  return * mpDouble;
110  break;
111  case eWrappedBool:
112  return (* mpBool)? 1.0 : 0.0;
113  break;
114  case eWrappedEnum:
115  wxASSERT( false );
116  break;
117  default:
118  wxASSERT( false );
119  break;
120  }
121  return -1.0f;//Compiler pacifier
122 }
123 
125 {
126  switch( eWrappedType )
127  {
128  case eWrappedString:
129  return mpStr->IsSameAs( wxT("true"), false ); // case free comparison.
130  break;
131  case eWrappedInt:
132  return *mpInt != 0;
133  break;
134  case eWrappedDouble:
135  wxASSERT( false );// DANGEROUS USE OF WrappedType. Can't rely on equality.
136  return * mpDouble != 0.0f; // this is what the code would be...
137  break;
138  case eWrappedBool:
139  return * mpBool;
140  break;
141  case eWrappedEnum:
142  wxASSERT( false );
143  break;
144  default:
145  wxASSERT( false );
146  break;
147  }
148  return false;//Compiler pacifier
149 }
150 
151 
152 void WrappedType::WriteToAsString( const wxString & InStr)
153 {
154  switch( eWrappedType )
155  {
156  case eWrappedString:
157  *mpStr = InStr;
158  break;
159  case eWrappedInt:
160  {
161  long l;
162  InStr.ToLong(&l);
163  *mpInt = (int) l;
164  break;
165  }
166  case eWrappedDouble:
168  break;
169  case eWrappedBool:
170  *mpBool = InStr.IsSameAs( wxT("true"), false ); // case free comparison.;
171  break;
172  case eWrappedEnum:
173  wxASSERT( false );
174  break;
175  default:
176  wxASSERT( false );
177  break;
178  }
179 }
180 
181 void WrappedType::WriteToAsInt( const int InInt)
182 {
183  switch( eWrappedType )
184  {
185  case eWrappedString:
186  *mpStr = wxString::Format( wxT("%i"), InInt );
187  break;
188  case eWrappedInt:
189  *mpInt = InInt;
190  break;
191  case eWrappedDouble:
192  *mpDouble = (double)InInt;
193  break;
194  case eWrappedBool:
195  * mpBool = (InInt !=0);
196  break;
197  case eWrappedEnum:
198  wxASSERT( false );
199  break;
200  default:
201  wxASSERT( false );
202  break;
203  }
204 }
205 
206 void WrappedType::WriteToAsDouble( const double InDouble)
207 {
208  switch( eWrappedType )
209  {
210  case eWrappedString:
211  *mpStr = wxString::Format( wxT("%.8g"), InDouble );
212  break;
213  case eWrappedInt:
214  *mpInt = (int)InDouble;
215  break;
216  case eWrappedDouble:
217  *mpDouble = InDouble;
218  break;
219  case eWrappedBool:
220  wxASSERT( false );
221  * mpBool = InDouble != 0.0;
222  break;
223  case eWrappedEnum:
224  wxASSERT( false );
225  break;
226  default:
227  wxASSERT( false );
228  break;
229  }
230 }
231 
232 
233 void WrappedType::WriteToAsBool( const bool InBool)
234 {
235  switch( eWrappedType )
236  {
237  case eWrappedString:
238  *mpStr = InBool ? wxT("true") : wxT("false" );
239  break;
240  case eWrappedInt:
241  *mpInt = InBool ? 1 : 0;
242  break;
243  case eWrappedDouble:
244  *mpDouble = InBool ? 1.0 : 0.0;
245  break;
246  case eWrappedBool:
247  *mpBool = InBool;
248  break;
249  case eWrappedEnum:
250  wxASSERT( false );
251  break;
252  default:
253  wxASSERT( false );
254  break;
255  }
256 }
257 
WrappedType::mpDouble
double *const mpDouble
Definition: WrappedType.h:67
WrappedType::ReadAsString
wxString ReadAsString()
Definition: WrappedType.cpp:42
eWrappedEnum
@ eWrappedEnum
Definition: WrappedType.h:24
WrappedType::IsString
bool IsString()
Definition: WrappedType.cpp:35
WrappedType::WriteToAsBool
void WriteToAsBool(const bool InBool)
Definition: WrappedType.cpp:233
WrappedType::ReadAsBool
bool ReadAsBool()
Definition: WrappedType.cpp:124
WrappedType::ReadAsDouble
double ReadAsDouble()
Definition: WrappedType.cpp:98
WrappedType::ReadAsInt
int ReadAsInt()
Definition: WrappedType.cpp:68
eWrappedInt
@ eWrappedInt
Definition: WrappedType.h:21
WrappedType.h
WrappedType::mpStr
wxString *const mpStr
Definition: WrappedType.h:65
eWrappedDouble
@ eWrappedDouble
Definition: WrappedType.h:22
eWrappedString
@ eWrappedString
Definition: WrappedType.h:20
WrappedType::WriteToAsDouble
void WriteToAsDouble(const double InDouble)
Definition: WrappedType.cpp:206
WrappedType::mpBool
bool *const mpBool
Definition: WrappedType.h:68
Internat.h
eWrappedBool
@ eWrappedBool
Definition: WrappedType.h:23
WrappedType::WriteToAsString
void WriteToAsString(const wxString &InStr)
Definition: WrappedType.cpp:152
WrappedType::mpInt
int *const mpInt
Definition: WrappedType.h:66
WrappedType::WriteToAsInt
void WriteToAsInt(const int InInt)
Definition: WrappedType.cpp:181
WrappedType::eWrappedType
const teWrappedType eWrappedType
Definition: WrappedType.h:64
Internat::CompatibleToDouble
static bool CompatibleToDouble(const wxString &stringToConvert, double *result)
Convert a string to a number.
Definition: Internat.cpp:134