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

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