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

Last change on this file since 93 was 93, checked in by dkearney, 17 years ago
  1. corrected c interface language binding function names so they are

consistant with previous c interface function names

  1. separated object dictionaries from fortran code, placed them in

the RpBindings.[h,cc] files so matlab bindings can use them too.

  1. adjusted makefile to compile RpBindings code
File size: 20.5 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Library Source
4 *
5 * ======================================================================
6 *  AUTHOR:  Derrick Kearney, Purdue University
7 *  Copyright (c) 2005
8 *  Purdue Research Foundation, West Lafayette, IN
9 * ======================================================================
10 */
11
12#include "RpLibraryFInterface.h"
13#include "RpBindingsDict.h"
14#include "RpLibraryFStubs.c"
15
16int rp_lib(const char* filePath, int filePath_len)
17{
18    RpLibrary* lib = NULL;
19    int handle = -1;
20    std::string inFilePath = "";
21
22    inFilePath = null_terminate_str(filePath, filePath_len);
23
24    // create a RapptureIO object and store in dictionary
25    lib = new RpLibrary(inFilePath);
26
27    if (lib) {
28        handle = storeObject_Lib(lib);
29    }
30
31    return handle;
32}
33
34int rp_lib_element_obj(int* handle,     /* integer handle of library */
35                          char* path,     /* null terminated path */
36                          int path_len
37                        )
38{
39    int newObjHandle = -1;
40
41    std::string inPath = "";
42
43    RpLibrary* lib = NULL;
44    RpLibrary* retObj = NULL;
45
46    inPath = null_terminate_str(path,path_len);
47
48    if ((handle) && (*handle != 0)) {
49        lib = getObject_Lib(*handle);
50        if (lib) {
51            retObj = lib->element(inPath);
52
53            if (retObj) {
54                newObjHandle = storeObject_Lib(retObj);
55            }
56        }
57    }
58
59    return newObjHandle;
60}
61
62void rp_lib_element_comp( int* handle, /* integer handle of library */
63                            char* path,      /* null terminated path */
64                            char* retText,   /* return buffer for fortran*/
65                            int path_len,
66                            int retText_len /* length of return text buffer */
67                          )
68{
69    std::string inPath = "";
70    RpLibrary* lib = NULL;
71    std::string retStr = "";
72
73    inPath = null_terminate_str(path,path_len);
74
75    lib = getObject_Lib(*handle);
76
77    if (lib) {
78        retStr = lib->element(inPath)->nodeComp();
79        if (!retStr.empty()) {
80            fortranify(retStr.c_str(),retText,retText_len);
81        }
82    }
83
84}
85
86void rp_lib_element_id(   int* handle, /* integer handle of library */
87                            char* path,      /* null terminated path */
88                            char* retText,   /* return buffer for fortran*/
89                            int path_len,
90                            int retText_len /* length of return text buffer */
91                        )
92{
93    std::string inPath = "";
94    RpLibrary* lib = NULL;
95    std::string retStr = "";
96
97    inPath = null_terminate_str(path,path_len);
98
99    lib = getObject_Lib(*handle);
100
101    if (lib) {
102        retStr = lib->element(inPath)->nodeId();
103        if (!retStr.empty()) {
104            fortranify(retStr.c_str(),retText,retText_len);
105        }
106    }
107}
108
109void rp_lib_element_type( int* handle, /* integer handle of library */
110                            char* path,      /* search path inside 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)->nodeType();
126        fortranify(retStr.c_str(),retText,retText_len);
127    }
128}
129
130int rp_lib_children (   int* handle, /* integer handle of library */
131                        char* path, /* search path of the xml */
132                        int* childHandle, /*integer hanlde of last returned child*/
133                        int path_len  /* length of the search path buffer */
134                    ) {
135
136    std::string inPath = "";
137    RpLibrary* lib = NULL;
138    RpLibrary* childNode = NULL;
139    int newObjHandle = -1;
140
141    inPath = null_terminate_str(path,path_len);
142
143    if (handle && (*handle >= 0) ) {
144        lib = getObject_Lib(*handle);
145        if (lib) {
146            if (*childHandle < 1) {
147                // check to see if there were any previously returned children
148                childNode = getObject_Lib(*childHandle);
149            }
150
151            // call the children base method
152            childNode = lib->children(path,childNode);
153
154            // store the childNode in the dictionary.
155            //
156            // because the base method is using static memory to get store the
157            // children we should be able to chekc and see if the childHandle
158            // was valud.
159            // if so, then we can just return the childHandle back to the user
160            // if not, store the object in the dictionary and return the new
161            // handle.
162
163            if (childNode) {
164                if (*childHandle < 1) {
165                    newObjHandle = storeObject_Lib(childNode);
166                }
167                else {
168                    newObjHandle = *childHandle;
169                }
170            }
171        }
172    }
173
174    return newObjHandle;
175
176}
177
178/*
179int rp_lib_child_num( int* handle,
180                         char* path,
181                         int path_len
182                       )
183{
184    int numChildren = 0;
185
186    PyObject* lib = NULL;
187    PyObject* list = NULL;
188    char* inPath = NULL;
189
190    inPath = null_terminate(path,path_len);
191
192    if (rapptureStarted) {
193        if ((handle) && (*handle != 0)) {
194            lib = getObject_Lib(*handle);
195
196            if (lib) {
197                list = rpChildren_f(lib, inPath, "type");
198                if (list) {
199                    numChildren = PyList_Size(list);
200                    Py_DECREF(list);
201                }
202                else {
203
204                }
205            }
206        }
207    }
208
209    if (inPath) {
210        free(inPath);
211        inPath = NULL;
212    }
213
214    return numChildren;
215
216}
217*/
218
219//int rp_lib_child_comp (   int* handle,    /* integer handle of library */
220//                            char* path,     /* DOM path of requested object */
221//                            char* type,     /* specific name of element */
222//                            int* childNum,  /* child number for iteration */
223//                            char* retText,  /* buffer to store return text */
224//                            int path_len,   /* length of path */
225//                            int type_len,   /* length of type */
226//                            int retText_len /* length of return text buffer */
227//                       )
228/*
229{
230    int retVal = 0;
231
232    char* inPath = NULL;
233    char* inType = NULL;
234
235    inPath = null_terminate(path,path_len);
236    inType = null_terminate(type,type_len);
237
238    if (inPath) {
239        path_len = strlen(inPath) + 1;
240    }
241    else {
242        path_len = 0;
243    }
244
245    if (inType) {
246        type_len = strlen(inType) + 1;
247    }
248    else {
249        type_len = 0;
250    }
251
252    retVal = rp_lib_child_str( handle,
253                                 inPath,
254                                 "component",
255                                 inType,
256                                 childNum,
257                                 retText,
258                                 path_len,
259                                 10,
260                                 type_len,
261                                 retText_len
262                               );
263
264    if (inPath) {
265        free(inPath);
266        inPath = NULL;
267    }
268
269    if (inType) {
270        free(inType);
271        inType = NULL;
272    }
273
274    return retVal;
275}
276*/
277
278//int rp_lib_child_id(   int* handle,    /* integer handle of library */
279//                          char* path,     /* DOM path of requested object */
280//                          char* type,     /* specific name of element */
281//                          int* childNum,  /* child number for iteration */
282//                          char* retText,  /* buffer to store return text */
283//                          int path_len,   /* length of path */
284//                          int type_len,   /* length of type */
285//                          int retText_len /* length of return text buffer */
286//                       )
287/*
288{
289    int retVal = 0;
290    char* inPath = NULL;
291    char* inType = NULL;
292
293    inPath = null_terminate(path,path_len);
294    inType = null_terminate(type,type_len);
295
296    if (inPath) {
297        path_len = strlen(inPath) + 1;
298    }
299    else {
300        path_len = 0;
301    }
302
303    if (inType) {
304        type_len = strlen(inType) + 1;
305    }
306    else {
307        type_len = 0;
308    }
309
310    retVal = rp_lib_child_str( handle,
311                                 inPath,
312                                 "id",
313                                 inType,
314                                 childNum,
315                                 retText,
316                                 path_len,
317                                 3,
318                                 type_len,
319                                 retText_len
320                               );
321
322    if (inPath) {
323        free(inPath);
324        inPath = NULL;
325    }
326
327    if (inType) {
328        free(inType);
329        inType = NULL;
330    }
331
332    return retVal;
333}
334*/
335
336//int rp_lib_child_type (   int* handle,    /* integer handle of library */
337//                            char* path,     /* DOM path of requested object */
338//                            char* type,     /* specific name of element */
339//                            int* childNum,  /* child number for iteration */
340//                            char* retText,  /* buffer to store return text */
341//                            int path_len,   /* length of path */
342//                            int type_len,   /* length of type */
343//                            int retText_len /* length of return text buffer */
344//                       )
345/*
346{
347    int retVal = 0;
348    char* inPath = NULL;
349    char* inType = NULL;
350
351    inPath = null_terminate(path,path_len);
352    inType = null_terminate(type,type_len);
353
354    if (inPath) {
355        path_len = strlen(inPath) + 1;
356    }
357    else {
358        path_len = 0;
359    }
360
361    if (inType) {
362        type_len = strlen(inType) + 1;
363    }
364    else {
365        type_len = 0;
366    }
367
368    retVal = rp_lib_child_str( handle,
369                                 inPath,
370                                 "type",
371                                 inType,
372                                 childNum,
373                                 retText,
374                                 path_len,
375                                 5,
376                                 type_len,
377                                 retText_len
378                               );
379
380    if (inPath) {
381        free(inPath);
382        inPath = NULL;
383    }
384
385    if (inType) {
386        free(inType);
387        inType = NULL;
388    }
389
390    return retVal;
391}
392*/
393
394/*
395int rp_lib_child_obj ( int* handle,
396                            char* path,
397                            char* type,
398                            int path_len,
399                            int type_len
400                          )
401{
402    int newObjHandle = -1;
403
404    PyObject* lib = NULL;
405    PyObject* list = NULL;
406
407    char* inPath = NULL;
408    char* inType = NULL;
409
410    inPath = null_terminate(path,path_len);
411    inType = null_terminate(type,type_len);
412
413    if (rapptureStarted) {
414        if ((handle) && (*handle != 0)) {
415            lib = getObject_Lib(*handle);
416
417            if (lib) {
418                list = rpChildren_f(lib, inPath, "object");
419                if (list) {
420                    // store the whole list,
421                    // need to make a way to read the nodes
422                    newObjHandle = storeObject_Lib(list);
423                    // Py_DECREF(list);
424                }
425                else {
426
427                }
428            }
429        }
430    }
431
432    if (inPath) {
433        free(inPath);
434        inPath = NULL;
435    }
436
437    if (inType) {
438        free(inType);
439        inType = NULL;
440    }
441
442    return newObjHandle;
443
444}
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 = getObject_Lib(*handle);
464
465        if (lib) {
466            xmlText = lib->getString(inPath);
467            if (!xmlText.empty()) {
468                fortranify(xmlText.c_str(),retText,retText_len);
469            }
470
471        }
472    }
473}
474
475double rp_lib_get_double( int* handle,   /* integer handle of library */
476                            char* path,    /* null terminated path */
477                            int path_len
478                          )
479{
480    double retVal = 0.0;
481
482    RpLibrary* lib = NULL;
483
484    std::string inPath = "";
485
486    inPath = null_terminate_str(path,path_len);
487
488    if ((handle) && (*handle != 0)) {
489        lib = getObject_Lib(*handle);
490
491        if (lib) {
492            retVal = lib->getDouble(inPath);
493        }
494    }
495
496    return retVal;
497}
498
499
500void rp_lib_put_str( int* handle,
501                        char* path,
502                        char* value,
503                        int* append,
504                        int path_len,
505                        int value_len
506                      )
507{
508    std::string inPath = "";
509    std::string inValue = "";
510    RpLibrary* lib = NULL;
511
512    inPath = null_terminate_str(path,path_len);
513    inValue = null_terminate_str(value,value_len);
514
515    if ((handle) && (*handle != 0)) {
516        lib = getObject_Lib(*handle);
517
518        if (lib) {
519            lib->put(inPath,inValue,"",*append);
520        }
521    }
522
523    return;
524
525}
526
527
528void rp_lib_put_id_str ( int* handle,
529                        char* path,
530                        char* value,
531                        char* id,
532                        int* append,
533                        int path_len,
534                        int value_len,
535                        int id_len
536                      )
537{
538    RpLibrary* lib = NULL;
539
540    std::string inPath = "";
541    std::string inValue = "";
542    std::string inId = "";
543
544    inPath = null_terminate_str(path,path_len);
545    inValue = null_terminate_str(value,value_len);
546    inId = null_terminate_str(id,id_len);
547
548    if ((handle) && (*handle != 0)) {
549        lib = getObject_Lib(*handle);
550
551        if (lib) {
552            lib->put(inPath,inValue,inId,*append);
553        }
554    }
555
556}
557
558//void rp_lib_put_obj( int* handle,
559//                        char* path,
560//                        int* valHandle,
561//                        int* append,
562//                        int path_len
563//                      )
564//{
565//    std::string inPath = "";
566//    RpLibrary* lib = NULL;
567//
568//    // inPath = null_terminate(path,path_len);
569//    inPath = std::string(path,path_len);
570//
571//    /*
572//    if (inPath) {
573//        path_len = strlen(inPath) + 1;
574//    }
575//    */
576//
577//    if ((handle) && (*handle != 0)) {
578//        lib = getObject_Lib(*handle);
579//       
580//        if (lib) {
581//            // rpPut(lib, inPath, inValue, inId, *append);
582//            lib->put(inPath,inValue,"",*append);
583//        }
584//    }
585//
586//    /*
587//    rp_lib_put_id_obj(handle,inPath,valHandle,NULL,append,path_len,0);
588//
589//    if (inPath) {
590//        free(inPath);
591//        inPath = NULL;
592//    }
593//    */
594//
595//}
596
597/*
598void rp_lib_put_id_obj ( int* handle,
599                        char* path,
600                        int* valHandle,
601                        char* id,
602                        int* append,
603                        int path_len,
604                        int id_len
605                      )
606{
607    PyObject* lib = NULL;
608    PyObject* value = NULL;
609
610    char* inPath = NULL;
611    char* inId = NULL;
612
613    inPath = null_terminate(path,path_len);
614    inId = null_terminate(id,id_len);
615
616    if (rapptureStarted) {
617        if ((handle) && (*handle != 0)) {
618            lib = getObject_Lib(*handle);
619            value = getObject_Lib(*valHandle);
620
621            if (lib && value) {
622                // retObj is a borrowed object
623                // whose contents must not be modified
624                rpPutObj(lib, inPath, value, inId, *append);
625            }
626        }
627    }
628
629    if (inPath) {
630        free(inPath);
631        inPath = NULL;
632    }
633
634    if (inId) {
635        free(inId);
636        inId = NULL;
637    }
638
639}
640*/
641
642/*
643int rp_lib_remove (int* handle, char* path, int path_len)
644{
645    int newObjHandle = -1;
646
647    PyObject* lib = NULL;
648    PyObject* removedObj = NULL;
649
650    char* inPath = NULL;
651
652    inPath = null_terminate(path,path_len);
653
654    if (rapptureStarted) {
655        if ((handle) && (*handle != 0)) {
656            lib = getObject_Lib(*handle);
657
658            if (lib) {
659                removedObj = rpRemove(lib, inPath);
660
661                if (removedObj) {
662                    newObjHandle = storeObject_Lib(removedObj);
663                    // Py_DECREF(removedObj);
664                }
665
666            }
667        }
668    }
669
670    if (inPath) {
671        free(inPath);
672        inPath = NULL;
673    }
674
675    return newObjHandle;
676}
677*/
678
679/*
680int rp_lib_xml_len (int* handle)
681{
682    int length = -1;
683    char* xmlText = NULL;
684
685    PyObject* lib = NULL;
686
687    if (rapptureStarted) {
688        if ((handle) && (*handle != 0)) {
689            lib = getObject_Lib(*handle);
690
691            if (lib) {
692                // dont modify xmlText, borrowed pointer
693                xmlText = rpXml(lib);
694
695                if (xmlText) {
696                    length = strlen(xmlText) + 1;
697                    free(xmlText);
698                    // printf("len = :%d:\n",length);
699                }
700            }
701        }
702    }
703    return length;
704}
705*/
706
707int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
708{
709    int retVal = -1;
710    RpLibrary* lib = NULL;
711    std::string inOutFile = "";
712    std::string xmlText = "";
713    std::fstream file;
714
715    inOutFile = null_terminate_str(outFile, outFile_len);
716
717    if (!inOutFile.empty() ) {
718        file.open(inOutFile.c_str(),std::ios::out);
719    }
720
721    if ( file.is_open() ) {
722        if ((handle) && (*handle != 0)) {
723            lib = getObject_Lib(*handle);
724
725            if (lib) {
726                xmlText = lib->xml();
727                if (!xmlText.empty()) {
728                    file << xmlText;
729                    retVal = 0;
730                }
731            }
732        }
733
734        file.close();
735    }
736
737    return retVal;
738}
739
740void  rp_lib_xml(int* handle, char* retText, int retText_len)
741{
742    std::string xmlText = "";
743
744    RpLibrary* lib = NULL;
745
746    if ((handle) && (*handle != 0)) {
747        lib = getObject_Lib(*handle);
748
749        if (lib) {
750            xmlText = lib->xml();
751            if (!xmlText.empty()) {
752                fortranify(xmlText.c_str(), retText, retText_len);
753            }
754        }
755    }
756}
757
758void rp_lib_node_comp ( int* handle, char* retText, int retText_len ) {
759
760    std::string retStr = "";
761    RpLibrary* node = NULL;
762
763    if ((handle) && (*handle != 0)) {
764        node = getObject_Lib(*handle);
765
766        if (node) {
767            retStr = node->nodeComp();
768            if (!retStr.empty()) {
769                fortranify(retStr.c_str(), retText, retText_len);
770            }
771        }
772    }
773}
774
775void rp_lib_node_type ( int* handle, char* retText, int retText_len ) {
776
777    std::string retStr = "";
778    RpLibrary* node = NULL;
779
780    if ((handle) && (*handle != 0)) {
781        node = getObject_Lib(*handle);
782
783        if (node) {
784            retStr = node->nodeType();
785            if (!retStr.empty()) {
786                fortranify(retStr.c_str(), retText, retText_len);
787            }
788        }
789    }
790}
791
792void rp_lib_node_id ( int* handle, char* retText, int retText_len ) {
793
794    std::string retStr = "";
795    RpLibrary* node = NULL;
796
797    if ((handle) && (*handle != 0)) {
798        node = getObject_Lib(*handle);
799
800        if (node) {
801            retStr = node->nodeId();
802            if (!retStr.empty()) {
803                fortranify(retStr.c_str(), retText, retText_len);
804            }
805        }
806    }
807}
808
809void rp_quit()
810{
811
812    // clean up the dictionary
813
814    RpDictEntry DICT_TEMPLATE_L *hPtr;
815    // RpDictIterator DICT_TEMPLATE iter(fortObjDict_Lib);
816    // should rp_quit clean up the dict or some function in RpBindingsCommon.h
817    RpDictIterator DICT_TEMPLATE_L iter(ObjDict_Lib);
818
819    hPtr = iter.first();
820
821    while (hPtr) {
822        // Py_DECREF(*(hPtr->getValue()));
823        hPtr->erase();
824        hPtr = iter.next();
825    }
826
827    // if (fortObjDict_Lib.size()) {
828    if (ObjDict_Lib.size()) {
829        // probably want to change the warning sometime
830        // printf("\nWARNING: internal dictionary is not empty..deleting\n");
831    }
832
833}
834
835void rp_result(int* handle) {
836    RpLibrary* lib = NULL;
837
838    if (handle && *handle != 0) {
839        lib = getObject_Lib(*handle);
840        if (lib) {
841            lib->result();
842        }
843    }
844}
845
Note: See TracBrowser for help on using the repository browser.