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

Last change on this file since 496 was 496, checked in by dkearney, 16 years ago

added getInt and getBool functions to fortran bindings and test programs.

File size: 24.4 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Library Source
4 *
5 * ======================================================================
6 *  AUTHOR:  Derrick Kearney, Purdue University
7 *  Copyright (c) 2004-2005  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//void rp_lib_put_obj( int* handle,
674//                        char* path,
675//                        int* valHandle,
676//                        int* append,
677//                        int path_len
678//                      )
679//{
680//    std::string inPath = "";
681//    RpLibrary* lib = NULL;
682//
683//    // inPath = null_terminate(path,path_len);
684//    inPath = std::string(path,path_len);
685//
686//    /*
687//    if (inPath) {
688//        path_len = strlen(inPath) + 1;
689//    }
690//    */
691//
692//    if ((handle) && (*handle != 0)) {
693//        lib = getObject_Lib(*handle);
694//       
695//        if (lib) {
696//            // rpPut(lib, inPath, inValue, inId, *append);
697//            lib->put(inPath,inValue,"",*append);
698//        }
699//    }
700//
701//    /*
702//    rp_lib_put_id_obj(handle,inPath,valHandle,NULL,append,path_len,0);
703//
704//    if (inPath) {
705//        free(inPath);
706//        inPath = NULL;
707//    }
708//    */
709//
710//}
711
712/*
713void rp_lib_put_id_obj ( int* handle,
714                        char* path,
715                        int* valHandle,
716                        char* id,
717                        int* append,
718                        int path_len,
719                        int id_len
720                      )
721{
722    PyObject* lib = NULL;
723    PyObject* value = NULL;
724
725    char* inPath = NULL;
726    char* inId = NULL;
727
728    inPath = null_terminate(path,path_len);
729    inId = null_terminate(id,id_len);
730
731    if (rapptureStarted) {
732        if ((handle) && (*handle != 0)) {
733            lib = getObject_Lib(*handle);
734            value = getObject_Lib(*valHandle);
735
736            if (lib && value) {
737                // retObj is a borrowed object
738                // whose contents must not be modified
739                rpPutObj(lib, inPath, value, inId, *append);
740            }
741        }
742    }
743
744    if (inPath) {
745        free(inPath);
746        inPath = NULL;
747    }
748
749    if (inId) {
750        free(inId);
751        inId = NULL;
752    }
753
754}
755*/
756
757/*
758int rp_lib_remove (int* handle, char* path, int path_len)
759{
760    int newObjHandle = -1;
761
762    PyObject* lib = NULL;
763    PyObject* removedObj = NULL;
764
765    char* inPath = NULL;
766
767    inPath = null_terminate(path,path_len);
768
769    if (rapptureStarted) {
770        if ((handle) && (*handle != 0)) {
771            lib = getObject_Lib(*handle);
772
773            if (lib) {
774                removedObj = rpRemove(lib, inPath);
775
776                if (removedObj) {
777                    newObjHandle = storeObject_Lib(removedObj);
778                    // Py_DECREF(removedObj);
779                }
780
781            }
782        }
783    }
784
785    if (inPath) {
786        free(inPath);
787        inPath = NULL;
788    }
789
790    return newObjHandle;
791}
792*/
793
794/*
795int rp_lib_xml_len (int* handle)
796{
797    int length = -1;
798    char* xmlText = NULL;
799
800    PyObject* lib = NULL;
801
802    if (rapptureStarted) {
803        if ((handle) && (*handle != 0)) {
804            lib = getObject_Lib(*handle);
805
806            if (lib) {
807                // dont modify xmlText, borrowed pointer
808                xmlText = rpXml(lib);
809
810                if (xmlText) {
811                    length = strlen(xmlText) + 1;
812                    free(xmlText);
813                    // printf("len = :%d:\n",length);
814                }
815            }
816        }
817    }
818    return length;
819}
820*/
821
822/**********************************************************************/
823// FUNCTION: rp_lib_write_xml()
824/// Write the xml text into a file.
825/**
826 * \sa {rp_result}
827 */
828int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
829{
830    int retVal = -1;
831    RpLibrary* lib = NULL;
832    std::string inOutFile = "";
833    std::string xmlText = "";
834    std::fstream file;
835
836    inOutFile = null_terminate_str(outFile, outFile_len);
837
838    if (!inOutFile.empty() ) {
839        file.open(inOutFile.c_str(),std::ios::out);
840    }
841
842    if ( file.is_open() ) {
843        if ((handle) && (*handle != 0)) {
844            lib = getObject_Lib(*handle);
845
846            if (lib) {
847                xmlText = lib->xml();
848                if (!xmlText.empty()) {
849                    file << xmlText;
850                    retVal = 0;
851                }
852            }
853        }
854
855        file.close();
856    }
857
858    return retVal;
859}
860
861/**********************************************************************/
862// FUNCTION: rp_lib_xml()
863/// Return this node's xml text
864/**
865 */
866void  rp_lib_xml(int* handle, char* retText, int retText_len)
867{
868    std::string xmlText = "";
869
870    RpLibrary* lib = NULL;
871
872    if ((handle) && (*handle != 0)) {
873        lib = getObject_Lib(*handle);
874
875        if (lib) {
876            xmlText = lib->xml();
877            if (!xmlText.empty()) {
878                fortranify(xmlText.c_str(), retText, retText_len);
879            }
880        }
881    }
882}
883
884/**********************************************************************/
885// FUNCTION: rp_lib_node_comp()
886/// Return this node's component name
887/**
888 */
889void rp_lib_node_comp ( int* handle, char* retText, int retText_len ) {
890
891    std::string retStr = "";
892    RpLibrary* node = NULL;
893
894    if ((handle) && (*handle != 0)) {
895        node = getObject_Lib(*handle);
896
897        if (node) {
898            retStr = node->nodeComp();
899            if (!retStr.empty()) {
900                fortranify(retStr.c_str(), retText, retText_len);
901            }
902        }
903    }
904}
905
906/**********************************************************************/
907// FUNCTION: rp_lib_node_type()
908/// Return this node's type
909/**
910 */
911void rp_lib_node_type ( int* handle, char* retText, int retText_len ) {
912
913    std::string retStr = "";
914    RpLibrary* node = NULL;
915
916    if ((handle) && (*handle != 0)) {
917        node = getObject_Lib(*handle);
918
919        if (node) {
920            retStr = node->nodeType();
921            if (!retStr.empty()) {
922                fortranify(retStr.c_str(), retText, retText_len);
923            }
924        }
925    }
926}
927
928/**********************************************************************/
929// FUNCTION: rp_lib_node_id()
930/// Return this node's id.
931/**
932 */
933void rp_lib_node_id ( int* handle, char* retText, int retText_len ) {
934
935    std::string retStr = "";
936    RpLibrary* node = NULL;
937
938    if ((handle) && (*handle != 0)) {
939        node = getObject_Lib(*handle);
940
941        if (node) {
942            retStr = node->nodeId();
943            if (!retStr.empty()) {
944                fortranify(retStr.c_str(), retText, retText_len);
945            }
946        }
947    }
948}
949
950/**********************************************************************/
951// FUNCTION: rp_result()
952/// Write xml text to a run.xml file and signal the program has completed
953/**
954 */
955void rp_result(int* handle) {
956    RpLibrary* lib = NULL;
957
958    if (handle && *handle != 0) {
959        lib = getObject_Lib(*handle);
960        if (lib) {
961            lib->result();
962        }
963    }
964
965    // do no delete this, still working on testing this
966    cleanLibDict();
967}
968
Note: See TracBrowser for help on using the repository browser.