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

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

Added putFile capability to octave, matlab, fortran, perl bindings
Adjusted the core putFile function and all put functions to accept unsigned ints
added enum flags for binary and text file for the putFile function in c/c++

File size: 26.0 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
691    inPath = null_terminate_str(path,path_len);
692
693    if ((handle) && (*handle != 0)) {
694        lib = getObject_Lib(*handle);
695
696        if (lib) {
697            lib->putData(inPath,bytes,*nbytes,*append);
698        }
699    }
700
701    return;
702
703}
704
705
706/**********************************************************************/
707// FUNCTION: rp_lib_put_file()
708/// Put string into Rappture Library Object at location 'path'.
709/**
710 */
711void rp_lib_put_file( int* handle,
712                        char* path,
713                        char* fileName,
714                        int* fileType,
715                        int* append,
716                        int path_len,
717                        int fileName_len
718                      )
719{
720    std::string inPath = "";
721    std::string inFileName = "";
722    RpLibrary* lib = NULL;
723
724    inPath = null_terminate_str(path,path_len);
725    inFileName = null_terminate_str(fileName,fileName_len);
726
727    if ((handle) && (*handle != 0)) {
728        lib = getObject_Lib(*handle);
729
730        if (lib) {
731            lib->putFile(inPath,inFileName,*fileType,*append);
732        }
733    }
734
735    return;
736
737}
738
739
740//void rp_lib_put_obj( int* handle,
741//                        char* path,
742//                        int* valHandle,
743//                        int* append,
744//                        int path_len
745//                      )
746//{
747//    std::string inPath = "";
748//    RpLibrary* lib = NULL;
749//
750//    // inPath = null_terminate(path,path_len);
751//    inPath = std::string(path,path_len);
752//
753//    /*
754//    if (inPath) {
755//        path_len = strlen(inPath) + 1;
756//    }
757//    */
758//
759//    if ((handle) && (*handle != 0)) {
760//        lib = getObject_Lib(*handle);
761//       
762//        if (lib) {
763//            // rpPut(lib, inPath, inValue, inId, *append);
764//            lib->put(inPath,inValue,"",*append);
765//        }
766//    }
767//
768//    /*
769//    rp_lib_put_id_obj(handle,inPath,valHandle,NULL,append,path_len,0);
770//
771//    if (inPath) {
772//        free(inPath);
773//        inPath = NULL;
774//    }
775//    */
776//
777//}
778
779/*
780void rp_lib_put_id_obj ( int* handle,
781                        char* path,
782                        int* valHandle,
783                        char* id,
784                        int* append,
785                        int path_len,
786                        int id_len
787                      )
788{
789    PyObject* lib = NULL;
790    PyObject* value = NULL;
791
792    char* inPath = NULL;
793    char* inId = NULL;
794
795    inPath = null_terminate(path,path_len);
796    inId = null_terminate(id,id_len);
797
798    if (rapptureStarted) {
799        if ((handle) && (*handle != 0)) {
800            lib = getObject_Lib(*handle);
801            value = getObject_Lib(*valHandle);
802
803            if (lib && value) {
804                // retObj is a borrowed object
805                // whose contents must not be modified
806                rpPutObj(lib, inPath, value, inId, *append);
807            }
808        }
809    }
810
811    if (inPath) {
812        free(inPath);
813        inPath = NULL;
814    }
815
816    if (inId) {
817        free(inId);
818        inId = NULL;
819    }
820
821}
822*/
823
824/*
825int rp_lib_remove (int* handle, char* path, int path_len)
826{
827    int newObjHandle = -1;
828
829    PyObject* lib = NULL;
830    PyObject* removedObj = NULL;
831
832    char* inPath = NULL;
833
834    inPath = null_terminate(path,path_len);
835
836    if (rapptureStarted) {
837        if ((handle) && (*handle != 0)) {
838            lib = getObject_Lib(*handle);
839
840            if (lib) {
841                removedObj = rpRemove(lib, inPath);
842
843                if (removedObj) {
844                    newObjHandle = storeObject_Lib(removedObj);
845                    // Py_DECREF(removedObj);
846                }
847
848            }
849        }
850    }
851
852    if (inPath) {
853        free(inPath);
854        inPath = NULL;
855    }
856
857    return newObjHandle;
858}
859*/
860
861/*
862int rp_lib_xml_len (int* handle)
863{
864    int length = -1;
865    char* xmlText = NULL;
866
867    PyObject* lib = NULL;
868
869    if (rapptureStarted) {
870        if ((handle) && (*handle != 0)) {
871            lib = getObject_Lib(*handle);
872
873            if (lib) {
874                // dont modify xmlText, borrowed pointer
875                xmlText = rpXml(lib);
876
877                if (xmlText) {
878                    length = strlen(xmlText) + 1;
879                    free(xmlText);
880                    // printf("len = :%d:\n",length);
881                }
882            }
883        }
884    }
885    return length;
886}
887*/
888
889/**********************************************************************/
890// FUNCTION: rp_lib_write_xml()
891/// Write the xml text into a file.
892/**
893 * \sa {rp_result}
894 */
895int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
896{
897    int retVal = -1;
898    RpLibrary* lib = NULL;
899    std::string inOutFile = "";
900    std::string xmlText = "";
901    std::fstream file;
902
903    inOutFile = null_terminate_str(outFile, outFile_len);
904
905    if (!inOutFile.empty() ) {
906        file.open(inOutFile.c_str(),std::ios::out);
907    }
908
909    if ( file.is_open() ) {
910        if ((handle) && (*handle != 0)) {
911            lib = getObject_Lib(*handle);
912
913            if (lib) {
914                xmlText = lib->xml();
915                if (!xmlText.empty()) {
916                    file << xmlText;
917                    retVal = 0;
918                }
919            }
920        }
921
922        file.close();
923    }
924
925    return retVal;
926}
927
928/**********************************************************************/
929// FUNCTION: rp_lib_xml()
930/// Return this node's xml text
931/**
932 */
933void  rp_lib_xml(int* handle, char* retText, int retText_len)
934{
935    std::string xmlText = "";
936
937    RpLibrary* lib = NULL;
938
939    if ((handle) && (*handle != 0)) {
940        lib = getObject_Lib(*handle);
941
942        if (lib) {
943            xmlText = lib->xml();
944            if (!xmlText.empty()) {
945                fortranify(xmlText.c_str(), retText, retText_len);
946            }
947        }
948    }
949}
950
951/**********************************************************************/
952// FUNCTION: rp_lib_node_comp()
953/// Return this node's component name
954/**
955 */
956void rp_lib_node_comp ( int* handle, char* retText, int retText_len ) {
957
958    std::string retStr = "";
959    RpLibrary* node = NULL;
960
961    if ((handle) && (*handle != 0)) {
962        node = getObject_Lib(*handle);
963
964        if (node) {
965            retStr = node->nodeComp();
966            if (!retStr.empty()) {
967                fortranify(retStr.c_str(), retText, retText_len);
968            }
969        }
970    }
971}
972
973/**********************************************************************/
974// FUNCTION: rp_lib_node_type()
975/// Return this node's type
976/**
977 */
978void rp_lib_node_type ( int* handle, char* retText, int retText_len ) {
979
980    std::string retStr = "";
981    RpLibrary* node = NULL;
982
983    if ((handle) && (*handle != 0)) {
984        node = getObject_Lib(*handle);
985
986        if (node) {
987            retStr = node->nodeType();
988            if (!retStr.empty()) {
989                fortranify(retStr.c_str(), retText, retText_len);
990            }
991        }
992    }
993}
994
995/**********************************************************************/
996// FUNCTION: rp_lib_node_id()
997/// Return this node's id.
998/**
999 */
1000void rp_lib_node_id ( int* handle, char* retText, int retText_len ) {
1001
1002    std::string retStr = "";
1003    RpLibrary* node = NULL;
1004
1005    if ((handle) && (*handle != 0)) {
1006        node = getObject_Lib(*handle);
1007
1008        if (node) {
1009            retStr = node->nodeId();
1010            if (!retStr.empty()) {
1011                fortranify(retStr.c_str(), retText, retText_len);
1012            }
1013        }
1014    }
1015}
1016
1017/**********************************************************************/
1018// FUNCTION: rp_result()
1019/// Write xml text to a run.xml file and signal the program has completed
1020/**
1021 */
1022void rp_result(int* handle) {
1023    RpLibrary* lib = NULL;
1024
1025    if (handle && *handle != 0) {
1026        lib = getObject_Lib(*handle);
1027        if (lib) {
1028            lib->result();
1029        }
1030    }
1031
1032    // do no delete this, still working on testing this
1033    cleanLibDict();
1034}
1035
Note: See TracBrowser for help on using the repository browser.