/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/xtixml.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/xtixml.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 3 months ago) by william
File size: 18821 byte(s)
committing r3113 initial commit again...
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/xtixml.cpp
3 // Purpose: streaming runtime metadata information
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 27/07/03
7 // RCS-ID: $Id: xtixml.cpp 38939 2006-04-27 12:47:14Z ABX $
8 // Copyright: (c) 2003 Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_EXTENDED_RTTI
20
21 #include "wx/xtixml.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/object.h"
25 #include "wx/hash.h"
26 #include "wx/event.h"
27 #endif
28
29 #include "wx/xml/xml.h"
30 #include "wx/tokenzr.h"
31 #include "wx/txtstrm.h"
32
33 #include "wx/xtistrm.h"
34
35 #include "wx/beforestd.h"
36 #include <map>
37 #include <vector>
38 #include <string>
39 #include "wx/afterstd.h"
40
41 using namespace std ;
42
43 //
44 // XML Streaming
45 //
46
47 // convenience functions
48
49 void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data )
50 {
51 node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxT("value"), data ) );
52 }
53
54 wxString wxXmlGetContentFromNode( wxXmlNode *node )
55 {
56 if ( node->GetChildren() )
57 return node->GetChildren()->GetContent() ;
58 else
59 return wxEmptyString ;
60 }
61
62 struct wxXmlWriter::wxXmlWriterInternal
63 {
64 wxXmlNode *m_root ;
65 wxXmlNode *m_current ;
66 vector< wxXmlNode * > m_objectStack ;
67
68 void Push( wxXmlNode *newCurrent )
69 {
70 m_objectStack.push_back( m_current ) ;
71 m_current = newCurrent ;
72 }
73
74 void Pop()
75 {
76 m_current = m_objectStack.back() ;
77 m_objectStack.pop_back() ;
78 }
79 } ;
80
81 wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode )
82 {
83 m_data = new wxXmlWriterInternal() ;
84 m_data->m_root = rootnode ;
85 m_data->m_current = rootnode ;
86 }
87
88 wxXmlWriter::~wxXmlWriter()
89 {
90 delete m_data ;
91 }
92
93 void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name )
94 {
95 wxXmlNode *pnode;
96 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));
97 pnode->AddProperty(wxString(wxT("name")), name);
98 m_data->m_current->AddChild(pnode) ;
99 m_data->Push( pnode ) ;
100 }
101
102 void wxXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) )
103 {
104 m_data->Pop() ;
105 }
106
107 void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID , wxxVariantArray &metadata )
108 {
109 wxXmlNode *pnode;
110 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
111 pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName()));
112 pnode->AddProperty(wxT("id"), wxString::Format( wxT("%d") , objectID ) );
113
114 for ( size_t i = 0 ; i < metadata.GetCount() ; ++i )
115 {
116 pnode->AddProperty( metadata[i].GetName() , metadata[i].GetAsString() ) ;
117 }
118 m_data->m_current->AddChild(pnode) ;
119 m_data->Push( pnode ) ;
120 }
121
122 // end of writing the root object
123 void wxXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *WXUNUSED(classInfo), int WXUNUSED(objectID) )
124 {
125 m_data->Pop() ;
126 }
127
128 // writes a property in the stream format
129 void wxXmlWriter::DoWriteSimpleType( wxxVariant &value )
130 {
131 wxXmlAddContentToNode( m_data->m_current ,value.GetAsString() ) ;
132 }
133
134 void wxXmlWriter::DoBeginWriteElement()
135 {
136 wxXmlNode *pnode;
137 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("element") );
138 m_data->m_current->AddChild(pnode) ;
139 m_data->Push( pnode ) ;
140 }
141
142 void wxXmlWriter::DoEndWriteElement()
143 {
144 m_data->Pop() ;
145 }
146
147 void wxXmlWriter::DoBeginWriteProperty(const wxPropertyInfo *pi )
148 {
149 wxXmlNode *pnode;
150 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("prop") );
151 pnode->AddProperty(wxT("name"), pi->GetName() );
152 m_data->m_current->AddChild(pnode) ;
153 m_data->Push( pnode ) ;
154 }
155
156 void wxXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) )
157 {
158 m_data->Pop() ;
159 }
160
161
162
163 // insert an object reference to an already written object
164 void wxXmlWriter::DoWriteRepeatedObject( int objectID )
165 {
166 wxXmlNode *pnode;
167 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
168 pnode->AddProperty(wxString(wxT("href")), wxString::Format( wxT("%d") , objectID ) );
169 m_data->m_current->AddChild(pnode) ;
170 }
171
172 // insert a null reference
173 void wxXmlWriter::DoWriteNullObject()
174 {
175 wxXmlNode *pnode;
176 pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
177 m_data->m_current->AddChild(pnode) ;
178 }
179
180 // writes a delegate in the stream format
181 void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(pi) ,
182 const wxObject *eventSink, int sinkObjectID , const wxClassInfo* WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo )
183 {
184 if ( eventSink != NULL && handlerInfo != NULL )
185 {
186 wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName().c_str()) ) ;
187 }
188 }
189
190 // ----------------------------------------------------------------------------
191 // reading objects in
192 // ----------------------------------------------------------------------------
193
194
195
196 // ----------------------------------------------------------------------------
197 // reading xml in
198 // ----------------------------------------------------------------------------
199
200 /*
201 Reading components has not to be extended for components
202 as properties are always sought by typeinfo over all levels
203 and create params are always toplevel class only
204 */
205
206 int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
207 {
208 wxASSERT_MSG( callbacks , wxT("Does not support reading without a Depersistor") ) ;
209 wxString className;
210 wxClassInfo *classInfo;
211
212 wxxVariant *createParams ;
213 int *createParamOids ;
214 const wxClassInfo** createClassInfos ;
215 wxXmlNode *children;
216 int objectID;
217 wxString ObjectIdString ;
218
219 children = node->GetChildren();
220 if (!children)
221 {
222 // check for a null object or href
223 if (node->GetPropVal(wxT("href") , &ObjectIdString ) )
224 {
225 objectID = atoi( ObjectIdString.ToAscii() ) ;
226 if ( HasObjectClassInfo( objectID ) )
227 {
228 return objectID ;
229 }
230 else
231 {
232 wxLogError( _("Forward hrefs are not supported") ) ;
233 return wxInvalidObjectID ;
234 }
235 }
236 if ( !node->GetPropVal(wxT("id") , &ObjectIdString ) )
237 {
238 return wxNullObjectID;
239 }
240 }
241 if (!node->GetPropVal(wxT("class"), &className))
242 {
243 // No class name. Eek. FIXME: error handling
244 return wxInvalidObjectID;
245 }
246 classInfo = wxClassInfo::FindClass(className);
247 if ( classInfo == NULL )
248 {
249 wxLogError( wxString::Format(_("unknown class %s"),className ) ) ;
250 return wxInvalidObjectID ;
251 }
252
253 if ( children != NULL && children->GetType() == wxXML_TEXT_NODE )
254 {
255 wxLogError(_("objects cannot have XML Text Nodes") ) ;
256 return wxInvalidObjectID;
257 }
258 if (!node->GetPropVal(wxT("id"), &ObjectIdString))
259 {
260 wxLogError(_("Objects must have an id attribute") ) ;
261 // No object id. Eek. FIXME: error handling
262 return wxInvalidObjectID;
263 }
264 objectID = atoi( ObjectIdString.ToAscii() ) ;
265 // is this object already has been streamed in, return it here
266 if ( HasObjectClassInfo( objectID ) )
267 {
268 wxLogError ( wxString::Format(_("Doubly used id : %d"), objectID ) ) ;
269 return wxInvalidObjectID ;
270 }
271
272 // new object, start with allocation
273 // first make the object know to our internal registry
274 SetObjectClassInfo( objectID , classInfo ) ;
275
276 wxxVariantArray metadata ;
277 wxXmlProperty *xp = node->GetProperties() ;
278 while ( xp )
279 {
280 if ( xp->GetName() != wxString(wxT("class")) && xp->GetName() != wxString(wxT("id")) )
281 {
282 metadata.Add( new wxxVariant( xp->GetValue() , xp->GetName() ) ) ;
283 }
284 xp = xp->GetNext() ;
285 }
286 if ( !classInfo->NeedsDirectConstruction() )
287 callbacks->AllocateObject(objectID, classInfo, metadata);
288
289 //
290 // stream back the Create parameters first
291 createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ;
292 createParamOids = new int[classInfo->GetCreateParamCount() ] ;
293 createClassInfos = new const wxClassInfo*[classInfo->GetCreateParamCount() ] ;
294
295 #if wxUSE_UNICODE
296 typedef map<wstring, wxXmlNode *> PropertyNodes ;
297 typedef vector<wstring> PropertyNames ;
298 #else
299 typedef map<string, wxXmlNode *> PropertyNodes ;
300 typedef vector<string> PropertyNames ;
301 #endif
302 PropertyNodes propertyNodes ;
303 PropertyNames propertyNames ;
304
305 while( children )
306 {
307 wxString name ;
308 children->GetPropVal( wxT("name") , &name ) ;
309 propertyNames.push_back( name.c_str() ) ;
310 propertyNodes[name.c_str()] = children->GetChildren() ;
311 children = children->GetNext() ;
312 }
313
314 for ( int i = 0 ; i <classInfo->GetCreateParamCount() ; ++i )
315 {
316 const wxChar* paramName = classInfo->GetCreateParamName(i) ;
317 PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ;
318 const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ;
319 if ( pi == 0 )
320 {
321 wxLogError( wxString::Format(_("Unkown Property %s"),paramName) ) ;
322 }
323 // if we don't have the value of a create param set in the xml
324 // we use the default value
325 if ( propiter != propertyNodes.end() )
326 {
327 wxXmlNode* prop = propiter->second ;
328 if ( pi->GetTypeInfo()->IsObjectType() )
329 {
330 createParamOids[i] = ReadComponent( prop , callbacks ) ;
331 createClassInfos[i] = dynamic_cast<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
332 }
333 else
334 {
335 createParamOids[i] = wxInvalidObjectID ;
336 createParams[i] = ReadValue( prop , pi->GetTypeInfo() ) ;
337 if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
338 {
339 const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
340 if ( eti )
341 {
342 long realval ;
343 eti->ConvertToLong( createParams[i] , realval ) ;
344 createParams[i] = wxxVariant( realval ) ;
345 }
346 else
347 {
348 wxLogError( _("Type must have enum - long conversion") ) ;
349 }
350 }
351 createClassInfos[i] = NULL ;
352 }
353
354 for ( size_t j = 0 ; j < propertyNames.size() ; ++j )
355 {
356 if ( propertyNames[j] == paramName )
357 {
358 propertyNames[j] = wxEmptyString ;
359 break ;
360 }
361 }
362 }
363 else
364 {
365 if ( pi->GetTypeInfo()->IsObjectType() )
366 {
367 createParamOids[i] = wxNullObjectID ;
368 createClassInfos[i] = dynamic_cast<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
369 }
370 else
371 {
372 createParams[i] = pi->GetDefaultValue() ;
373 createParamOids[i] = wxInvalidObjectID ;
374 }
375 }
376 }
377
378 // got the parameters. Call the Create method
379 if ( classInfo->NeedsDirectConstruction() )
380 callbacks->ConstructObject(objectID, classInfo,
381 classInfo->GetCreateParamCount(),
382 createParams, createParamOids, createClassInfos, metadata );
383 else
384 callbacks->CreateObject(objectID, classInfo,
385 classInfo->GetCreateParamCount(),
386 createParams, createParamOids, createClassInfos, metadata );
387
388 // now stream in the rest of the properties, in the sequence their properties were written in the xml
389 for ( size_t j = 0 ; j < propertyNames.size() ; ++j )
390 {
391 if ( propertyNames[j].length() )
392 {
393 PropertyNodes::iterator propiter = propertyNodes.find( propertyNames[j] ) ;
394 if ( propiter != propertyNodes.end() )
395 {
396 wxXmlNode* prop = propiter->second ;
397 const wxPropertyInfo* pi = classInfo->FindPropertyInfo( propertyNames[j].c_str() ) ;
398 if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
399 {
400 const wxCollectionTypeInfo* collType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() ) ;
401 const wxTypeInfo * elementType = collType->GetElementType() ;
402 while( prop )
403 {
404 if ( prop->GetName() != wxT("element") )
405 {
406 wxLogError( _("A non empty collection must consist of 'element' nodes" ) ) ;
407 break ;
408 }
409 wxXmlNode* elementContent = prop->GetChildren() ;
410 if ( elementContent )
411 {
412 // we skip empty elements
413 if ( elementType->IsObjectType() )
414 {
415 int valueId = ReadComponent( elementContent , callbacks ) ;
416 if ( valueId != wxInvalidObjectID )
417 {
418 if ( pi->GetAccessor()->HasAdder() )
419 callbacks->AddToPropertyCollectionAsObject( objectID , classInfo , pi , valueId ) ;
420 // TODO for collections we must have a notation on taking over ownership or not
421 if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
422 callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
423 }
424 }
425 else
426 {
427 wxxVariant elementValue = ReadValue( elementContent , elementType ) ;
428 if ( pi->GetAccessor()->HasAdder() )
429 callbacks->AddToPropertyCollection( objectID , classInfo ,pi , elementValue ) ;
430 }
431 }
432 prop = prop->GetNext() ;
433 }
434 }
435 else if ( pi->GetTypeInfo()->IsObjectType() )
436 {
437 // and object can either be streamed out a string or as an object
438 // in case we have no node, then the object's streaming out has been vetoed
439 if ( prop )
440 {
441 if ( prop->GetName() == wxT("object") )
442 {
443 int valueId = ReadComponent( prop , callbacks ) ;
444 if ( valueId != wxInvalidObjectID )
445 {
446 callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ;
447 if ( pi->GetTypeInfo()->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
448 callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
449 }
450 }
451 else
452 {
453 wxASSERT( pi->GetTypeInfo()->HasStringConverters() ) ;
454 wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
455 callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
456 }
457 }
458 }
459 else if ( pi->GetTypeInfo()->IsDelegateType() )
460 {
461 if ( prop )
462 {
463 wxString resstring = prop->GetContent() ;
464 wxInt32 pos = resstring.Find('.') ;
465 if ( pos != wxNOT_FOUND )
466 {
467 int sinkOid = atol(resstring.Left(pos).ToAscii()) ;
468 wxString handlerName = resstring.Mid(pos+1) ;
469 wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ;
470
471 callbacks->SetConnect( objectID , classInfo , pi , sinkClassInfo ,
472 sinkClassInfo->FindHandlerInfo(handlerName) , sinkOid ) ;
473 }
474 else
475 {
476 wxLogError( _("incorrect event handler string, missing dot") ) ;
477 }
478 }
479
480 }
481 else
482 {
483 wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
484 if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
485 {
486 const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
487 if ( eti )
488 {
489 long realval ;
490 eti->ConvertToLong( nodeval , realval ) ;
491 nodeval = wxxVariant( realval ) ;
492 }
493 else
494 {
495 wxLogError( _("Type must have enum - long conversion") ) ;
496 }
497 }
498 callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
499 }
500 }
501 }
502 }
503
504 delete[] createParams ;
505 delete[] createParamOids ;
506 delete[] createClassInfos ;
507
508 return objectID;
509 }
510
511 wxxVariant wxXmlReader::ReadValue(wxXmlNode *node,
512 const wxTypeInfo *type )
513 {
514 wxString content ;
515 if ( node )
516 content = node->GetContent() ;
517 wxxVariant result ;
518 type->ConvertFromString( content , result ) ;
519 return result ;
520 }
521
522 int wxXmlReader::ReadObject( const wxString &name , wxDepersister *callbacks)
523 {
524 wxXmlNode *iter = m_parent->GetChildren() ;
525 while ( iter )
526 {
527 wxString entryName ;
528 if ( iter->GetPropVal(wxT("name"), &entryName) )
529 {
530 if ( entryName == name )
531 return ReadComponent( iter->GetChildren() , callbacks ) ;
532 }
533 iter = iter->GetNext() ;
534 }
535 return wxInvalidObjectID ;
536 }
537
538 #endif // wxUSE_EXTENDED_RTTI

  ViewVC Help
Powered by ViewVC 1.1.22