source: trunk/src/core/RpLibraryFInterface.cc @ 2529

Last change on this file since 2529 was 2529, checked in by dkearney, 9 years ago

updating the fortran showdata example and the c++ getFile and fortran's
rp_lib_get_file functions to correctly return the number of bytes written to
the file.

File size: 27.7 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Library Source
4 *
5 * ======================================================================
6 *  AUTHOR:  Derrick Kearney, Purdue University
7 *  Copyright (c) 2004-2007  Purdue Research Foundation
8 *
9 *  See the file "license.terms" for information on usage and
10 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
11 * ======================================================================
12 */
13
14#include "RpLibraryFInterface.h"
15#include "RpBindingsDict.h"
16#include "RpLibraryFStubs.c"
17#include "RpDXWriter.h"
18
19/**********************************************************************/
20// FUNCTION: rp_lib(const char* filePath, int filePath_len)
21/// Open the file at 'filePath' and return Rappture Library Object.
22/**
23 */
24
25int rp_lib(const char* filePath, int filePath_len) {
26
27    RpLibrary* lib = NULL;
28    int handle = -1;
29    std::string inFilePath = "";
30
31    inFilePath = null_terminate_str(filePath, filePath_len);
32
33    // create a RapptureIO object and store in dictionary
34    lib = new RpLibrary(inFilePath);
35
36    if (lib) {
37        handle = storeObject_Void((void*)lib);
38    }
39
40    return handle;
41}
42
43/**********************************************************************/
44// FUNCTION: rp_lib_element_obj()
45/// Return the node located at 'path'.
46/**
47 */
48int rp_lib_element_obj(int* handle,     /* integer handle of library */
49                          char* path,     /* null terminated path */
50                          int path_len
51                        )
52{
53    int newObjHandle = -1;
54
55    std::string inPath = "";
56
57    RpLibrary* lib = NULL;
58    RpLibrary* retObj = NULL;
59
60    inPath = null_terminate_str(path,path_len);
61
62    if ((handle) && (*handle != 0)) {
63        lib = (RpLibrary*) getObject_Void(*handle);
64        if (lib) {
65            retObj = lib->element(inPath);
66
67            if (retObj) {
68                newObjHandle = storeObject_Void((void*)retObj);
69            }
70        }
71    }
72
73    return newObjHandle;
74}
75
76/**********************************************************************/
77// FUNCTION: rp_lib_element_comp()
78/// Return the component name of the node located at 'path'.
79/**
80 */
81void rp_lib_element_comp( int* handle, /* integer handle of library */
82                            char* path,      /* null terminated path */
83                            char* retText,   /* return buffer for fortran*/
84                            int path_len,
85                            int retText_len /* length of return text buffer */
86                          )
87{
88    std::string inPath = "";
89    RpLibrary* lib = NULL;
90    std::string retStr = "";
91
92    inPath = null_terminate_str(path,path_len);
93
94    lib = (RpLibrary*) getObject_Void(*handle);
95
96    if (lib) {
97        retStr = lib->element(inPath)->nodeComp();
98        if (!retStr.empty()) {
99            fortranify(retStr.c_str(),retText,retText_len);
100        }
101    }
102
103}
104
105/**********************************************************************/
106// FUNCTION: rp_lib_element_id()
107/// Return the 'id' of node located at 'path'.
108/**
109 */
110void rp_lib_element_id(   int* handle,       /* integer handle of library    */
111                            char* path,      /* path of element within xml   */
112                            char* retText,   /* return buffer for fortran    */
113                            int path_len,
114                            int retText_len  /* length of return text buffer */
115                        )
116{
117    std::string inPath = "";
118    RpLibrary* lib = NULL;
119    std::string retStr = "";
120
121    inPath = null_terminate_str(path,path_len);
122
123    lib = (RpLibrary*) getObject_Void(*handle);
124
125    if (lib) {
126        retStr = lib->element(inPath)->nodeId();
127        if (!retStr.empty()) {
128            fortranify(retStr.c_str(),retText,retText_len);
129        }
130    }
131}
132
133/**********************************************************************/
134// FUNCTION: rp_lib_element_type()
135/// Return the type of the node located at 'path'.
136/**
137 */
138void rp_lib_element_type( int* handle,       /* integer handle of library */
139                            char* path,      /* search path inside xml */
140                            char* retText,   /* return buffer for fortran*/
141                            int path_len,
142                            int retText_len  /* length of return text buffer */
143                          )
144{
145    std::string inPath = "";
146    RpLibrary* lib = NULL;
147    std::string retStr = "";
148
149    inPath = null_terminate_str(path,path_len);
150
151    lib = (RpLibrary*) getObject_Void(*handle);
152
153    if (lib) {
154        retStr = lib->element(inPath)->nodeType();
155        fortranify(retStr.c_str(),retText,retText_len);
156    }
157}
158
159/**********************************************************************/
160// FUNCTION: rp_lib_children(const char* filePath, int filePath_len)
161/// Retrieve the next child of 'path' from the Rappture Library Object.
162/**
163 */
164int rp_lib_children (   int* handle, /* integer handle of library */
165                        char* path, /* search path of the xml */
166                        int* childHandle, /*integer hanlde of last returned child*/
167                        int path_len  /* length of the search path buffer */
168                    ) {
169
170    std::string inPath = "";
171    RpLibrary* lib = NULL;
172    RpLibrary* childNode = NULL;
173    int newObjHandle = -1;
174
175    inPath = null_terminate_str(path,path_len);
176
177    if (handle && (*handle >= 0) ) {
178        lib = (RpLibrary*) getObject_Void(*handle);
179        if (lib) {
180
181            if (*childHandle > 0) {
182                // check to see if there were any previously returned children
183                childNode = (RpLibrary*) getObject_Void(*childHandle);
184            }
185
186            // call the children base method
187            childNode = lib->children(inPath,childNode);
188
189            // store the childNode in the dictionary.
190            //
191            // because the base method is using static memory to get store the
192            // children we should be able to check and see if the childHandle
193            // was valid.
194            // if so, then we can just return the childHandle back to the user
195            // if not, store the object in the dictionary and return the new
196            // handle.
197
198            if (childNode) {
199                if (*childHandle < 1) {
200                    newObjHandle = storeObject_Void((void*)childNode);
201                }
202                else {
203                    newObjHandle = storeObject_Void((void*)childNode,*childHandle);
204                }
205            }
206        }
207    }
208
209    return newObjHandle;
210
211}
212
213
214//int rp_lib_child_comp (   int* handle,    /* integer handle of library */
215//                            char* path,     /* DOM path of requested object */
216//                            char* type,     /* specific name of element */
217//                            int* childNum,  /* child number for iteration */
218//                            char* retText,  /* buffer to store return text */
219//                            int path_len,   /* length of path */
220//                            int type_len,   /* length of type */
221//                            int retText_len /* length of return text buffer */
222//                       )
223/*
224{
225    int retVal = 0;
226
227    char* inPath = NULL;
228    char* inType = NULL;
229
230    inPath = null_terminate(path,path_len);
231    inType = null_terminate(type,type_len);
232
233    if (inPath) {
234        path_len = strlen(inPath) + 1;
235    }
236    else {
237        path_len = 0;
238    }
239
240    if (inType) {
241        type_len = strlen(inType) + 1;
242    }
243    else {
244        type_len = 0;
245    }
246
247    retVal = rp_lib_child_str( handle,
248                                 inPath,
249                                 "component",
250                                 inType,
251                                 childNum,
252                                 retText,
253                                 path_len,
254                                 10,
255                                 type_len,
256                                 retText_len
257                               );
258
259    if (inPath) {
260        free(inPath);
261        inPath = NULL;
262    }
263
264    if (inType) {
265        free(inType);
266        inType = NULL;
267    }
268
269    return retVal;
270}
271*/
272
273//int rp_lib_child_id(   int* handle,    /* integer handle of library */
274//                          char* path,     /* DOM path of requested object */
275//                          char* type,     /* specific name of element */
276//                          int* childNum,  /* child number for iteration */
277//                          char* retText,  /* buffer to store return text */
278//                          int path_len,   /* length of path */
279//                          int type_len,   /* length of type */
280//                          int retText_len /* length of return text buffer */
281//                       )
282/*
283{
284    int retVal = 0;
285    char* inPath = NULL;
286    char* inType = NULL;
287
288    inPath = null_terminate(path,path_len);
289    inType = null_terminate(type,type_len);
290
291    if (inPath) {
292        path_len = strlen(inPath) + 1;
293    }
294    else {
295        path_len = 0;
296    }
297
298    if (inType) {
299        type_len = strlen(inType) + 1;
300    }
301    else {
302        type_len = 0;
303    }
304
305    retVal = rp_lib_child_str( handle,
306                                 inPath,
307                                 "id",
308                                 inType,
309                                 childNum,
310                                 retText,
311                                 path_len,
312                                 3,
313                                 type_len,
314                                 retText_len
315                               );
316
317    if (inPath) {
318        free(inPath);
319        inPath = NULL;
320    }
321
322    if (inType) {
323        free(inType);
324        inType = NULL;
325    }
326
327    return retVal;
328}
329*/
330
331//int rp_lib_child_type (   int* handle,    /* integer handle of library */
332//                            char* path,     /* DOM path of requested object */
333//                            char* type,     /* specific name of element */
334//                            int* childNum,  /* child number for iteration */
335//                            char* retText,  /* buffer to store return text */
336//                            int path_len,   /* length of path */
337//                            int type_len,   /* length of type */
338//                            int retText_len /* length of return text buffer */
339//                       )
340/*
341{
342    int retVal = 0;
343    char* inPath = NULL;
344    char* inType = NULL;
345
346    inPath = null_terminate(path,path_len);
347    inType = null_terminate(type,type_len);
348
349    if (inPath) {
350        path_len = strlen(inPath) + 1;
351    }
352    else {
353        path_len = 0;
354    }
355
356    if (inType) {
357        type_len = strlen(inType) + 1;
358    }
359    else {
360        type_len = 0;
361    }
362
363    retVal = rp_lib_child_str( handle,
364                                 inPath,
365                                 "type",
366                                 inType,
367                                 childNum,
368                                 retText,
369                                 path_len,
370                                 5,
371                                 type_len,
372                                 retText_len
373                               );
374
375    if (inPath) {
376        free(inPath);
377        inPath = NULL;
378    }
379
380    if (inType) {
381        free(inType);
382        inType = NULL;
383    }
384
385    return retVal;
386}
387*/
388
389/*
390int rp_lib_child_obj ( int* handle,
391                            char* path,
392                            char* type,
393                            int path_len,
394                            int type_len
395                          )
396{
397    int newObjHandle = -1;
398
399    PyObject* lib = NULL;
400    PyObject* list = NULL;
401
402    char* inPath = NULL;
403    char* inType = NULL;
404
405    inPath = null_terminate(path,path_len);
406    inType = null_terminate(type,type_len);
407
408    if (rapptureStarted) {
409        if ((handle) && (*handle != 0)) {
410            lib = (RpLibrary*) getObject_Void(*handle);
411
412            if (lib) {
413                list = rpChildren_f(lib, inPath, "object");
414                if (list) {
415                    // store the whole list,
416                    // need to make a way to read the nodes
417                    newObjHandle = storeObject_Void((void*)list);
418                    // Py_DECREF(list);
419                }
420                else {
421
422                }
423            }
424        }
425    }
426
427    if (inPath) {
428        free(inPath);
429        inPath = NULL;
430    }
431
432    if (inType) {
433        free(inType);
434        inType = NULL;
435    }
436
437    return newObjHandle;
438
439}
440*/
441
442/**********************************************************************/
443// FUNCTION: rp_lib_get()
444/// Get data located at 'path' and return it as a string value.
445/**
446 */
447void rp_lib_get( int* handle, /* integer handle of library */
448                   char* path,      /* null terminated path */
449                   char* retText,   /* return text buffer for fortran*/
450                   int path_len,
451                   int retText_len /* length of return text buffer */
452                 )
453{
454    std::string xmlText = "";
455
456    RpLibrary* lib = NULL;
457
458    std::string inPath = "";
459
460    inPath = null_terminate_str(path,path_len);
461
462    if ((handle) && (*handle != 0)) {
463        lib = (RpLibrary*) getObject_Void(*handle);
464
465        if (lib) {
466            xmlText = lib->get(inPath);
467            if (!xmlText.empty()) {
468                fortranify(xmlText.c_str(),retText,retText_len);
469            }
470
471        }
472    }
473}
474
475/**********************************************************************/
476// FUNCTION: rp_lib_get_str()
477/// Get data located at 'path' and return it as a string value.
478/**
479 */
480void rp_lib_get_str( int* handle, /* integer handle of library */
481                   char* path,      /* null terminated path */
482                   char* retText,   /* return text buffer for fortran*/
483                   int path_len,
484                   int retText_len /* length of return text buffer */
485                 )
486{
487    std::string xmlText = "";
488
489    RpLibrary* lib = NULL;
490
491    std::string inPath = "";
492
493    inPath = null_terminate_str(path,path_len);
494
495    if ((handle) && (*handle != 0)) {
496        lib = (RpLibrary*) getObject_Void(*handle);
497
498        if (lib) {
499            xmlText = lib->getString(inPath);
500            if (!xmlText.empty()) {
501                fortranify(xmlText.c_str(),retText,retText_len);
502            }
503
504        }
505    }
506}
507
508
509/**********************************************************************/
510// FUNCTION: rp_lib_get_double()
511/// Get data located at 'path' and return it as a double precision value.
512/**
513 */
514double rp_lib_get_double( int* handle,   /* integer handle of library */
515                            char* path,    /* null terminated path */
516                            int path_len
517                          )
518{
519    double retVal = 0.0;
520
521    RpLibrary* lib = NULL;
522
523    std::string inPath = "";
524
525    inPath = null_terminate_str(path,path_len);
526
527    if ((handle) && (*handle != 0)) {
528        lib = (RpLibrary*) getObject_Void(*handle);
529
530        if (lib) {
531            retVal = lib->getDouble(inPath);
532        }
533    }
534
535    return retVal;
536}
537
538
539/**********************************************************************/
540// FUNCTION: rp_lib_get_integer()
541/// Get data located at 'path' and return it as an integer value.
542/**
543 */
544int rp_lib_get_integer( int* handle,   /* integer handle of library */
545                        char* path,    /* null terminated path */
546                        int path_len
547                      )
548{
549    int retVal = 0;
550
551    RpLibrary* lib = NULL;
552
553    std::string inPath = "";
554
555    inPath = null_terminate_str(path,path_len);
556
557    if ((handle) && (*handle != 0)) {
558        lib = (RpLibrary*) getObject_Void(*handle);
559
560        if (lib) {
561            retVal = lib->getInt(inPath);
562        }
563    }
564
565    return retVal;
566}
567
568
569/**********************************************************************/
570// FUNCTION: rp_lib_get_boolean()
571/// Get data located at 'path' and return it as an integer value.
572/**
573 */
574int rp_lib_get_boolean( int* handle,   /* integer handle of library */
575                        char* path,    /* null terminated path */
576                        int path_len
577                      )
578{
579    bool value = false;
580    int retVal = 0;
581
582    RpLibrary* lib = NULL;
583
584    std::string inPath = "";
585
586    inPath = null_terminate_str(path,path_len);
587
588    if ((handle) && (*handle != 0)) {
589        lib = (RpLibrary*) getObject_Void(*handle);
590
591        if (lib) {
592            value = lib->getBool(inPath);
593            if (value == true) {
594                retVal = 1;
595            }
596            else {
597                retVal = 0;
598            }
599        }
600    }
601
602    return retVal;
603}
604
605
606/**********************************************************************/
607// FUNCTION: rp_lib_get_file()
608/// Get data located at 'path' and write it to the file 'fileName'.
609/**
610 * Returns if any bytes were written to the file
611 */
612int rp_lib_get_file (   int* handle,     /* integer handle of library */
613                        char* path,      /* null terminated path */
614                        char* fileName,  /* name of file to write data to */
615                        int path_len,    /* length of the path variable */
616                        int fileName_len /* length of the fileName variable */
617                     )
618{
619    size_t nbytes = 0;
620
621    RpLibrary* lib = NULL;
622
623    std::string inPath = "";
624    std::string filePath = "";
625
626    inPath = null_terminate_str(path,path_len);
627    filePath = null_terminate_str(fileName,fileName_len);
628
629    if ((handle) && (*handle != 0)) {
630        lib = (RpLibrary*) getObject_Void(*handle);
631
632        if (lib) {
633            nbytes = lib->getFile(inPath, filePath);
634        }
635    }
636
637    return nbytes;
638}
639
640
641
642/**********************************************************************/
643// FUNCTION: rp_lib_put_str()
644/// Put string into Rappture Library Object at location 'path'.
645/**
646 */
647void rp_lib_put_str( int* handle,
648                        char* path,
649                        char* value,
650                        int* append,
651                        int path_len,
652                        int value_len
653                      )
654{
655    std::string inPath = "";
656    std::string inValue = "";
657    RpLibrary* lib = NULL;
658
659    inPath = null_terminate_str(path,path_len);
660    inValue = null_terminate_str(value,value_len);
661
662    if ((handle) && (*handle != 0)) {
663        lib = (RpLibrary*) getObject_Void(*handle);
664
665        if (lib) {
666            lib->put(inPath,inValue,"",*append);
667        }
668    }
669
670    return;
671
672}
673
674
675/**********************************************************************/
676// FUNCTION: rp_lib_put_id_str()
677/// Put string into Rappture Library Object at location 'path' with id = 'id'
678/**
679 */
680void rp_lib_put_id_str ( int* handle,
681                        char* path,
682                        char* value,
683                        char* id,
684                        int* append,
685                        int path_len,
686                        int value_len,
687                        int id_len
688                      )
689{
690    RpLibrary* lib = NULL;
691
692    std::string inPath = "";
693    std::string inValue = "";
694    std::string inId = "";
695
696    inPath = null_terminate_str(path,path_len);
697    inValue = null_terminate_str(value,value_len);
698    inId = null_terminate_str(id,id_len);
699
700    if ((handle) && (*handle != 0)) {
701        lib = (RpLibrary*) getObject_Void(*handle);
702
703        if (lib) {
704            lib->put(inPath,inValue,inId,*append);
705        }
706    }
707
708}
709
710
711/**********************************************************************/
712// FUNCTION: rp_lib_put_data()
713/// Put string into Rappture Library Object at location 'path'.
714/**
715 */
716void rp_lib_put_data( int* handle,
717                        char* path,
718                        char* bytes,
719                        int* nbytes,
720                        int* append,
721                        int path_len,
722                        int bytes_len
723                      )
724{
725    std::string inPath = "";
726    RpLibrary* lib = NULL;
727    int bufferSize = 0;
728
729    inPath = null_terminate_str(path,path_len);
730
731    if (*nbytes < bytes_len) {
732        bufferSize = *nbytes;
733    }
734    else {
735        bufferSize = bytes_len;
736    }
737
738    if ((handle) && (*handle != 0)) {
739        lib = (RpLibrary*) getObject_Void(*handle);
740
741        if (lib) {
742            lib->putData(inPath,bytes,bufferSize,*append);
743        }
744    }
745
746    return;
747
748}
749
750
751/**********************************************************************/
752// FUNCTION: rp_lib_put_file()
753/// Put string into Rappture Library Object at location 'path'.
754/**
755 */
756void rp_lib_put_file( int* handle,
757                        char* path,
758                        char* fileName,
759                        int* compress,
760                        int* append,
761                        int path_len,
762                        int fileName_len
763                      )
764{
765    std::string inPath = "";
766    std::string inFileName = "";
767    RpLibrary* lib = NULL;
768
769    inPath = null_terminate_str(path,path_len);
770    inFileName = null_terminate_str(fileName,fileName_len);
771
772    if ((handle) && (*handle != 0)) {
773        lib = (RpLibrary*) getObject_Void(*handle);
774
775        if (lib) {
776            lib->putFile(inPath,inFileName,*compress,*append);
777        }
778    }
779
780    return;
781
782}
783
784
785void rp_lib_put_obj( int* handle,
786                        char* path,
787                        int* valHandle,
788                        int* append,
789                        int path_len
790                      )
791{
792    std::string inPath = "";
793    RpLibrary* lib = NULL;
794    // Rp_Obj does not currently exist
795    Rappture::DXWriter* obj = NULL;
796    char* objStr = NULL;
797
798
799    inPath = null_terminate_str(path,path_len);
800
801    if ((handle) && (*handle != 0)) {
802        lib = (RpLibrary*) getObject_Void(*handle);
803        if (!lib) {
804            // return error, lib was not found
805        }
806
807        obj = (Rappture::DXWriter*) getObject_Void(*valHandle);
808        if (!obj) {
809            // return error, obj was not found
810        }
811
812        // textsize function does not currently exist
813        objStr = (char*) malloc(obj->size()*sizeof(char));
814        obj->write(objStr);
815        lib->put(inPath,objStr,"",*append);
816        free(objStr);
817    }
818}
819
820
821/*
822void rp_lib_put_id_obj ( int* handle,
823                        char* path,
824                        int* valHandle,
825                        char* id,
826                        int* append,
827                        int path_len,
828                        int id_len
829                      )
830{
831    PyObject* lib = NULL;
832    PyObject* value = NULL;
833
834    char* inPath = NULL;
835    char* inId = NULL;
836
837    inPath = null_terminate(path,path_len);
838    inId = null_terminate(id,id_len);
839
840    if (rapptureStarted) {
841        if ((handle) && (*handle != 0)) {
842            lib = (RpLibrary*) getObject_Void(*handle);
843            value = (RpLibrary*) getObject_Void(*valHandle);
844
845            if (lib && value) {
846                // retObj is a borrowed object
847                // whose contents must not be modified
848                rpPutObj(lib, inPath, value, inId, *append);
849            }
850        }
851    }
852
853    if (inPath) {
854        free(inPath);
855        inPath = NULL;
856    }
857
858    if (inId) {
859        free(inId);
860        inId = NULL;
861    }
862
863}
864*/
865
866/*
867int rp_lib_remove (int* handle, char* path, int path_len)
868{
869    int newObjHandle = -1;
870
871    PyObject* lib = NULL;
872    PyObject* removedObj = NULL;
873
874    char* inPath = NULL;
875
876    inPath = null_terminate(path,path_len);
877
878    if (rapptureStarted) {
879        if ((handle) && (*handle != 0)) {
880            lib = (RpLibrary*) getObject_Void(*handle);
881
882            if (lib) {
883                removedObj = rpRemove(lib, inPath);
884
885                if (removedObj) {
886                    newObjHandle = storeObject_Void((void*)removedObj);
887                    // Py_DECREF(removedObj);
888                }
889
890            }
891        }
892    }
893
894    if (inPath) {
895        free(inPath);
896        inPath = NULL;
897    }
898
899    return newObjHandle;
900}
901*/
902
903/*
904int rp_lib_xml_len (int* handle)
905{
906    int length = -1;
907    char* xmlText = NULL;
908
909    PyObject* lib = NULL;
910
911    if (rapptureStarted) {
912        if ((handle) && (*handle != 0)) {
913            lib = (RpLibrary*) getObject_Void(*handle);
914
915            if (lib) {
916                // dont modify xmlText, borrowed pointer
917                xmlText = rpXml(lib);
918
919                if (xmlText) {
920                    length = strlen(xmlText) + 1;
921                    free(xmlText);
922                    // printf("len = :%d:\n",length);
923                }
924            }
925        }
926    }
927    return length;
928}
929*/
930
931/**********************************************************************/
932// FUNCTION: rp_lib_write_xml()
933/// Write the xml text into a file.
934/**
935 * \sa {rp_result}
936 */
937int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
938{
939    int retVal = -1;
940    RpLibrary* lib = NULL;
941    std::string inOutFile = "";
942    std::string xmlText = "";
943    std::fstream file;
944
945    inOutFile = null_terminate_str(outFile, outFile_len);
946
947    if (!inOutFile.empty() ) {
948        file.open(inOutFile.c_str(),std::ios::out);
949    }
950
951    if ( file.is_open() ) {
952        if ((handle) && (*handle != 0)) {
953            lib = (RpLibrary*) getObject_Void(*handle);
954
955            if (lib) {
956                xmlText = lib->xml();
957                if (!xmlText.empty()) {
958                    file << xmlText;
959                    retVal = 0;
960                }
961            }
962        }
963
964        file.close();
965    }
966
967    return retVal;
968}
969
970/**********************************************************************/
971// FUNCTION: rp_lib_xml()
972/// Return this node's xml text
973/**
974 */
975void  rp_lib_xml(int* handle, char* retText, int retText_len)
976{
977    std::string xmlText = "";
978
979    RpLibrary* lib = NULL;
980
981    if ((handle) && (*handle != 0)) {
982        lib = (RpLibrary*) getObject_Void(*handle);
983
984        if (lib) {
985            xmlText = lib->xml();
986            if (!xmlText.empty()) {
987                fortranify(xmlText.c_str(), retText, retText_len);
988            }
989        }
990    }
991}
992
993/**********************************************************************/
994// FUNCTION: rp_lib_node_comp()
995/// Return this node's component name
996/**
997 */
998void rp_lib_node_comp ( int* handle, char* retText, int retText_len ) {
999
1000    std::string retStr = "";
1001    RpLibrary* node = NULL;
1002
1003    if ((handle) && (*handle != 0)) {
1004        node = (RpLibrary*) getObject_Void(*handle);
1005
1006        if (node) {
1007            retStr = node->nodeComp();
1008            if (!retStr.empty()) {
1009                fortranify(retStr.c_str(), retText, retText_len);
1010            }
1011        }
1012    }
1013}
1014
1015/**********************************************************************/
1016// FUNCTION: rp_lib_node_type()
1017/// Return this node's type
1018/**
1019 */
1020void rp_lib_node_type ( int* handle, char* retText, int retText_len ) {
1021
1022    std::string retStr = "";
1023    RpLibrary* node = NULL;
1024
1025    if ((handle) && (*handle != 0)) {
1026        node = (RpLibrary*) getObject_Void(*handle);
1027
1028        if (node) {
1029            retStr = node->nodeType();
1030            if (!retStr.empty()) {
1031                fortranify(retStr.c_str(), retText, retText_len);
1032            }
1033        }
1034    }
1035}
1036
1037/**********************************************************************/
1038// FUNCTION: rp_lib_node_id()
1039/// Return this node's id.
1040/**
1041 */
1042void rp_lib_node_id ( int* handle, char* retText, int retText_len ) {
1043
1044    std::string retStr = "";
1045    RpLibrary* node = NULL;
1046
1047    if ((handle) && (*handle != 0)) {
1048        node = (RpLibrary*) getObject_Void(*handle);
1049
1050        if (node) {
1051            retStr = node->nodeId();
1052            if (!retStr.empty()) {
1053                fortranify(retStr.c_str(), retText, retText_len);
1054            }
1055        }
1056    }
1057}
1058
1059/**********************************************************************/
1060// FUNCTION: rp_result()
1061/// Write xml text to a run.xml file and signal the program has completed
1062/**
1063 */
1064void rp_result(int* handle) {
1065    RpLibrary* lib = NULL;
1066
1067    if (handle && *handle != 0) {
1068        lib = (RpLibrary*) getObject_Void(*handle);
1069        if (lib) {
1070            lib->put("tool.version.rappture.language", "fortran");
1071            lib->result();
1072        }
1073    }
1074
1075    // do no delete this, still working on testing this
1076    cleanLibDict();
1077}
1078
Note: See TracBrowser for help on using the repository browser.