source: trunk/src/fortran/RpLibraryFInterface.cc @ 829

Last change on this file since 829 was 789, checked in by dkearney, 14 years ago

adding tool.version.rappture.language to xml files to keep track of language usage

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